Two Traps all Software Developers Must Avoid (A.K.A. Ned Ludd is the Devil)


Software development is a challenging task–one where the velocity of change is staggering.  Practices, ideas, technologies and languages that are considered best practice today may be relegated to the trash heap tomorrow.

However, at its core, good software development doesn’t really change that much.  That’s because, at its core, good software development isn’t about software development at all.  It’s about understanding a problem domain, finding ways to facilitate an activity in that problem domain and then breaking down the tasks and ideas involved in that activity into loosely coupled, well defined conceptual chunks.

There are two major traps all software developers should avoid at all costs:

Don’t become a ludditefactory

The Luddites were 18th century English textile workers who protested against industrial revolution technologies such as the spinning frame and power loom.  Software developers that refuse to investigate new technologies, languages or tools are similar to Luddites.

While it may come as a surprise, I’ve known many developers (particularly in the enterprise world) who have many years of experience in a particular tech stack and refuse to develop in anything else.  The rationales are varied but the crux of their argument always returns to: I can do it the way I’ve always done it and I know it will work.

This is, of course, true.  But the argument is specious.  You can write a modern web-app in assembly but you won’t be providing a very good return on investment to whoever’s paying for the development.  Ultimately, software developers are employed because they provide good return on investment–they create a better product, faster, than someone without their education and experience.

Over the years, we get better at decomposing things and assembling them in more useful ways: we create general patterns (e.g. the factory pattern, the singleton pattern, etc.) that help us identify common ways of decomposing ideas. We create new technologies that allow us to share components more effectively (e.g. NPM, Nuget, Maven, etc.).  And, we develop new languages that help us assemble things more quickly, allowing us to better leverage new patterns and tools.

Refusing to make use of these improvements is tantamount to dereliction of duty.  Exactly which tools, when and how you leverage them depends upon the project’s demands and constraints.  However, it’s your job to stay up-to-date and take appropriate risks to improve the quality of your product.  If you’re not willing to research, learn and experiment, you shouldn’t be a software developer.

don’t paint the duckbabyduck

Okay, I’m mixing metaphors here.  “Painting the bike shed” refers to an inordinate focus on trivialities.  The “duck technique” is when a developer throws in a sacrificial feature they don’t mind getting rid of to distract management from the features they feel strongly about.

“Painting the duck” is when a development team becomes hyper-focused on trivial features.  Yes, the color gradient of the help button is important.  No, you shouldn’t spend three months on it.

It’s surprisingly easy to become focused on the wrong things.  This can be due to a lack of clarity from management, lack of communication with the users, poor process or even a well-intentioned desire to make the best product possible.  A product that ships with a 90% solution is better than a 100% solution that gets canceled because it’s late and over-budget.


Keep learning.  Take risks.  Be pragmatic.