Clean Code Masterclass
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.
Highlights
- 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.