We Are Not Engineers
Photo by ThisisEngineering on Unsplash
Software development has an image problem. Not just the isolated, ramen eating stereotype that I’ve played off while writing this blog for the last couple of years.
No. I say it’s the image that we are trying to project. It is how we throw the word engineering. It is stopping people from calling us software developers and insisting we are software engineers. It is our teams embracing engineering culture. It is our processes driven by engineering best practices. The issue isn’t that these things sound great. The issue is this.
We are not engineers.
Engineering
I won’t be shocked if the comments section of this post explodes with hate, all in my direction. Some will say I’m not worthy of writing posts. Some will say that I’m too junior to have an opinion. Some will say I’m simply not good enough a software developer to call myself a software engineer and I’m simply jealous.
Some will let me explain.
I don’t think software engineers are engineers in the same way that civil engineers and mechanical engineers are. Not in the way that their disciplines are built on rigorous methodologies, certifications, and professional accountability.
Even the best software developers I know operate in a world where copy-pasting Stack Overflow answers is a legitimate problem-solving strategy, code reviews devolve into bikeshedding about indentation, and entire teams deploy changes based on the time-honored philosophy of “well, it works on my machine”. Tell me that I’m wrong.
What Even Is Engineering Culture?
If you ask five software teams what engineering culture means, you’ll get five different answers, and all of them will be nonsense. That’s because it isn’t a thing.
Some teams think it means hiring 10x engineers, and they are happy with employing engineers who work overtime for free (as is their incorrect interpretation of 10x engineers).
Some teams follow Agile “to the letter” and ignore feedback from actual developers.
Some insist that a healthy engineering culture is about quality in terms of engineering practices. This is common in teams where they rush an untested feature to production because the business demands it.
We can compare this to engineers in other industries who become and keep their status as engineers. They follow regulations, understand the content of a widely accepted body of knowledge, and require certifications to remain qualified and perform important work. These engineers have a prefix like civil, electrical or aerospace. They work to strict standards to protect people.
When a civil engineer screws up, a bridge collapses. When we screw up, a button doesn’t align properly in Safari.
The Hypocrisy of the Software Engineer
The entire software industry has an uncomfortable relationship with the term engineer. The word implies a level of rigor and professionalism that, frankly, we do not possess.
We do not have industry-wide licensing. You don’t need a degree in software engineering to be a software engineer. In fact, many of the best developers I’ve worked with had no formal education in computer science at all and have come through code camps or are self-taught.
The hiring process in software is also completely detached from reality. In real engineering fields, you don’t get hired based on an abstract ability to implement a binary search tree from memory in under 30 minutes. You don’t spend entire weekends grinding LeetCode because your ability to invert a binary tree is somehow a measure of your ability to work in a team.
And let’s not forget our approach to quality control. A mechanical engineer wouldn’t sign off on a car where the brakes probably work, yet software companies routinely ship products riddled with bugs and call it “iteration.” If buildings were built the way software is developed, we’d all be living in tents.
This shouldn’t be happening. Calling ourselves software engineers is an embarrassment to everybody we come into contact with.
The Industry’s Love Affair with Titles
Software development loves rebranding itself. Nobody is just a developer anymore. It’s a love affair with only one party involved.
Frontend Developer became Frontend Engineer
Backend Developer became Software Engineer, Backend
Mobile Developer became Android Engineer
Tech Lead became Principal Engineer
Senior Developer became Staff Engineer
We iterated job titles without looking at job responsibilities. It’s as if we collectively agreed that engineer makes us sound more serious than developer, even though most of what we do still boils down to googling error messages and debugging issues that shouldn’t exist.
The Consequences
Because we have deluded ourselves into thinking we are engineers, we assume that what we do is as structured and precise as real engineering. But the reality is, software development is a mess and that isn’t getting fixed in a hurry.
We constantly reinvent the wheel
Every six months, there’s a new JavaScript framework that promises to fix all the problems of the last one. We collectively rush to implement it and introduce a host of new issues into the codebase. Then everything is settled, until a new JavaScript framework is released.
Hype-driven decisions
If a Big Tech company does something, the rest of the industry blindly copies it — whether it makes sense for them or not.
We ship first, fix later
The fact that hotfix is a normal term in our industry says everything. Stop cherry-picking and get it right the first time.
We accept a ridiculous amount of technical debt
Any software engineer who’s had to work with legacy code knows the pain of wondering what kind of monster wrote it, only to check Git blame and realize it was you a few short weeks ago.
None of this is how a real engineering discipline functions. No one builds a bridge first and then figures out how to make it safe.
So What Should We Do?
Maybe it’s time to stop pretending we’re engineers and start acting like professionals in our own right.
This doesn’t mean we need to adopt the exact methodologies of traditional engineering. Software is different — it’s more flexible, more iterative, and (thankfully) less likely to result in catastrophic failure.
If we want to claim the title of engineer, we need to actually deserve it. That means:
Writing code that is maintainable, not just code that works in any way we can make it run.
Treating software as a long-term product, not just a series of rushed releases.
Holding ourselves accountable for the messes we create.
Standardizing actual best practices instead of having religious wars over tabs vs. spaces or whatever that day (incidentally, tabs are the way to go.
Conclusion
Is this article completely honest? I guess not to the extent that I do indeed call myself a software engineer on my resume.
Yet I do think it is time for us to be honest with ourselves as a profession. We can do better. Until we do, and we take the issues facing tech seriously, we are not engineers. I’m a developer, and I suspect you are too. And what exactly is wrong with that, when one day we might become engineers.
Maybe, one day.