Most software isn’t what people think it is.
It’s a common thread – it’s mistaken for lots of things that it isn’t.
“I bet you’re good at maths!”
Ask the well-intentioned friends and strangers who think we write in ones and zeros.
“Software is engineering”
Cries the mid-career developer, desperately searching for legitimacy in a world that makes it hard for people to feel their own worth.
“Software is architecture!”
Says the lead developer, filling out job applications looking to scale their experience and paycheck.
But programming is programming. And we do it a disservice, we lower it, by claiming it to be something else.
Comparison and the Death of Identity
Software is the youngest of industries, and with youth comes the need for identity, and understanding – because those things bring legitimacy to an occupation.
Every new job must run the gauntlet of people’s understanding – and when a discipline is new, or complicated it is tempting to rely on comparison to borrow credibility, and to feel legitimate.
But comparison is reductive, and over a long enough time can harm the identity of the people that rely on it.
Software is none of the things that it may seem like.
Software is beautiful because of what it is
I’m so proud of software and the people that build it. And I want you to all be proud of what you are and what you do too.
Software is the most important innovation of the last one hundred years. Without software, the modern world wouldn’t exist.
Software is beautiful because we’ve found our own patterns that aren’t engineering, or design. They’re fundamentally of software, and they have legitimacy, and are important.
You wouldn’t TDD a building, even if you might model it first – the disciplines that are of software, are ours, and things to celebrate.
We do not need to borrow the authority or identity of other disciplines on the way to finding our own.
Just as much as we should celebrate our success, we should embrace and be accountable for our failures. It’s important that we embrace and solve our ethical problems, defend the rights of our workers, and are accountable for our mistakes.
Because software does not exist without the humans at the centre of it.
Love What You Are
There’s a trend of negativity that can infect software.
That everything sucks, that everything is buggy, that modern programmers just plug Lego bricks together – and it’s toxic. It is absolutely possible to be critical of things that you love to help them grow, but unbridled aggression and negativity is worthless.
Software, even buggy software, has changed the world.
Software, even software you don’t like, has inspired, and enabled, has been a life changing experience to someone.
As programmers, our software is our work, our literature, our singular creative output.
As romantic and pretentious as that sounds – respect each other, and the work, lest we drown out someone’s beautiful violent urge to create and make things.
Every character matters
I was recently on a podcast where I was asked what advice I’d give to myself twenty years ago, if I could, and after some deliberation I think I finally know the answer.
“Always take more time”
Time is the most finite of resources, and if you want to write beautiful software, you have to do it with intent. With thoughtfulness.
And the only way to do that is to take your time.
We’re often subjected to environments while producing works, where time is the scarcest resource – and simultaneously the thing you need to defend the most to produce work of value and of quality.
If I could have my time again, after every change, every completed story, after everything was done, I’d give myself the time and the mental space to sit with the work, and soak it in, and improve it. Taking time, in the middle of my career, has become the most important part of doing the work.
When you realise that how you do something matters as much as why you’re doing it – that legibility and form directly affect function, when you take time to think articulate why something is – that’s when you do your best work.
The only analogy I subscribe to
And now the contradiction – after writing about how software should be empowered to be its own thing, let me tell you what I think software is really closest to.
Software is fundamentally a work of literature.
You can look at software through the same lens you would as any body of writing. It has text and subtext. It has authorial intent that perhaps is contradictory to its form. It has phrasing, rhythm, and constrained grammar. Software is a method of communicating concepts and ideas between humans, using a subset of language. The fact that it happens to be executed by a computer is almost a beautiful side effect.
Your code tells a story, your commit messages transfer mood. The best code is written for the reader – using form to imitate function, and flow and form to transfer meaning.
I love software, and I love the people that write it – and who do so with intent, and thoughtfulness. You’re not plumbers, or electricians, or engineers, however wonderful those jobs are.
You’re artists. <3
Top comments (5)
David. Thank you for a very eloquent, yet romantic expression of many of my own feelings towards programming. I think it's important to always keep that special spark when working on a problem and secretly feeling like a child doing something exciting. It is, after all, hard to keep oneself motivated over the years without an emotional attachments. It's also important that programming is not only about the visceral experience and "gung ho" approach to practical problems, but also about learning, refining, acquiring taste. After all, it's hard to maintain the sense of meaning if all you do is play. So the balance between the Apollonian and Dionysian elements is central to programming and in the end makes it, as you've pointed out, an art form.
As you mentioned, David, it is contradictory to compare software and the software industry to anything else, but I do have a lovely analogy that seems apt. I do not have the same eloquent supporting comparisons as you did with your comparison to literature, but I think you'll agree that it too is an accurate comparison.
Software is like gardening. You need to plan where things will go, how you are going to maintain it, how you will protect it from invaders and pests. You need to know which parts can go together and which parts are mortal enemies. But above all else, Software is like gardening because it takes patience, passed down knowledge, pragmatism, and a little love.
...and some times a heap of fertilizer (🐄 💩 ) is needed too!
For me the joy of programming is being able to play with what is the ultimate Tinker Toy, Erector, or Lego Set. The things you can build in software are boundless, given enough time and motivation. I've just retired from a 40 year programming career, but I continue to code as a hobby and to support my other hobbies such as photography.
While I understand what you are trying to say, programming should be about engineering because engineering is about discipline. Picking the right tools, the right techniques and algorithms, determining the customer's needs, and testing, testing, testing. I was fortunate to learn programming at a good engineering school and the lessons I learned, beyond just the act of programming, have served me well over my entire career.
In my favorite class, over the course of the semester, we learned 6 very different programming languages. In each case we had to solve a non-trivial problem in that language. Each problem was selected to illustrated the particular strengths of that language and why it would be a good choice. When you were done, you had proved to yourself that programming languages are just a tool. Different programming are a good or not so good fit for solving different classes of problems. And you also learned that you should be able to become proficient in any programming language that is thrown your way. Each new language becomes easier to learn than the last. My favorite programming language almost always ends up being the one I'll learn next.
In another class we learned different ways to model logic. My favorite take away -- Finite State Machines (FSM) -- an incredibly powerful method for decomposing a class of difficult problems into a representation that is easy to understand, test, and turn into code. It is tool that I've turned to again and again over the course of my career.
But like all good engineering, there is an art to programming as well, and the joy to be found in the elegance of a good design.
One last observation -- when I first enrolled in the Computer Science program so long ago, it was such still such a new subject that it was initially a part of the math department. Now I'm an average math student at best, understanding the concepts, but not very good at turning the crank. But the one thing I found that is a good predictor of success in a programming career is the ability to do word problems. Often even the best math students shudder at the thought of word problems, but I relished them. I think it is also why you see so many physics majors gravitate to programming -- so much of learning physics is learning how to solve word problems.
Software blends science and art in an unique way 😊