Clean Coding

To better structure and apply the principles and practices of Clean Code Development (CCD), they are categorized into different grades. These grades help developers to maintain an overview and continuously improve in clean coding. The grades range from black to white, with each grade encompassing specific principles and practices. Below, we describe just a few examples of these principles and practices, but there are many more included in each grade.

0. Black Level

The black level shows a basic interest in clean code development without actively applying the principles.

1. Red Level

In the red level, you begin to incorporate basic CCD principles and practices into your daily work.

Principles:

• Don't Repeat Yourself (DRY): Avoid repetition in clean coding to make changes centrally and efficiently in a single place.
• Keep it Simple, Stupid (KISS): Keep the code as simple as possible to improve understandability for other developers and increase changeability.

Practices:

• Boy Scout Rule: Always leave the code a little better than you found it. Even minor improvements promote the continuous improvement of code quality.

• Simple refactorings: Carry out simple restructuring to improve the code step by step. This increases readability and maintainability without introducing new errors.

   

2. Orange Level

The focus is on the application of principles at the class level.

Principles:

• Source code conventions: Adherence to uniform code conventions makes reading and understanding the code easier.
• Single Responsibility Principle (SRP): Each class should only have one responsibility. This reduces the need to adapt many classes when changes are made and avoids complex couplings.

Practices:

• Issue tracking: Systematically track tasks and errors in the code to maintain a clear overview. This clean coding practice facilitates the efficient processing and delegation of all open issues.
• Reviews: Regular review of the code by team members promotes the identification of weaknesses and opportunities for improvement.

3. Yellow Level

This grade emphasizes structured and maintainable codes.

Principles:

• Principle of Least Astonishment: The code should behave as the reader expects to avoid surprises and unnecessary complications.
• Information Hiding Principle: Avoid the disclosure of unnecessary information to reduce dependencies and increase the changeability of the software.

Practices:

• Mockups: Creation of dummy classes that are used as a replacement for components to isolate dependencies during testing and perform controllable tests.
• Automated unit tests: Automation of tests to check the functionality of individual code units to save time and detect errors at an early stage.

4. Green Level

The focus is on continuous improvement, in particular through conscious dependency management.

Principles:

• Open-Closed Principle: Software modules should be open for extensions but closed for modifications. This means that changes and enhancements to functionality should be made by adding new code components without changing the existing code.

Practices:

• Application of metrics: Using metrics to measure and improve code quality. Metrics help to objectively evaluate code quality and identify the potential for improvement, e.g., to determine test coverage.

5. Blue Level

The highest level establishes the link between CCD and software architecture.

Principles:

• You Aren't Going to Need It (YAGNI): Implement only what is really needed. This avoids unnecessary complexity, saves resources, and makes the software more flexible and maintainable.
• Implementation reflects design: The code should reflect the original design. This ensures that the implementation corresponds to the architecture and that the planned structures and relationships are clearly and comprehensibly recognizable in the code.

Practices:

• Test First (Test Driven Development): Tests are written before implementation to clearly and precisely define the requirements and design. This method ensures that the software meets the desired specifications from the outset, thereby promoting higher code quality and consistency.

6. White Level

The white level combines all the principles of clean code development and applies them in their entirety.

Clean coding is more than just a collection of best practices - it's a philosophy that positively influences the entire development culture. By adhering to the various degrees and principles of clean code development, developers can not only improve the quality of their code, but also increase their efficiency and productivity. The journey towards clean code may be challenging, but the benefits for software development are enormous and indispensable in the long term.