Clean Code training at generic.de

Not all software quality is the same. We differentiate between internal and external quality, whereby the focus of our Clean Code training is on internal quality - i.e. the quality of the source code. The topics of readability, traceability, testability and changeability (evolvability) are addressed.
‍
The benefits of a shared sense of quality:

• Optimum basis for cooperation
• Increased sensitivity to economic relationships
• Better understanding of the consequences of poor code quality

The Clean Code Development Initiative is based on the book Clean Code by Robert C. Martin. Building on this, the two German developers Stefan Lieser and Ralf Westphal 2009 designed a standards-setting value system for software developers, which, in addition to learning modules, also includes a collection of principles and practices. The four Clean Code values are at the top:

• Correctness
• Evolvability
• Production efficiency
• Continuous improvement

Flow Design is a technique for planning and structuring source code in a meaningful way — even before it is written. It is always about the question of how to get from a request to the actual code. The technology works by hierarchically dividing the requirement down to its smallest units: data flows.
‍
The benefits of Flow Design:‍

• Source code can be planned down to the last detail without losing sight of the big picture
• The entire team is involved in the software design process
• Positive effects on team responsibilities and code readability
• Ideal template for a well-thought-out test suite

Automated tests not only ensure that the source code works correctly, they are also a good way to better understand and define requirements. And they ensure trust and security among developers. However, writing tests and complex test suites, consisting of system, integration and unit tests, is a craft in itself. Our trainers teach basic concepts, techniques and the necessary technologies, such as SonarCloud, to increase test coverage in the back and front end and achieve good ratings in penetration tests.

Although all Clean Code principles have their right to exist and are important, there are principles that should always be applied and are therefore also an important part of our training courses:

• SRP - “Single Responsibility Principle”: A method or class should only ever have one function
• DRY - “Don't Repeat Yourself”: Duplicates in code should always be avoided
• IOSP - “Integration, Operation, Segregation Principle”: An application is divided into functional units that are called as if in a chain
• YAGNI - “You Aint Gonna Need It”: Focus on current, not future, potential problems

Dependencies in the source code can help simplify structures. However, too many dependencies can result in code changes with unexpected side effects and make the code confusing over time. In our training courses, we provide participants with techniques and best practices to effectively manage dependencies and, if necessary, resolve them.

Pair programming, pairing or even tandem programming describes a clean code development method in which two developers work on a problem and on the same code at the same time. As useful as the approach is in some cases, it can be inefficient in other cases. Our trainers give best practices on how and when the method makes sense.

Clean code development must not become an end in itself. If you study source code, you will always find places that you can optimize. But at some point, that is simply no longer productive and is no longer in proportion to the costs. The only question is: When?
In our Clean Code training courses, we provide participants with tools to achieve the right definition of done — individually tailored to the project, requirements and corporate goals.

The right mindset is just as important as craftsmanship. The aim is to maintain the Clean Code values again and again and to draw attention to them. The content is therefore not taught in a completed session, but in parallel throughout the entire training session. In detail, it is about agile work, efficiency through focus, reflection, responsibilities, expectations and collaboration.

Only by doing, you learn clean code. That is why we attach great importance to a high level of practical experience in our training courses. On the one hand, these are small exercises to deepen a theoretically discussed topic. On the other hand, there are joint code reviews in which the results of the exercises or other code examples are discussed in detail with all participants.

Code checks on an existing application are a good start to find out where a team stands with its code base. Similar to a code review, the code is analyzed by our trainers and the original developer. Through such a reflexive approach, participants learn a lot about themselves and their approach.