Should programmers really stop calling themselves Software Engineers?

! Warning: this post hasn't been updated in over three years and so may contain out of date information.

This post is in reaction to an article on the American publication website, The Atlantic, entitled “Programmers: Stop Calling Yourselves Engineers”. That article itself paints a rather silly, rose-tinted, picture of engineers and tries to argue that programmers don’t make the grade. This post isn’t (just) an attack on that article; it is an exploration of the various terms used to describe programmers and whether any are fit-for-purpose as a unifying term to describe those who code?

The article itself starts with a valid point: the term “engineer” has, in many countries, become a debased term. Here in the UK, things are particularly bad. Car mechanics, washing machine repairman and even hairdressers are sometimes referred to as engineers. However, the rest of the article is more than a little bit ridiculous. It talks of the ethics of engineers; the need for them to put the public above all else and suchlike. The simple reality though is that the concept of a “Professional Engineer”, accredited via some professional body, exists solely as a means of ensuring they are a reasonable bet for insurance companies to supply them with indemnity insurance. This ensures that, when things go wrong, the engineer is financially covered against litigation costs.

And things most certainly do go wrong. The author, Ian Bogost, cites a couple of examples of how software projects have failed. However, he utterly ignores such things as the long list of bridges that have failed, the many occurrences of lithium batteries that explode and so forth. Whilst on the topic of hardware engineering failures, let’s not forget the physical patches that used to have to be applied to circuit boards after going into production. What’s interesting about these patches is that they are a lot rarer these days. The reason is simple: software. Rather than somehow being a poor cousin that seeks to steal its title, software has instead transformed engineering, making massively more complex projects possible. These days, the need for rigid processes requiring significant up-front design, review, test etc prior to build has greatly reduced. The reason for this is that these physical systems can be modelled in software and so can be developed more like software, using rapid build and test phases prior to resorting the the final physical implementation.

Are we Software Engineers?
Having gotten that out the way, is there something to the article? Is “Software Engineer” really a good term to describe a programmer? The obvious counter question to that is does that person work for an engineering company? From experience, companies that create physical products that contain software, or that produce software for engineering companies, tend to think of their programmers are engineers. They work in the engineering department, not in IT and they work closely with electrical and mechanical engineers. Some might even have chartered/professional engineering accreditation. They are clearly engineers, whether Ian Bogost likes it or not.

What of “web developers”? Those working in the financial sector? Mobile app creators? Are any of these, software engineers? The financial sector tends to (still) use the term “Analyst Programmer” and other sectors use the term “Developer”. Not only do they not call themselves engineers, they don’t work in engineering departments and may even follow quite different product development processes. Programming is engineering for some of us; but not all. So is there a better term to describe everyone?

Are we Programmers?
I’ve used the term “programmer” a few times so far, and do so throughout the rest of this post. Is this the elephant in the room: aren’t we just programmers, case closed? The problem with this label is highlighted by the term “analyst programmer” used in financial companies. An analyst programmer both analyses and programs, thus by implication a programmer just programs. The term “programmer” is all too often synonymous with “code monkey”, a code “builder”, rather than someone involved in designing a solution. It’s an unfortunate misconception that originates from the early days of computing. It has also given rise to the whole mess of waterfall, requirement specifications, UML and other methodologies based on the mistaken assumption that code isn’t design. Whilst perceptions over how best to carry out software creation has matured in recent years, it is debatable whether we can completely throw off the negative view of the term “programmer”. So it probably isn’t a great choice for a unifying term.

Are we Software Craftsmen?
Dan North wrote a great article on why programmers are not craftsman. Whilst he covers a number of valid points, I feel he misses the killer argument against calling ourselves craftsmen. Most programmers I know will happily spend a day writing code to automate a task that would only take an hour to perform manually. A good programmer uses automation tools to help write, test, build, deploy, track changes to etc etc a piece of code. They do the minimum possible by hand. A craft is literally the opposite of this: it’s “an activity involving skill in making things by hand” (Oxford Dictionaries). Programming most definitely is not a craft.

Are we developers?
What about “developer”? Can we settle on that term to describe what we do? This term potentially has the same problem as “programmer” though. It originates from the idea that a designer designs an application and a developer then implements, or “develops” it. It still isn’t capturing the fact that the code is as much a part of the application design as the graphics and user-experience work-flows (UX).

Also, I’ve found a problem with the term, at least here in the UK. Refer to yourself as a “developer” to a non-programmer and they will often assume you mean a property developer. So one has to use the term “software developer”, and then respond with “a programmer” when they ask “what’s that?”!

Having said that, throughout this post I’ve repeated wanted to use a particular phrase and deliberately steered away from it so as to save it until now. That phrase is “software development”. To me at least, what we do is develop software solutions, be they embedded firmware, open-source libraries, websites or iPhone apps. A developer may rely on dedicated designers to create the imagery and UX of an app and dedicated testers to end-to-end test her creations, but she deigns and tests too. Software development seems a neat way of encapsulating modern good practices: agile, clean code, test-driven development, functional-orientated techniques and continuous integration & deployment.

So is “developer” a good choice for a single term for everyone who develops software solutions for a living? Maybe, but there are plenty of folk who develop software yet who don’t use the term and instead still carry the “software engineer” or “analyst programmer” labels. Further, there’ll always be those who are keen on self-promotion who’ll shun the common term and will adopt daft terms like “rock star” and “ninja” to differential themselves. So we’ll probably never achieve a single unified name for all developers, but for now “software developer” is likely the best we have.

In conclusion, maybe Ian Bogost is right and we should stop calling ourselves “software engineers”. But maybe he’s actually 5-10 years late, as many of us already did stop. Of course if software development is the de-facto standard name for our profession, maybe we really should have an official software development body to set standards by which we should all seek to work. But that’s definitely a topic for another day…