Course · Training · Workshop
Clean Code Hands-On
Write readable, maintainable and extensible code. Recognize problematic code and refactor it systematically towards Clean Code.
A two or three day workshop focusing on writing readable, comprehensible code. Learn to identify poor code and improve it gradually through targeted refactoring. The course combines solid theory with numerous practical exercises, enabling you to immediately apply your new knowledge in your daily work. (Language specific courses: <a href="https://www.letsboot.ch/en-gb/course/clean-code-csharp">Clean Code C#</a>, <a href="https://www.letsboot.ch/en-gb/course/typescript-clean-code">TypeScript Clean Code</a>, <a href="https://www.letsboot.ch/en-gb/course/clean-code-java">Clean Code Java</a>)
What participants say






These customers booked courses in the same topic cluster.More customers →
Content
Clean and efficient code enables continuous adaptation of software to new needs. Most developers fundamentally know how clean code should look like but often lack the knowledge of how to specifically and systematically detect and improve poor code.
The workshop includes the following topics:
– Introduction to Clean Code
- Why is Clean Code important?
- How not to fall into the perfectionism trap
- The economics of clean code
– Effective Naming and Abstraction
- The art of naming variables, methods, and classes
- Finding meaningful and precise names
- Identifying the right level of abstraction
– Clean Code Principles
- SOLID principles to improve code structure
- DRY (Don’t Repeat Yourself) vs. WET (Write Everything Twice)
- KISS (Keep It Simple, Stupid) and YAGNI (You Aren’t Gonna Need It)
- Composition over Inheritance
- Integration Operation Segregation Principle (IOSP)
- Law of Demeter
– Recognizing and Naming Code Smells
- Identifying common anti-patterns
- Long Methods, Large Classes, Feature Envy
- Primitive Obsession and Data Clumps
- Shotgun Surgery and Divergent Change
– Refactoring Strategies and Tactics
- How to improve existing code without changing its functionality
- Using automated refactorings in the IDE
- Boy Scout Rule and continuous improvement
- Safe refactoring techniques
– Testing & Code Quality
- Unit testing principles
- Meaningful tests vs. mere coverage
- Test Driven Development (TDD) basics
- Using mocks and fakes effectively
– Design Patterns
- Key design patterns and when to use them
- Avoiding over-engineering
- Practical application of selected patterns
– Error Handling and Resilience
- Exception handling strategies
- Fail-fast principle
- Robust error handling
– Modularization and Architecture
- Project structure and dependency management
- Separation of Concerns
- Clean Architecture basics
- Ports & Adapters
– Working with Legacy Code
- Characterization tests for existing code
- Strangler pattern for gradual migration
- Code Archaeology
– Code Reviews and Team Practices
- Best practices for effective code reviews
- Giving and receiving constructive feedback
- Establishing continuous improvement
You will not only get to know these concepts but also apply them practically.
The actual course content may differ from the above depending on the trainer, delivery, duration and the composition of participants.
Request this course in-house
Request a public date
No suitable public date? Register without obligation — once there is enough interest we schedule a new public date and let you know first.
More about Clean Code
Clean Code is a fundamental approach in software development that ensures code remains understandable, maintainable, and extensible. The term was popularized by Robert C. Martin (Uncle Bob) and encompasses principles, practices, and patterns for high-quality software.Further resources:
History
The term "Clean Code" was popularized by Robert C. Martin (Uncle Bob), who published the book of the same name in 2008. The principles are based on decades of software development and were shaped by pioneers like Kent Beck, Martin Fowler, Ward Cunningham, and others.
The movement has its roots in agile software development and the principles of Extreme Programming. Concepts like the Boy Scout Rule ("Leave the code cleaner than you found it") and Broken Window Theory were integrated into the Clean Code philosophy.
Today, Clean Code is a recognized standard in professional software development and is practiced worldwide in companies and open-source projects.


