Blog Post

Becoming a good developer takes years of practice. However, no programmer is sinless. Even the best developer risks to fail without proper discipline. Here are the most common bad habits in software development.

Anti-patterns

Programming languages are too flexible, so they allow even nonsensical usage patterns. As an example, Java has an option to concentrate the entire application in just one class. When a system knows or does too much, it is called god object. You don´t have to guess for long. Even if the compiling of the application is technically feasible, the presence of anti-patterns provides risks. The larger their number, the more error-prone is the software. This applies in particular to object-oriented languages, as they inherit so much from procedural languages (C, Fortran, COBOL).

Complexity

A controllable and manageable project may quickly turn into a chaos. That´s why it is so important to divide a large software project into several smaller projects. Thus, reading, testing, and debugging of software components can be easily executed.

In accordance with Agile principles, it is recommended to split the development into short time frames (sprints). It minimizes risks and simplifies error detection. To sum up, not only the division of the project into phases is important, but also the transparency of the project planning and execution.

A successfull software development project requires traceability of all changes. For this reason, each change has to be recorded.

One of the main recommendations is to use a ticket system. Regardless of the team size, logging of changes is a must. It means they have to be understandable even for outsiders. It helps to keep a clear overview. Furthermore, don´t delete any comments in tickets. They are an important part of the development process.

Documentation for users is as important as for developers. Working software has a priority over a comprehensively documented one. This does not apply to documentation for external usage, as interaction of users with the software requires detailed documentation.

Test coverage

The lack of knowledge of test coverage is the next common sin. Test coverage measures the amount of testing performed by a set of test cases.

The greater the amount, the better it is.

However, a high test coverage isn´t equated with a high quality. But an unknown coverage is an indicator of maintainability problems. Thus, it is important to define the test coverage in advance as it is a fixed component of the development.

No milestones and releases

Software development requires frequent releases and versioning. A lack of release history creates an unmaintainable chaos.

Software development must be performed continuously and regularly.

Why is it so important? In fact, a continuous development also allows to document the changing goals of developers.

Both Git Tags and GitHub release notes are great tools for these purposes.

Communication

The above-recommended documentation is just one element of smooth cooperation between all those involved in the project and their successful communication.

According to the Agile methodology again, regular scrum meetings help to track progress and better coordinate the work.