Clean Code Masterclass


Practical, pragmatic, and realistic Clean Code certification training for experienced Java developers building real-world enterprise applications.

Do you want to write code that is easy to read, test, and maintain? Develop large-scale Java applications that are joy to work with? Move fast without compromising quality? Then this masterclass is for you.

During this intensive, practical, and high-energy 2-day masterclass, you will learn how to design clean and maintainable enterprise applications using modern Java coding best practices, libraries and secret gems.


  • The course is based on realistic code examples and provides effective solutions to real-world architecture and design challenges.
  • The course showcases good use of popular libraries such as Spring, Hibernate, and Guava, but also lesser known hidden gems.
  • The course reflects the latest Java additions and idioms, but is equally relevant to devs working with older Java versions.
  • The course features interactive sessions, Q&A, lab exercises, group knowledge sharing, and an optional homework assignment.
  • Upon completion of the course, you'll receive a verifiable certificate, as well as list of must-read books, videos, and GitHub repos for self-development. Everything you need to become an exceptional Javist.

What's under the hood?

(1/5) Effective Code Design

  •  Choosing good names for packages, classes, objects, methods, and variables.
  •  Refactoring large code chunks into small, testable, and reusable objects (SRP).
  •  Using interface segregation principle (ISP) to reduce coupling and increase cohesion.
  •  Writing intention-revealing code by choosing the right level of abstraction.
  •  Reducing cognitive load with the single level of abstraction principle (SLAP)
  •  Reducing discovery cost with the principle of least astonishment (POLA and DOD).
  •  Balancing duplication and coupling (DRY vs. WET).
  •  Striking the right balance between specific and abstract code (The use/reuse trade-off, KISS, YAGNI, and AHA principles)
  •  Making implicit code concepts explicit (Reification).
  •  Getting rid of null checks with null-safe programming, design patterns, and static analysis.
  •  Eliminating deep nesting with functional programming.
  •  Replacing eager loading with lazy loading and Memoization.
  •  Organizing code with The Stepdown Rule.

(2/5) Effective Domain-Driven Design

  •  A quick introduction to DDD, when to use it, and when not.
  •  Unlearning harmful procedural thinking habits and learing some real OOP/OOA&D.
  •  Replacing boilerplate code, helpers, and utils with good OO design.
  •  Reducing coupling and protecting objects by burning getters and setters in fire.
  •  Curing primitive obsession with value objects.
  •  Moving behavior into the entities.
  •  Passing dependencies into the entities (three strategies).
  •  Decoupling entities and bounded contexts with events and side-effects.
  •  Designing an event bus (Spring and custom ForkJoinPool).
  •  Controlling object growth and minimizing coupling with advanced DDD patterns.
  •  Advanced DDD patterns: Specifications, Queries, CSP, Events, and Roles.

(3/5) Effective Service Layer

  •  Understanding the purpose of the service layer in DDD.
  •  Why traditional Service + ServiceImpl - style services suck.
  •  Implementing a better service layer with Commands, Handlers, and Pipelines.
  •  Adding cross-cutting concerns without AOP, proxies, and black magic.
  •  Mapping the domain model to DTOs (and why exposing domain model is a bad idea).
  •  Offloading heavy work in a thread pool / MQ / Kafka.
  •  Adding simple and complex business rule validation.
  •  Pushing validation rules down to domain model with Secure by Design principles.
  •  Replacing BeanValidator with a small, simple, and fast custom validation library.

(4/5) Effective Persistence

  •  DAO vs. Repository – what's the difference?
  •  Understanding Hibernate and Unit of Work pattern.
  •  Transaction management strategies ("just add @Transactional" is not a strategy).
  •  Understanding ACID, locking, and isolation modes.
  •  Designing Aggregate Roots to ensure data safety and consistency.
  •  Implementing transactional queue / outbox pattern.
  •  Implementing IDs, hashCode() and equals() correctly.
  •  Optimizing reads performance with CQRS.
  •  Combining Hibernate and jOOQ.

(5/5) Effective Resilience

  •  Fault tolerance patterns.
  •  Retries.
  •  Timeouts.
  •  Bulkheads.
  •  Rate limiting.
  •  Circuit breakers.
  •  Making our service layer fault-tolerant.

... and more coding wisdom, inspiration, and good energy 

This course is a fast-track to the knowledge that usually takes years to master – from basic SOLID to advanced OOP and Enterprise Application Architecture. By the end of this course, you'll become a better, well-rounded Javist, with a deep understanding of how clean Java enterprise applications should look like.

For further information and to register, please click here.