Holding a Program in One's Head (2007)

August 2007

A good programmer working intensively on his own code can hold itin his mind the way a mathematician holds a problem he's workingon. Mathematicians don't answer questions by working them out onpaper the way schoolchildren are taught to. They do more in theirheads: they try to understand a problem space well enough that theycan walk around it the way you can walk around the memory of thehouse you grew up in. At its best programming is the same. Youhold the whole program in your head, and you can manipulate it atwill.

That's particularly valuable at the start of a project, becauseinitially the most important thing is to be able to change whatyou're doing. Not just to solve the problem in a different way,but to change the problem you're solving.

Your code is your understanding of the problem you're exploring.So it's only when you have your code in your head that you reallyunderstand the problem.

It's not easy to get a program into your head. If you leave aproject for a few months, it can take days to really understand itagain when you return to it. Even when you're actively working ona program it can take half an hour to load into your head when youstart work each day. And that's in the best case. Ordinaryprogrammers working in typical office conditions never enter thismode. Or to put it more dramatically, ordinary programmers workingin typical office conditions never really understand the problemsthey're solving.

Even the best programmers don't always have the whole program they'reworking on loaded into their heads. But there are things you cando to help:

1. Avoid distractions.Distractions are bad for many types of work, but especially bad for programming, because programmers tend to operate at the limit of the detail they can handle.
   The danger of a distraction depends not on how long it is, but on how much it scrambles your brain. A programmer can leave the office and go and get a sandwich without losing the code in his head. But the wrong kind of interruption can wipe your brain in 30 seconds.
   Oddly enough, scheduled distractions may be worse than unscheduled ones. If you know you have a meeting in an hour, you don't even start working on something hard.
2. Work in long stretches.Since there's a fixed cost each time you start working on a program, it's more efficient to work in a few long sessions than many short ones. There will of course come a point where you get stupid because you're tired. This varies from person to person. I've heard of people hacking for 36 hours straight, but the most I've ever been able to manage is about 18, and I work best in chunks of no more than 12.
   The optimum is not the limit you can physically endure. There's an advantage as well as a cost of breaking up a project. Sometimes when you return to a problem after a rest, you find your unconscious mind has left an answer waiting for you.
3. Use succinct languages.Morepowerful programming languages make programs shorter. And programmers seem to think of programs at least partially in the language they're using to write them. The more succinct the language, the shorter the program, and the easier it is to load and keep in your head.
   You can magnify the effect of a powerful language by using a style called bottom-up programming, where you write programs in multiple layers, the lower ones acting as programming languages for those above. If you do this right, you only have to keep the topmost layer in your head.
4. Keep rewriting your program.Rewriting a program often yields a cleaner design. But it would have advantages even if it didn't: you have to understand a program completely to rewrite it, so there is no better way to get one loaded into your head.
5. Write rereadable code.All programmers know it's good to write readable code. But you yourself are the most important reader. Especially in the beginning; a prototype is a conversation with yourself. And when writing for yourself you have different priorities. If you're writing for other people, you may not want to make code too dense. Some parts of a program may be easiest to read if you spread things out, like an introductory textbook. Whereas if you're writing code to make it easy to reload into your head, it may be best to go for brevity.
6. Work in small groups.When you manipulate a program in your head, your vision tends to stop at the edge of the code you own. Other parts you don't understand as well, and more importantly, can't take liberties with. So the smaller the number of programmers, the more completely a project can mutate. If there's just one programmer, as there often is at first, you can do all-encompassing redesigns.
7. Don't have multiple people editing the same piece of code.You never understand other people's code as well as your own. No matter how thoroughly you've read it, you've only read it, not written it. So if a piece of code is written by multiple authors, none of them understand it as well as a single author would.
   And of course you can't safely redesign something other people are working on. It's not just that you'd have to ask permission. You don't even let yourself think of such things. Redesigning code with several authors is like changing laws; redesigning code you alone control is like seeing the other interpretation of an ambiguous image.
   If you want to put several people to work on a project, divide it into components and give each to one person.
8. Start small.A program gets easier to hold in your head as you become familiar with it. You can start to treat parts as black boxes once you feel confident you've fully explored them. But when you first start working on a project, you're forced to see everything. If you start with too big a problem, you may never quite be able to encompass it. So if you need to write a big, complex program, the best way to begin may not be to write a spec for it, but to write a prototype that solves a subset of the problem. Whatever the advantages of planning, they're often outweighed by the advantages of being able to keep a program in your head.

It's striking how often programmers manage to hit all eight pointsby accident. Someone has an idea for a new project, but becauseit's not officially sanctioned, he has to do it in off hours—whichturn out to be more productive because there are no distractions.Driven by his enthusiasm for the new project he works on it formany hours at a stretch. Because it's initially just anexperiment, instead of a "production" language he uses a mere"scripting" language—which is in fact far more powerful. Hecompletely rewrites the program several times; that wouldn't bejustifiable for an official project, but this is a labor of loveand he wants it to be perfect. And since no one is going to seeit except him, he omits any comments except the note-to-self variety.He works in a small group perforce, because he either hasn't toldanyone else about the idea yet, or it seems so unpromising that noone else is allowed to work on it. Even if there is a group, theycouldn't have multiple people editing the same code, because itchanges too fast for that to be possible. And the project startssmall because the idea issmall at first; he just has some coolhack he wants to try out.

Even more striking are the number of officially sanctioned projectsthat manage to do all eight things wrong. In fact, if you look atthe way software gets written in most organizations, it's almostas if they were deliberately trying to do things wrong. In a sense,they are. One of the defining qualities of organizations sincethere have been such a thing is to treat individuals as interchangeableparts. This works well for more parallelizable tasks, like fightingwars. For most of history a well-drilled army of professionalsoldiers could be counted on to beat an army of individual warriors,no matter how valorous. But having ideas is not very parallelizable.And that's what programs are: ideas.

It's not merely true that organizations dislike the idea of dependingon individual genius, it's a tautology. It's part of the definitionof an organization not to. Of our current concept of an organization,at least.

Maybe we could define a new kind of organization that combined theefforts of individuals without requiring them to be interchangeable.Arguably a market is such a form of organization, though it may bemore accurate to describe a market as a degenerate case—as whatyou get by default when organization isn't possible.

Probably the best we'll do is some kind of hack, like making theprogramming parts of an organization work differently from the rest.Perhaps the optimal solution is for big companies not even to tryto develop ideas in house, but simply tobuy them. But regardlessof what the solution turns out to be, the first step is to realizethere's a problem. There is a contradiction in the very phrase"software company." The two words are pulling in opposite directions.Any good programmer in a large organization is going to be at oddswith it, because organizations are designed to prevent whatprogrammers strive for.

Good programmersmanage to get a lot done anyway. But often itrequires practically an act of rebellion against the organizationsthat employ them. Perhaps it will help if more people understand that the wayprogrammers behave is driven by the demands of the work they do.It's not because they're irresponsible that they work in long bingesduring which they blow off all other obligations, plunge straight intoprogramming instead of writing specs first, and rewrite code thatalready works. It's not because they're unfriendly that they preferto work alone, or growl at people who pop their head in the doorto say hello. This apparently random collection of annoying habitshas a single explanation: the power of holding a program in one'shead.

Whether or not understanding this can help large organizations, itcan certainly help their competitors. The weakest point in bigcompanies is that they don't let individual programmers do greatwork. So if you're a little startup, this is the place to attackthem. Take on the kind of problems that have to be solved in onebig brain.

Thanksto Sam Altman, David Greenspan, Aaron Iba, Jessica Livingston,Robert Morris, Peter Norvig, Lisa Randall, Emmett Shear, Sergei Tsarev,and Stephen Wolfram for reading drafts of this.