2 days
Online / Zoom
English
Certificate
30 people max
Eduards Sizovs
€16000
20000
Advanced Clean Code certification training for Java developers, covering the latest Java principles, design patterns, and architecture best practices for designing clean, modular, domain-driven applications.
Introduction
During this training, you'll master advanced design patterns and architectural best practices for building clean enterprise applications that don't suffer from unjustifed complexity so common in enterprise Java.
From advanced OOP and FP principles, to domain-driven design, and modern enterprise architecture patterns, you’ll learn to apply the underlying principles in your Java projects, pragmatically and incrementally, without major rewrites.
Day 1 ⋅ Code Design Principles and Patterns
Master the art of effective naming.
Identify the right level of abstraction.
Use cognitive load as a driver for refactoring.
Find the balance between specific and abstract code.
Apply just-enough design and Lean code.
Leverage reification in your design.
Avoid premature abstractions (AHA and WET principles).
Mix OOP with functional programming like a pro.
Don't scatter things too much (Locality of Behaviour).
Maintain consistent level of abstraction in your code (SLAP).
Treat SOLID, DRY, YAGNI, and the Law of Demeter as guidelines, not laws.
Eliminate NPEs with null-safe programming.
Organize code following The Stepdown Rule.
Replace getters with Queries.
Replace setters with Domain Methods.
Flatten conditionals with Monads.
Move from procedural design to Elegant Objects.
Cure primitive obsession with Value Objects.
Replace try-catch clauses with pluggable exception handling strategies.
Design data classes with Lombok, Immutables and pure Java.
Enhance Java collections with Guava and StreamEx.
Implement thread-safe lazy loading with Memoization.
Master advanced dependency injection patterns with Spring.
Learn principles for effective code packaging.
Test-drive components with Spock.
Day 2 ⋅ Architecture Principles and Patterns
Slice and structure your application by Features (Vertical Slice Architecture).
Modernize your application layer with the Mediator pattern.
Enable tracing, logging, and transactions for your app layer (without AOP, proxies, and other black magic).
Separate commands from queries with CQRS.
Mark clear boundaries between layers.
Map the domain to the API DTOs (and stay away from auto-mappers).
Design rich domain models with OO and FP patterns.
Break down God Objects with advanced DDD patterns (Specifications / Queries / Events / State Passing / Multimapping).
Connect domain entities with fast Event Bus (ForkJoinPool, Caffeine, and Springleton pattern).
Consolidate business rule validation in the domain model.
Run validation across all layers w/o duplicating the logic or triggering validation twice.
Move long-running processes into background with the Transactional Outbox.
Turn your relational database into a robust message queue.
Ensure jobs run once across the cluster by leveraging database locking.
Design a flexible data access layer (DAO, Repository, Unit of Work, Finder, Projection patterns).
Expose data safely and securely via public API (encryption, tokenization, UUIDs, ULIDs, Squids).
Optimize query performance by using a separate read model (JPA / jOOQ / JDBI).
Keep data safe under high-load scenarios by understanding tx locking, isolation modes, and trade-offs.
Make your application fault tolerant with Resilience Patterns (Resilience4j / Failsafe).
Enforce architectural constraints with ArchUnit.
Eduards Sizovs
Eduards has been involved in commercial software development for over 15 years. He quickly grew from a developer to architect, from architect to software engineering manager, from manager to IT director. Today, Eduards is training senior developers, architects and engineering leaders. He is a well-known international speaker, who had spoken at the largest conferences Worldwide. Eduards is a certified enterprise architect, CSM, CSPO and ICF coach.
