I’m watching the Future of Programming Languages panel and a point came
up that really resonated with me. To the question, “what is the next big trend
in programming”, Guy Steele said, “Maybe it’s sloppy programming.”

It’s hard not to recoil from that and either deny it, or at least wish it
weren’t true. I believe it is true. I think it’s inevitable, and, unlike
probably most of my peers, I don’t think it’s a bad thing.

What Does Sloppy Mean?

Let me clarify by what I mean “sloppy”. You probably have an intuition, and
it’s probably right, but I’ll throw out some examples:

If you’re programming in Erlang, you’re doing sloppy programming. Instead
of writing the code “right” such that it never fails, you just assume parts
will and try to patch things up afterwards.

If you’re programming in a dynamic language, you’re doing sloppy
programming. Instead of carefully specifying the storage and operations for
each of your values, you just toss them in a property bag. Later, when you
need to work with that data, you assume (or empirically test) that the bits
you need are still stuffed in there somewhere.

If you pass around numbers as strings (or JSON, or XML) even though they
can be more compactly encoded in binary, you’re doing sloppy programming.
If you then parse those back into a native int at some later point and
assume it won’t overflow, you’re really doing sloppy programming.

If you catch an exception instead of programmatically ensuring it cannot
occur, you’re doing sloppy programming.

If you cast to void* or Object or object and back, you’re doing
sloppy programming.

If you’re writing glue code that munges some data so that two programs can
talk to each other instead of defining the One True Format so they can
interoperate directly, you’re doing sloppy programming.

If you retry when an operation times out, you’re doing sloppy programming.

If I wrote that list right and you’re not in academia, odds are you answered
“yes” to at least one of those. These days, we’re all sloppy programmers at
least a little bit.

The Super Science Breakdown

What I’m going to describe here will sound like an analogy, but I think it’s
much closer to being literally true. I believe programming is working its way
through the physical sciences.

With a lot of hand-waving, you can organize the sciences roughly in order of
increasing complexity: math, physics, chemistry, biology, psychology,
sociology. (Or maybe in order of decreasing hubris.) Each of these
sciences takes the subject matter of the previous one and treats it as an
abstraction. To a chemist, subatomic particles just are and they study how
they interact to form chemicals. To a biologist, the organic chemicals just
are, and they study how they interact to form living organisms. Each science
is an aggregation of a more primitive one.

The Digital Universe

Stepping back from the real world, let’s look at the electronic one. The core
idea behind digital computers is that they’re discrete: instead of working
with complex, continuous analog signals, they quantize and decimate that down
to a fixed set of possible values. It’s the ultimate reductionism: the analog
signal running through a wire carries a nearly infinite flow of information,
and we crush that down to just 256 possible values ticking along at a fixed
clock rate.

You can look at this as restarting the complexity progression. We start at the
complexity of chemistry and, using a bunch of clever engineering, we
build a virtual world of data simpler than even basic physics.

Programmer-Physicists

The first programmers were essentially physicists moments after the Big Bang,
studying an artificial cosmos. At the time, the universe was so simple that
all they had to work with were the program equivalents of quarks: ones and
zeroes. Their work resembled particle physics: lots of math, lots of reasoning
from first principles. Lots of building things from scratch.

As time went on and we got farther and farther from the digital Big Bang, the
artificial universe got more complex. Given the computational particles that
our forebears created (numeric representations, data structures, basic
algorithms etc.) we started building more complex systems.

Coder-Chemists

In the early 70s, people started talking about the software crisis: it
became harder and harder to handle the complexity that the expanding software
universe could sustain. Up to now, computers were so simple that you could
write programs one byte at a time. You’d fill your magnetic tape storage
before you filled your head.

As computers got more powerful (and brains didn’t), we reached a tipping point
where our methods of building software were no longer effective. In other
words, we couldn’t make steel and bronze one atom at a time. We needed to
become chemists.

This was such a distinct transition in how software was done that they
considered it a generation change, embodied by so-called third-generation
languages. The stress on those languages wasn’t purity or fine-grained
control. It was abstraction and composability: being able to build software
out of existing parts even at the expense of purity. In other words: what a
chemist does.

With the transition to software chemistry, the idea that you could build
software through pure reason faded to become replaced by soft empiricism. We
stopped asking if the software was right in some Platonic ideal sense and
start tracking the rate of defects. We went from “purity” in the
mathematical sense (it either is or isn’t) to “purity” in the chemical sense
(how pure is this compound?).

Engineer-Entomologists

In the past decade, I think we’ve started stumbling through the next
transition: biology. Software, of course, isn’t anywhere near as complex as a
living thing yet. But it’s starting to reach a level of complexity,
especially on the web where most code is being written today, that it’s more
productive to think of code as an organic material.

Where chemistry is about taking existing building blocks, tearing them apart
and reassembling them, biology generally treats its subjects as more
inviolable. When possible, biologists study living organisms as they are.
Outside of the Island of Dr. Moreau, they refrain from building new animals
from parts. A significant portion of the job of someone working in the life
sciences is simply maintenance: keeping the living organisms in their care
alive and well.

And so it is becoming with software, especially web software. Most web
companies have “programmers” whose sole job is keeping things up and running.
They may not write a single line of code in production beyond test and batch
scripts. They’re practicing software husbandry more than software
engineering.

Even the programmers who are writing production code find their work dirtier
and messier than its ever been. When the code you build your software out of
was just sitting on your disc, it was relatively easy to chop it up into the
pieces you want. Now that the code you deal with is sitting on some other
company’s server hidden behind a web API, it may as well be a living organism.
You can interact with it, and even communicate with it, but only in its
language.

Where before it didn’t make sense to burn CPU cycles converting between
disparate data formats, now its a common part of the job. A good chunk of code
running on servers right now exists just to translate the grunts of one
software animal to the chirps that another understands.

Why the Long Face?

As I see it, that’s what’s going on in the software world. What’s fascinating
to me is how much emotion and morality allegedly rational programmers imbue
that with. Really, there’s no intrinsic rightness or wrongness about any of
this. Simple software is no “wronger” or “righter” than complex software. A
chunk of C code isn’t more “real” than a bash script.

But if you look at how programmers talk about their craft, the exact opposite
is true. Almost any coder knows the archetype of the “real programmer”:
someone who can delve all the way to the quantum level of code.
Meanwhile, programmers in higher-level languages (if you can even call that
“programming”) are sissy Nancy-boys, bedwetters barely better than humanities
majors who partied through school.

In fact, the strongest evidence I can find for my claim that software is
mirroring the physical sciences is how perfectly the attitudes of programmers
match those of their corresponding scientists. Compare Dijkstra’s “Elegance is
not a dispensable luxury but a quality that decides between success and
failure” to the aesthetic of your average physicist. Compare the stereotypical
OOP programmer’s love of nouns and naming with the impossibly long catalogues
of chemical compounds— design patterns and chemical formulae. And today, you
can look at the Rubyist waxing on about human factors and the latest
methodologies at a new convention every week and see echoes of the social
scientists and their endless manufacturing of new -isms.

Where this causes problems is that there’s a noticeable correlation between
personality type and job type. Ask any room full of coders how many still play
with LEGOs and how many still play with modeling clay. Many programmers,
especially many older ones, are predisposed to like things that are discrete,
simple, and concrete. By their very nature, the work they enjoy is at the
physics end of the software continuum, and as programming drifts away from
that, it becomes less enjoyable for them. Their LEGOs are being ripped from
their hands and replaced with Play-Doh, and they aren’t happy about it.

To make matters worse, the new crop of programmers who are comfortable
working at biological end are acquiring prestige at dizzying rate. For better
or worse, many of the luminaries of the software world today are on the soft
end of the spectrum. DHH may have never written a linked list in his
life, and he just bought a house in Italy for his car. If you spent
your formative years painstakingly learning how to carve code one bit at a
time and are now finding yourself becoming outdated, that can’t feel good.

It’s OK

I happen to be right at the chemist level: I think in OOP. I’ve done a bit of
assembly but it just seems tedious to me. At the same time, Javascript and
Ruby, try as I might, just don’t feel like programming. There aren’t even
types there. How can I feel like I’m getting a real code workout if I don’t
have a compiler yelling at me that I’m not doing it right?

So I get the lament that programming is becoming less real and it does make me
a bit sad that so much of my time programming these days is just jamming
chunks of code together. But it doesn’t get me down as much as it does some
people, because I know that programming isn’t moving towards softer
sciences. It’s simply expanding.

For as long as we’ll need physicists, we’ll still need low-level coders. The
software universe is getting bigger and it can accomodate scientists of all
persuasions.

And instead of thinking that programming is getting sloppier, I tell myself
it’s getting more organic.