Micro Focus is now part of OpenText. Learn more >

You are here

You are here

6 critical mistakes guaranteed to delay your software releases

Željko Plesac Technical Director, Infinum

When writing code, how many times have you had to tear everything up and start over? How many times have you refactored, revised, or rewritten that one buggy function that seems to break down every five minutes?

Software development is not so much a science as an art, but years of frustration for developers have brought to light several common mistakes that have derailed entire companies and stuck products in development hell. Unfortunately, almost everyone has to discover these problems for themselves. 

On their way to creating working software, most people make hundreds of mistakes—some small, some big, but all of them unnecessary, and all of them infuriatingly time-consuming.

A few of these common mistakes, however, are the most egregious, because they're so simple to prevent and yet can slow down your release cycle by months if you don't take the correct measures to rectify them.

Here are six commonly overlooked mistakes that can significantly prolong your software product development process.

1. Making it up as you go along

Naturally, you don't want to write algorithms and flowcharts. That's understandable; it's the real world and you're not in college anymore. But maybe you should do it anyway. Planning out exactly what you're going to do before you do it is one of the most time-effective ways to improve your development process.

Ten minutes of writing a simple algorithm or sitemap will save you dozens of hours in refactoring, backtracking, and staring blankly at the screen. Additionally, it'll save you both time and effort because you'll be able to communicate your plan and process clearly to the clients (and to your colleagues) without having to fall back on frustrating updates and catch-up meetings.

2. Breezing through the documentation

Algorithms, emails, READMEs, project reports—it can all be too much. You just want to write some code! But your project's documentation is the last place you want to cut corners. Developers are notoriously bad at reading code; research shows that reading code is much harder than writing it.

So, if there's even the slightest chance that anyone on earth will ever see, use, or debug your code in the next 10 years, write the documentation. The 15 minutes you'll save by skipping it are not worth it.

This goes both ways, by the way. A common mistake among programmers is to rope in a dependency or library without bothering to read the documentation. As hundreds of memes have illustrated, this is a huge waste of your time. Stack Overflow and Mozilla's MDN are extremely useful resources, but nine developers out of 10 will find everything they need right there in the docs.

3. Getting too attached to the product

It's quite natural to feel as if the project is your baby. With constant pressure from management and corporate, the technology department is going to want to protect the product. But the more experience you get, the more you'll realize that sometimes it's better to chop off an arm than to sacrifice the whole thing.

But it's okay to hold a feature until the next release or to under-deliver on a promise. The priority should be shipping a working, smooth experience on a steady schedule, not providing a long list of buggy features at the end of an unsustainable sprint two weeks after the deadline. The magic mantra is on time, on budget, and on spec—in that order.

4. Not communicating properly

Whether you're building your product at a 1,000-employee multinational or at a two-person startup, failing to communicate your needs and expectations can wreck your product and destroy the business value you have created.

If you need to set a deadline, give yourself plenty of time for bugs, tests, and assorted hijinks. If you need to extend a deadline, say so instead of trying to catch up by pulling all-nighters, skipping through important parts of the codebase, or patching in hacky solutions that will only take you more time to fix when they eventually break. If you that button isn't doing what it should be doing, take the time to fix it right away, the proper way. 

5. Farming everything out to dependencies

The modern software environment is immeasurably complex and incredibly well suited for users to build on without having to worry about the tiresome details themselves.

The problems start happening when, in a bid to save time, you start hacking around the library to try to fit it to your use case without breaking anything. The problem there is obvious. Sometimes, it's not an awful idea to roll your own implementation, especially when yours is a corner case. Plus, it's safer.

6. Trying to reinvent the wheel

You just can't win: While you shouldn't farm everything out, you also shouldn't create something that already exists just for the sake of doing it yourself. While it's true that there's not always a library that can help you, there usually is. And you can save hours and hours of time by just using it instead of trying to create your own implementation of a bubble sort, Djikstra's shortest-path algorithm, or any of the basic stuff that you really should just use a dependency for.

The real wisdom lies in picking your battles.

Slow down to speed up

You've probably seen a pattern here: Most of the mistakes that slow down your software development process happen when you're trying to speed it up. The truth is, if you just focus on writing clean code, making sure your colleagues and your clients know what you're doing and how long it will take, and making considered design choices, you will always have faster releases than if you wing it.

This is not very exciting, but it's the truth—and if you doubt it, see for yourself what happens when you do the opposite. Next time you're making a time-sensitive decision, remember the mistakes to avoid and take the longer route. It's quicker.

Keep learning

Read more articles about: App Dev & TestingApp Dev