Small Coders, Loosely Joined
The Code4Lib conference is fast approaching and, as people start to spend more time thinking about it, there is the question of how things should be done differently over the coming year. It’s a good question and one that Code4Lib does well to ask itself. Any “organization” that doesn’t question whether it’s doing things as well as it could be is already dead.
I think the question was originally posed on the mailing list as to how much structure Code4Lib should put into place to ensure that these conferences continue to happen (and perhaps grow). The issue has also been framed as a question of how much formality do we want to put into place (and where is the proper intersection between structure and formality)? My gut reaction was that I don’t want much formality and that any structure beyond a list of things that need to get done (and a list of volunteers willing to do them) is too much.
I think this is in part because I see Code4Lib as an experiment. There are plenty of well established (national and regional) organizations that put on conferences year after year (they are very dependable). Code4Lib is, for me, the exact opposite. It is a loose group of people who have gathered around a particular banner (library technology) because it interests us — it is more than just a job or a way to pay the bills (though many people in the Code4Lib cloud work in day jobs that do just that). In the end, though, I don’t need Code4Lib to fulfill any professional obligations and, while I would be sad to see it disappear, I wouldn’t lose any sleep over it either — I don’t see it as a movement.
It is this loose association that keeps me interested and coming back. There are times that I do not feel myself in sync with the group and there are times that I do. It is a relationship that I can take or leave, and I do (over and over again). I do not see Code4Lib as some sort of centralized organization that has a majority opinion. There are, at times, majorities of opinion, but they are no more representative of Code4Lib as a whole than the minority opinions because there is no consistency in them (the majorities) over time. I think this is, in part, because Code4Lib hasn’t, up to this point, been formalized into a “real thing” that needs to take a stand on issues (e.g. has a need to promote a consistent opinion, works as a force in the library community, etc.)
The issue to me, I think, boils down to a question of decentralization/centralization. I’d like to see Code4Lib stay as decentralized as possible. I think a couple years of conferences have taught us that we definitely need some procedures (best practices). We also need a way to recognize people who volunteer to step up and take responsibility for something that needs to get done (for the fun stuff to happen). I think we’ve also learned after a couple of bouts that we would benefit from some code that makes making decisions, as a group, easier.
These to me, though, are more indicators that we need better documentation (and more communication) than they are indicators that we need a centralization of the organization. Both approaches would be valid ways to go… don’t get me wrong. We could document more (put our organizational knowledge into external form) or, just as valid, we could rely on people who would hold offices over a period of years. These are just two different paths. I think whether a person chooses one over the other probably has to do with where s/he sees Code4Lib going in the future (that is what paths are good for after all — or, maybe I should say, “Whether one sees the path as the point or whether there is an attainable destination in mind”).
The David Clark quote seems relevant: “We reject kings, presidents and voting. We believe in rough consensus and running code.” It is dissected in a paper up at W3C:
Open Participation ("We")
citizen engineer: citizen is a contributor to her space (lists, Web, MUD, FAQ)
Consensus. ("... believe in rough consensus ...")
is it good enough, does it merit moving on, are there show stoppers?
No Kings ("... reject kings, presidents and voting.")
consensus mediated by Elders, citizen engineers who built the space and institutions others inhabit.
Running Code / Implementation ("... believe ... in running code.")
all policy is tested by both its support and formulation through implementation
I do think that having the conference mediated by kings (okay, that’s a loaded word isn’t it?) would ensure the successful growth of the Code4Lib conferences more reliably than just having better documentation would. Maybe. But, on the other hand, I’m okay if we have a few failures (e.g., have a conference or two that is a real stinker). We’ll learn from these (with good communication) just like we learn from making programming mistakes or faulty assumptions in our code. If we don’t learn and Code4Lib disappears that’s okay too. It was what it was and lived as long as it was useful.
I think though that creating a centralized structure that manages things from the top down will be a mistake for the group. I like the idea of having the local folks who are going to plan and host the conference take more of the responsibility. This doesn’t mean they have to take it all (especially if they don’t want to). I think this though will give each conference its own flavor (and that’s a good thing). If we rely on a centralized group to make consistent decisions year after year, things will go along smoothly enough but we will lose, in my opinion, some of the uniqueness of the conference (if it can be said to have characteristics after just a couple of years).
Maybe people would prefer the consistency. Maybe people want Code4Lib to become a force in the library community. I don’t. I’m happy (as happy can be) with the other professional organizations. Yes, they have their share of problems, but I don’t think creating a new professional organization is going to solve any of these. Anyway, enough crazy rambling…
Leave a Reply