This is a post I co-wrote with Douglas Gresham. Douglas is a software engineer at Google, who blogs at www.douglasgresham.co.uk (less often than he should, go bug him for updates).
I’m a graduate student, though I firmly believe that great programmers are not the result of university courses in programming. But university courses take us in, with no idea of what we’re doing and eventually spit us out, mediocre or – hopefully – competent, programmers. And then we’ll go out into the world, where we really master our art. Hopefully.
Going in to university knowing a little bit of C, I came out knowing a moderate amount of Java, some Python, some Haskell, some more C, a little of ML, Prolog and javascript, and very little (though more than I think anyone should have to know) of Tcl. Coming out of grad school, I think I’m a better programmer. Not because I’ve learnt more languages, or because anyone’s sat me down and taught me anything new, although reading Effective Java definitely helped, but because I’m more confident.
For some reason, I’ve ended up doing a lot of teaching over the past 4 years or so. And I’ve come to think that the difference between the mediocre and the competent programmer is confidence. When we take an assignment, a clearly defined task with a definite solution, believing that we can work out the answer is the most crucial thing to succeeding. I wonder if this is related to there being fewer women in computer science, as women are often less confident (also this article).
I’ve seen this not just with my students, who sometimes email me checking their correct answer because they are shocked they happened upon it, but with my own experience. If there was one thing that stopped me achieving my potential during the first years of my undergrad, it was my lack of confidence in my own abilities. I felt that I was at the bottom of the pack, but since I’ve come to realize that that was mostly in terms of arrogance.
Not that I advocate being arrogant – but having a little more faith in yourself might make a big difference, it has for me at least. If it takes 10 years to learn to program, by my calculations I’m less than half way there. Now, I can’t wait to go out into the real world so that I can make the progression from competant to good, and I hope eventually – great.
My friend Dig makes me believe this is possible, and his thoughts on what makes programmers great are below.
Having been living in the Real World(tm) for a couple of years now, I’m acutely aware that the rules are somewhat different than at university. You’re not working on self-contained projects for your own grades any more, and you’re almost certainly working with people who are smarter and more experienced than you are (at least to start with). Out here, confidence still matters, but you have to ground it in something – it’s not for nothing that the Dunning-Kruger Effect is reflected in new grad CVs more than those of seasoned vets (you are not a Java expert if your name isn’t Josh Bloch, I’m afraid!).
I’m firmly of the opinion that programming confidence should come only from working with great programmers. The reason for this is pretty simple: programming – or more accurately, software engineering – is about putting together complex interactions based on a whole heap of assumptions you have, be they about users, the type of input you’re going to get, the systems you’re interacting with, the performance of the hardware you’re running on, and so forth. Assumptions have a nasty habit of being completely wrong, but non-obviously such that they come back to bite you much later on.
Working with other programmers means having to justify your assumptions or revise them in light of others’ opinions. Working with great programmers means you have to do a damn good job of that justification, and that the revisions you make are going to be of a higher quality and frequency. As you do this, with any luck the ratio of justification to revision improves, and with it comes deserved confidence. It should never go to 1:0 though, that would be terrible both for personal development and humility. If it does, seek out more great programmers to disagree with pronto!
I say ‘working’ with other programmers, although I should really say ‘interacting’. Manipulating the same codebase, having to use each others’ designs and – if you get the chance – pair programming are definitely the best ways to achieve this, but the discussion over a mailing list or around a table (coffee in hand, naturally) are equally worthy, especially since you can balance the daily make-it-work hackery with the conceptual ‘ideal world’ solution. One of the best programmers I know is completely addicted to Stack Overflow – I’m sure the two factors feed into each other hugely.
I’d also qualify ‘programmers’ as being explicitly plural. One other opinion is never enough, particularly given the predisposition of compscis to get over-enthusiastic about the One True Path to code nirvana. It’s the same with design patterns, IDEs, languages and so on (every object-oriented coder should be made to write some functional code), but vital with others’ opinions. Many inputs makes it easier to spot the zealots and avoid becoming one yourself – or at least being able to justify it more competently!
Finally, there’s the bootstrap – you can’t sit anyone next to a great programmer and expect greatness to transmit via osmosis. This is probably worth a whole book in itself, but I’d say solid core computer science (especially algorithms and data structures, but I would say that as it’s my thing), a flair for design and an ability to break down your assumptions, both technically and psychologically, are all key (try Test Driven Development, even if you don’t stick with it long-term as it teaches you those).
Of course, this is all one opinion from someone a long way off of greatness, so by my own logic you should ignore me. Ah well.