cheat sheets.

The project begins in the programmer's mind with the beauty of a crystal. I
remember the feel of a system at the early stages of programming, when the
knowledge I am to represent in code seems lovely in its structuredness. For a
time, the world is a calm, mathematical place. Human and machine seem attuned to
a cut-diamond-like state of grace. Once in my life I tried methamphetamine: That
speed high is the only state that approximates the feel of a project at its
inception. Yes, I understand. Yes, it can be done. Yes, how straightforward. Oh
yes. I see.

Then something happens. As the months of coding go on, the irregularities of
human thinking start to emerge. You write some code, and suddenly there are
dark, unspecified areas. All the pages of careful design documents, and still,
between the sentences, something is missing. Human thinking can skip over a
great deal, leap over small misunderstandings, can contain ifs and buts in
untroubled corners of the mind. But the machine has no corners. Despite all the
attempts to see the computer as a brain, the machine has no foreground or
background. It can be programmed to behave as if it were working with
uncertainty, but -- underneath, at the code, at the circuits -- it cannot
simultaneously do something and withhold for later something that remains
unknown. In the painstaking working out of the specification, line by code line,
the programmer confronts an awful, inevitable truth: the ways of human and
machine understanding are disjunct.

Now begins a process of frustration. The programmer goes back to the analysts
with questions, the analysts to the users, the users to their managers, the
managers back to the analysts, the analysts to the programmers. It turns out
that some things are just not understood. No one knows the answers to some
questions. Or worse, there are too many answers. A long list of exceptional
situations is revealed, things that occur very rarely but that occur all the
same. Should these be programmed? Yes, of course. How else will the system do
the work human beings need to accomplish? Details and exceptions accumulate.
Soon the beautiful crystal must be recut. This lovely edge and that are lost.
What began in a state of grace soon reveals itself to be a jumble. The human
mind, as it turns out, is messy.

Gone is the calm, mathematical world. The clear, clean methedrine high is over.
The whole endeavor has become a struggle against disorder. A battle of wills. A
testing of endurance. Requirements muddle up; changes are needed immediately.
Meanwhile, no one has changed the system deadline. The programmer, who needs
clarity, who must talk all day to a machine that demands declarations, hunkers
down into a low-grade annoyance. It is here that the stereotype of the
programmer, sitting in a dim room, growling from behind Coke cans, has its
origins. The disorder of the desk, the floor; the yellow post-it notes
everywhere; the white boards covered with scrawl: all this is the outward
manifestation of the messiness of human thought. The messiness cannot go into
the program; it piles up around the programmer.

Soon the programmer has no choice but to retreat into some private interior
space, closer to the machine, where things can be accomplished. The machine
begins to seem friendlier than the analysts, the users, the managers. The
real-world reflection of the program -- who cares anymore? Guide an X-ray
machine or target a missile; print a budget or a dossier; run a city subway or a
disk-drive read/write arm: it all begins to blur. The system has crossed the
membrane -- the great filter of logic, instruction by instruction -- where it
has been cleansed of its linkages to actual human life.

The goal now is not whatever all the analysts first set out to do; the goal
becomes the creation of the system itself. Any ethics or morals or second
thoughts, any questions or muddles or exceptions, all dissolve into a junky
Nike-mind: Just do it. If I just sit here and code, you think, I can make
something run. When the humans come back to talk changes, I can just run the
program. Show them: Here. Look at this. See? This is not just talk. This runs.
Whatever you might say, whatever the consequences, all you have are words and
what I have is this, this thing I've built, this operational system. Talk all
you want, but this thing here: it works.

From "Close to the Machine" by Ellen Ullman.