Software development myths and misconceptions
The IT industry is ripe with software developer myths and misconceptions.
Despite being easily debunked, these myths persist throughout management, the education system, industry and even software development teams themselves.
Here are the most commonly held software myths that persist about IT:
- An extra developer will speed things up.
- Developers aren’t creative.
- Open source software is less secure.
- Agile doesn’t require documentation.
- Programmers need to be experts at math.
- Programming is boring.
- All programming languages are the same.
- Open source software is built by individuals.
- Writing tests is a waste of time.
- ChatGPT will make programmers obsolete.
An extra developer will speed things up
A common management myth in software is that adding bodies to a project linearly increases productivity. It doesn’t work that way.
When a new developer joins a team, there is always an initial decrease in per-person productivity. Onboarding takes time, and acclimating a new developer to a project takes time away from the development team’s development-focused activities.
Furthermore, in the world of software development, smaller teams are proven to be more product, adaptable and agile than larger ones. That’s why the Scrum framework limits teams to 10 members, which includes the Scrum Master and the product owner.
Diminishing returns from adding bodies to a development team is a manifestation of Brooks’ Law, which states: Adding manpower to a late software project makes it later.
Developers aren’t creative
It always frustrates me when I hear kids say they wouldn’t like computer programming because they like to be creative.
Actually, software development takes a great deal of creativity.
Anybody can learn how an API works. However, the ability to use an API and apply it to an unsolved problem takes a great deal of creativity.
The people who standout on a software development team are the ones who twist and turn methods and functions in unpredictable ways, and conjure up incredibly creative solutions to difficult and complex problems
There’s certainly a creative difference between developing a microservice and choreographing a tap dance. Nevertheless, it’s a software myth to suggest that developers aren’t creative people.
Open source software is less secure
There is no qualitative evidence to suggest that open source software is any more or less secure than software developed by a vendor.
Many contend that because the source code behind open source software is publicly available, any hacker with nefarious intent could easily crack that code. In fact, the opposite is true.
With open source software, hundreds if not thousands of people scour through updates, enhancements and even stale source code that hasn’t been touched in years to regularly check and test the codebase.
All that work makes open source software more secure than proprietary software that is maintained by only a handful of programmers.
Programmers need to be experts at math
The assertion that programmers need to be great at math is a common software myth that sadly discourages people from getting into software development.
Software development probably isn’t a great career choice for someone who has trouble with addition and multiplication, but you don’t need to know how to differentiate the Heisenberg equation to build a microservice.
There is very little math involved in enterprise software development, and what little math there is doesn’t typically go beyond addition, multiplication and the modulus operator.
Not being great at math shouldn’t discourage anyone from getting into software development. The idea that you need to be an expert mathematician to program a computer is just another software myth.
Programming is boring
It’s amazing how a person becomes full of life when they are engaged and challenged on a software project.
Talk to any software developer who’s been in the industry for half a dozen years. They’ll regale you with stories of working late through the night to solve a problem, and then waking up early to go straight to the keyboard to test out an inspiration that woke them out of dream.
I personally have been on project where I was so engrossed in the project that I lost track of time and stayed so late in a secure facility that I was locked inside until the morning crew arrived.
People don’t behave like that if they’re bored.
Agile doesn’t require documentation
One of the core tenets of the Agile Manifesto is: Working software over comprehensive documentation.
Somehow this simple statement has morphed into the software myth that insists Agile software development teams don’t need to produce documentation at all.
Agile certainly takes the approach to documentation that less is more, but it still requires documentation.
Every software project needs documentation that pertains to how a particular product was built, and the rationale behind key design decisions. Furthermore, users need documentation that explains how to use a product, and help desk personnel need documentation that explains how to support a given product.
The idea that Agile or Scrum projects don’t need any documentation is a software myth that isn’t helpful to anyone.
All programming languages are the same
At the core, all programming languages perform three functions:
- Manage data in the form of variables.
- Perform conditional logic through if..else statements.
- Do things really fast and iteratively in loops.
Beyond these fundamentals, though, things change drastically:
- Some languages are object oriented while others are functional.
- Some languages are interpreted while others are compiled.
- Some languages are close to the metal while others are virtualized.
- Some languages are strongly typed while others don’t use types at all.
Social media is always rife with debates over which language is best and why. If all programming languages were the same, those flame wars would die out quickly — but they don’t. They rage on because it’s a software myth to assert that all programming languages are the same.
Open source software is built by individual contributors
Many people have a mental image that open source software is built entirely by young, motivated developer savants who work late into the night after they put in a full day at work. Despite my secure-facility adventure above, the reality is typically quite different.
The biggest contributors to open source software are often proprietary vendors.
For example, according to Jonathan Corbet of lwn.net, Huawei had 117 developers working on the 6.1 Linux kernel, and 37% of the lines of code changed were contributed by Oracle, AMD, Google, Intel and IBM.
Writing tests up-front is a waste of time
Test-driven design asserts that tests should be written up front, before the code is actually written.
A common software myth is that this approach is a waste of time. It’s not a waste of time.
Before you write code, you must first think about how it works. You must also think about how external applications will invoke and use that code.
I have been using Test Driven Development for twenty years now. I am a faster, better, more confident programmer because of it. The code I write is very well tested. The tests give me confidence to refactor. The refactoring improves everything.
— Uncle Bob Martin (@unclebobmartin) October 30, 2019
Test-driven design asks you to write those thoughts into code that tests your logic. It’s simply a way to codify what you’re already thinking.
Furthermore, you need to write tests eventually. It actually saves time to write the tests while you think about how the code works, rather than crank out unit tests after the code is supposedly complete.
ChatGPT will make software developers obsolete
The promise of OpenAI and machine learning tools such as GitHub CoPilot is to write code that works according to the provided requirements. This has certainly woken up the software development community to the power of AI, but the software development career isn’t going anywhere yet.
As good as ChatGPT is, it still creates broken code that either doesn’t compile or doesn’t quite meet the requirements.
Programmers who know how to code and how to turn detailed requirements into deployable software will continue to be in demand into the near future.
It’s a software myth to think the world could ever survive without skilled developers and programmers to build the applications needed in the future. AI-driven tools won’t replace developers they’re going to need more of them, and also more from them.