Developers and Bugs – why are they happening again and again?

Entering the world of testers, one question started to formulate in my mind: “what is the reason that bugs happen?”.

And I am quite positive that you will, after reading this article, find the answers I provide useful for you as testers and QA engineers. Do consider them as tips you can easily implement too.

Also, I decided to share some insights into different ways of thinking (usually referred to as mindsets), why they are important for developers, and how they can be important to testers.

So let’s begin with our new journey, with bugs, developers, testers, and knowledge.

Humans and code writing

The below-stated reasons are so common that everyone in any business sector probably repeats them every day. In some jobs, this can be time-saving, helpful, and even inspiring, but for developers, it is a clear path for constant bugs in their code. And also, for testers, these seven reasons are prone to cause mistakes in the testing process and test case fallouts. But understanding them can help testers quickly find bugs and point developers to where the errors are in the code.

1. Copy-Paste

There are a minimum of two reasons why copy-pasting is creating bugs when coding. First of all, the copied part of the main code must precisely fit the destination where it’s pasted. Copy-paste can be a very bad solution in writing code since the probability of missing a bit of code is almost 100%. When reading the written code again (with copy-paste parts), the brain keeps jumping over the identical words and commands, so it just assumes they’re fine.

The second reason is: Maintenance of code is difficult. And, inserting a copy-paste code with an existing bug when editing your written code, is something that will happen. One copy is modified and bug-free, and if you are not very, very careful, the other copied one, won’t be bug-free. That’s one of the explanations behind the DRY principle.

“Don’t repeat yourself” (DRY) is a principle of software development aimed at reducing the repetition of software patterns, replacing it with abstractions, or using data normalization to avoid redundancy.(Wikipedia)

2. Rush

When we feel there’s no time to do something to achieve a perfect result, we panic and try to see a completed picture instead of the small parts that are making that picture. It is generally an efficient trait of our brain since it permits us to finish out the foremost tasks achieving an approximated result. And that’s fair enough if we are not talking about coding. However, coding is all about precision in small tasks (more than seeing the complete picture). So, details matter in coding, and developers must devote time to every detail and finish all phases of creating code.

Beware not to linger on tasks expecting ideas to blossom. It’s necessary to take the required time for each task. It is best to invest time in writing code that works than simply rushing through coding and then taking time to correct the bugs.

3. Improvisation

There are numerous ways to design software, like Scrum, Kanban, and Agile. But one thing must be common to all of them; you need to design new software without improvisation. Devote time to analyze every question in your program, and analyze patterns carefully.

Avoiding improvisations is important when you need to integrate new features into already existing software solutions. Carefully analyze the available documentation that the developers of this integration provide. It is not a waste of time, but a time saver, to avoid integration issues and system crashes.

Experienced programmers will sometimes use their intuition, such as a rule of thumb, but consider improvisation as one of the reasons that bugs are very common.

4. Multi-Tasking

Now, one thing that definitely can’t be used when programming, no matter how popular this expression is in the work environment. I don’t think that any job can be correctly done using multi-tasking, but that is another topic.

What programmers need is concentration. A solution for this can be to plan the workday with meeting-free hours, switch off notifications, use headphones, etc. There are some methods to stay concentrated (such as the Pomodoro method). And one more thing, avoid “asynchronous communication” meaning stop disturbing your colleagues with minor questions and work independently.

5. Shallowness

Consider every project important and devote your time to designing the best solution. Maybe programmers think that the project is simple, but even the simplest applications have complex solutions in them.
Programmers must understand that things like the number of application users or saved entries, the device on which the program is going to be used, and its working memory can limit created software. So keep this in mind and do your math correctly.

6. Overconfidence

One thing that can be the reason for bugs is when you stop questioning yourself if your code is making sense. Never stop having some healthy doubts about your code and whether it will fulfill all requirements of the implementation. Programmers with a lot of experience in creating software know the importance of this rule.

Describe in detail all features, and this needs to clarify all questions that will arise in implementation.

One more thing, try to balance insecurity and overconfidence. Since both can create problems: insecurity will make you stuck, and overconfidence will end in buggy software.

7. Negligence

This is something that not only programmers are responsible for. Everyone involved in software creation needs to be aware of external events. Things like network issues, missing access, and the right resources must be considered to prevent bugs and successfully run the software.

The importance of writing cleaner code

Programming is 99% team work.

Today teams shift approaches in code writing and encourage team members to write cleaner code. The reason for that: if your code is cleaner then it’s easier to read. And it will be more understandable to other developers. And this is important for any programming language you use. Hence, when you hire a software engineer, you must test them on their ability to write clean code.

Also, software solutions are constantly updated, so when a new team member has to do updates, it will be a problem if the code is messy.

For testers, the reason is an obvious one. If they are dealing with clean code, it will be easy to spot a bug and write a bug report. Also, if a bug occurs, and you report it to the developing team, every team member will better understand the error if the code is written respecting the “rules” of writing cleaner code.

These are some points that will help in writing cleaner code:

1. When defining names for variables or functions, use descriptive names. Try creating syntax with variables that have understandable value for other developers. And not only in your team but for anybody who will review your code later.
2. Try to write functions that do only one thing. Yes, when you write your code and have the result in your head, you will write one function that does a lot of things. This complex function is clear to you, but it will be hard for somebody else to understand.
3. Try to take some time, and write a couple of short functions that will do one thing at a time and be easy to read and understand.
4. Another tip, instead of writing too many comments, write code with descriptive names. It can be harder, but be sure that it would be appreciated in the end.
5. When writing a comment, one needs to be understandable and have a clear message. Write your comment with information that will be useful. And this is not only that other developers will know what you did, but you will also need to go back to your code later. And after a couple of months or a year, you will have difficulty understanding what the code is doing if you don’t have a descriptive message.

The most important use of cleaner code is when you write one, testers will easily automate tests for it.

Binary search

Now, let’s see why binary search is easier with cleaner code.

Binary search is only successful and possible to use when you have a sorted list of items. In binary search in every step, data will be reduced to half. This reduces search time significantly, and required information or piece of information will be quickly delivered to the end user.

To have a clean code and to write one, you must have a well-organized structure. The organized structure is easier to read, and as we know, binary search is only successful on codes with clear structure.

This will also reduce the time for testing, and your software will be released without bugs. Your end user will also be satisfied.

Timeless Knowledge

Now, you probably wonder what does timeless knowledge have to do with bugs? I will try to explain it in short.

The world of programming and software solutions is a fast-changing game. More and more people are driven to start their careers in this field, and it is the reason for the fast evolution of coding languages and solutions.

So much research is happening in the field of programming and software solutions, that it’s practically impossible to keep up with all the new developments that are going on.

All the time some hot new thing is out in the market, and we are prone to follow it. People just don’t want to be left aside, they aim to be in the center of the action.

But, one thing tends to be ignored. And that is the advantage of having timeless knowledge.

What is timeless knowledge and how to identify it:

It can be derived from physical or abstract truths, like graph theory, linear algebra, and most other branches of pure mathematics.

It can be time-stationary like storytelling, leadership, and learning how to learn. In the world of programming try to transfer this to things like operating systems, computer networks, and cryptography.

To maintain timeless knowledge learn about operating systems, and use knowledge about cryptography for a better understanding of codebases. Learning communication skills will help you to be a successful team leader, and to run successful testing cycles in the world of testing and QA.

For programming these points are timeless knowledge (you know them as the basics of programming languages):

• Variable Declaration
• Basic Syntax
• Data Type and Structures
• Flow Control Structures (Conditionals and loops)
• Functional Programming
• Object-Oriented Programming
• Debugging
• IDEs (integrated development environments) and Coding Environments

And now to wrap it up:

Why is this all important to testers?

All I mentioned in this article are the most important coding basics that testers need to know. And testers and QA need to understand this to be included in all phases of software development.

The starting point in understanding software programs, solutions, machine learning, and automation is to learn the algorithm, binary code, and how machine language is evolved into today’s “modern” languages. Not to mention you will easily understand cloud solutions and AI.

I want to say – to test, you must understand how the software solution you test is supposed to work, and then you will easily find errors and write an acceptable bug report. Timeless knowledge is the foundation for learning new things. Learn basics and you will easily switch between manual to automation testing, from tester to QA team leader.