We have no idea what we are doing: exclusion in free software culture
The following is a live post which includes some strong statements which I might temper later. If anyone asks, I do know what I’m doing and understand recursion just fine.
There’s an interesting thread on the eightycolumn mailing list on gender and exclusion in free software, which has prompted me to write up some thoughts I’ve been having on why programming cultures have such a problem with diversity.
In particular, I have come to the conclusion that programmers have no idea what they are doing. Actually I think it is generally true; people have no idea what they are doing. We all do things anyway, because knowledge and practice can be embodied in action, rather than being based entirely on theory. But we find this idea uncomfortable somehow, so come up with somewhat arbitrary theories to structure our lives. For example floor traders have algorithms that they follow when making their decisions, but if they take them too seriously the result is a market crash, because they are following models rather than ground truths. (World leaders are also known to externalise their decisions when confronted with the unfathomable, with catastrophic results.)
When it comes to programming, there are all manner of pseudoscientific theories for software development, but humans really lack the powers of introspection to know what programming is and how we do it. That’s a pretty wonderful thought, really, that we can construct these huge systems together without understanding them. However when you’re learning programming, it can result in a pretty scary leap. We have mathematical theory from computer science, and the half-arsed broken metaphors around object orientation, and the constraints of strict interpretations of agile development (which no-one actually adheres to in practice), and learners might get the impression that somehow internalising all this theory is essential before you can start programming. No it isn’t, you learn programming by doing it, not by understanding it! Programs are fundamentally non-understandable.
As an example, I seriously doubt whether we can really grasp the notion of recursion, at least without extensive meditation. But we don’t have to, we just internalise a bunch of heuristics that allow us to feel our way around a problem until we have a solution that works. In the case of recursion, we focus on single cases and terminating conditions, but I don’t think this is understanding recursion, it’s using a computer as cognitive support, to reach beyond our imagination.
Another example is monads, computational constructs often beloved by Haskell programmers. It’s fascinating that those new to Haskell gain an intuition for monads through a lot of practice, then come up with a post-hoc theory to structure that intuition, and then invariably write a tutorial based on that theory. However that tutorial turns out to be useless for everyone else, because the theory structures the intuition (or in Schön’s terms, knowledge-in-action), and without the intuition, the theory is next to useless.
Anyway, returning to my actual point.. To learn programming is to embark on years of practice, learning to engage with the unknowable, while battling with complex and sometimes unhelpful theory. With such barriers to entry, no wonder that it seems so very easy to exclude people from developer communities. Of course this just means we have to try harder, and I think part of this involves rethinking programming culture as something grounded in engaged activity as well as theory.