2 days
Online / Zoom
English
Certificate
15 people max
Victor Rentea
€7500
9375
Practical, pragmatic, and realistic Clean Architecture certification training for Java developers building large-scale applications.
Introduction
This training will guide you through the major architectural styles and patterns for backend systems, including Clean Architecture, Hexagonal Architecture, Layered Architecture, Vertical Slices Architecture, Domain-Driven Design, Modular Monoliths, and Microservices.
By understanding every style and its trade-offs, you’ll learn how to combine them in your application while avoiding common pitfalls. Guided by real-world Java examples, you’ll learn how to:
Day 1 ⋅ Design clean and pragmatic architecture
Slice and structure your application by Features.
Group code by the axis of change.
Organize code in functional top-level packages.
Find package boundaries (heuristics).
Remove cyclic dependencies between packages (6 strategies).
Separate module/compilation units.
Decouple modules/packages/components with Dependency Inversion.
Reduce cognitive load with modularity and information hiding.
Enforce architectural constraints.
Isolate the core application logic from the infrastructure.
Test your core logic, infrastructure, and integrations.
Segregate data structures and DB Schemas.
Balance between uniformity/standardization and pragmatism.
Leverage Evolutionary Architecture and avoid big up-front designs.
Incrementally migrate from legacy Big Ball of Mud to Modulith/Microservices.
Day 2 ⋅ Design clean services and domain model
Apply SOLID Principles and Five Rules of Simple Design.
Masterfully balance coupling and cohesion.
Make your code speak the domain language.
Separate the core domain from subdomains.
Decouple domains with APIs and events.
Design rich domain entities (OOP done right).
Protect domain objects’ invariants (strategies).
Decouple the domain from the infrastructure, API, and persistence.
Create an Anti-Corruption Layer with Adapter pattern.
Test-drive the domain with fast unit tests.
Map the domain to the API DTOs (and stay away from auto-mappers).
Separate logic by Layers of Abstraction.
Design Application Services, Controllers, and Façades.
Logically separate commands from queries with CQRS.
Improve query performance by using a separate read model.
Keep write and read models in sync.
By the end of this course, you’ll be able to mix and apply essential architectural styles – Clean-, Hexagonal-, Layered-, Onion-, Screaming-, and Vertical Slices- Architectures, Domain-Driven Design, Microservices, Monolith, and Modular Monoliths. You’ll develop a firm understanding of the underlying architectural principles and learn how to implement them in your Java applications incrementally, as necessary, without big rewrites.
Victor Rentea
Victor is a Java Champion, Java Enterprise Architect, and Independent Trainer, delivering intense masterclasses for companies worldwide since 2014. He is passionate about software architecture, clean code, refactoring, and unit testing. He is a regular speaker at top international conferences. He's also the founder of the Bucharest Software Craftsmanship Community with 4000 members.
