The Underestimated Complexity
Who would have thought that Clean Code would address concurrency? In fact, Clean Code has special significance in this area. Concurrency is complex, which makes Clean Code principles all the more important here. The central goal: to create a clear separation between the "what" (the business operation) and the "when" (the timing). This is achieved through well-designed code structure.
Principles and Models
A classic example is a JEE servlet that manages concurrency for us. As discussed on Day 5 regarding "Objects": "Clean Code in object-oriented programming comes from consistent application of object-oriented principles" – the same applies to concurrency. The key difference: Here we work with specialized models deeply rooted in software engineering knowledge.
A solution implemented directly with threads can quickly become unmaintainable. That's why various powerful concurrency models were developed:
CSP (Communicating Sequential Processes): Commonly used in Go and ideally supported through Go routines
Actor Model: Particularly popular in Scala and Kotlin due to excellent language support
Understanding these models brings enormous benefits. They provide a clear code structure and define precise data flows. This significantly simplifies programming concurrent processes and makes the code more readable, understandable, and extensible.
Additional Rules for Clean Concurrent Code
Of course, all previous Clean Code principles apply to concurrency code. Additionally, there are some specific rules that make the work considerably easier:
Use immutable data: Work with unchangeable data and only process copies
Utilize specialized libraries: Thread-safe collections, executors, non-blocking implementations, etc.
Minimize synchronized blocks: Keep synchronized code sections as small as possible
As becomes apparent, we face a double challenge here: On one hand, we must master the technical aspects of concurrency while simultaneously applying Clean Code principles to keep the code maintainable.
Practical Recommendations
My specific recommendations for handling concurrency:
Strictly follow the Single Responsibility Principle: Keep responsibilities clearly separated
Study concurrency models: Invest time in understanding established paradigms
Learn language-specific features: Use what your programming language offers in support
Separate concurrency code: "Keep your concurrency-related code separate from other code"¹
Avoid concurrency when possible: The simplest solution is often the best
Mastering Clean Code in concurrent systems is a challenging but rewarding skill that contributes significantly to the robustness and maintainability of complex applications.
¹ Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)
