AUTHOR: Eugene Wallingford
DATE: May 04, 2017 4:07 PM
in The Guardian, writer George Saunders reflects on having
written his first novel after many years writing shorter fiction.
To a first approximation, he found the two experiences to be quite
similar. In particular,
What does an artist do, mostly? She tweaks that which she's
I read this on a day when I had just graded thirty-plus programming
assignments from my junior/senior-level Programming Languages
courses, and this made me think of student programmers. My first
thought was snarky, and only partly tongue-in-cheek: Students write
and then submit. Who has the time or interest to tweak?
My conscience quickly got the better of me, and I admitted that this
was unfair. In a weak moment at the end of a long day, it's easy to
be dismissive and not think about students as people who face all
sorts of pressures both in and out of the classroom. Never forget
my favorite formulation of which is:
Never attribute to malice or stupidity that which can be
explained by moderately rational individuals following
incentives in a complex system of interactions.
Even allowing the snark, my first thought was inaccurate. The code
students submit is often the end result of laborious tweaking. The
thing is, most students tweak only while the code gives incorrect
answers. In the worst case, some students tweak and tweak,
employing an age-old but highly inefficient software development
methodology: Make another change and see if it works.
This realization brought to mind Kent Beck's
Rules of Simple Design:
Most students are under time pressures that make artistry a luxury
good; they are happy to find time to make their code work at all.
If the code passes the tests, it's probably good enough for now.
But there is more to the student's willingness to stop tinkering so
soon than just external pressures. It takes a lot of programming
experience and a fair amount of time to come to even appreciate
Rules 2 through 4. Why does it matter if code reveals the
programmer's intention, in terms of either art or engineering?
What's the big deal about a little duplication? The fewest
elements? -- making that happen takes time that could be spent on
something much more interesting.
I am coming to think of Kent's rules as a sort of
for the development of programming expertise. Students start
at Level 1, happy to write code that achieves its stated purpose.
As they grow, programmers move through the rules, mastering
deeper levels of understanding of design, simplicity, and, yes,
artistry. They don't move through the stages in a purely linear
fashion, but they do tend to master the rules in roughly the
order listed above.
Today is a day of empathy for my novice programmers. As I write
this, they are writing the final exam in my course. I hope that
in a few weeks, after the blur of a busy semester settles in their
minds, they reflect a bit and see that they have made progress as
programmers -- and that they can now ask better questions about the
programming languages they use than they could at the beginning of
- passes the tests
- reveals intention
- has no duplication
- has the fewest elements possible