Clean Code: The Next Level
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
(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.
- ... and much more.
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.
By the end of this masterclass, you’ll have gained the knowledge and insights that usually take years to master. You’ll know exactly how modern and maintainable Java enterprise applications should be built, why so many fall short, and the practical steps to improve them.
FAQ
For whom is this course?
This course is perfect for Java developers, architects, and tech leads looking to expand their knowledge beyond trivial and easy-to-google concepts.
What are the prerequisites for this course?
You should have at least a few years of hands-on experience in enterprise software development with Java 8+. If you're passionate about clean code, refactoring, design patterns, software architecture, Spring, and alike, you'll do great in this course.
You'll be covering modern Java, but since I work with an old legacy codebase, won't I feel lonely?
No worries! You'll discover plenty of strategies for gradually improving your codebase. So if you're keen on improving the code – legacy or not – you'll feel at home.
How is the learning process organized?
The course is a mix of slides, demos, discussions, and exercises.
What tech will be used for demos/exercises?
Java (and bits of Groovy and Kotlin).
Do I need to prepare for this course?
You'll need the latest JDK installed, a decent IDE, and access to GitHub and Maven Central.
Will I receive a certificate upon completion of the course?
Yes, you’ll receive a digitally verifiable certificate of accomplishment.
What is the language of instruction?
The course is taught in English.
Which timezone does the course run?
Central European / CET / Berlin time.
What are the exact times of the course?
9:00 – 18:00 (max).
How would I develop my knowledge after the course?
You will receive a list of books, blogs, videos, and GitHub repos for self-development. After the course, you'll stay connected with alumni via group chat. You'll make new connections who will support you throughout this course and beyond. Eduards will remain available in group chat after the session for any questions, clarifications, and advice.
How do I convince my manager to send me to this course?
To make it easy to ask for company funding, download this template.
Questions?
Send an email to [email protected]
Testimonials
Alex K. ⋅ Senior Java Developer The course was absolutely above expectations. Usually courses just reuse "Clean Code" book and provide common sense recommendations. But not this one! More than 95% of information was top new and mind-blowing. I've got new practical tips to use in my everyday work and a completely new look on the things I do. Moreover, it inspired me for further growth as a professional and gave different directions, how to do it! Thanks, Eduard, this was the best training I ever attended!
Jahziah W. ⋅ Java Consultant This was the most advanced and best course I've been on! Also very entertaining! I learned that I should use more functional Java and that courses can be fun.
Liesbeth de Keyzer ⋅ Senior Software Developer I wanted to know how I could improve the quality of my code and your course gave me many tools to achieve that. I liked that it was about more than writing code. You gave some tips on how to deal with management and what you can do as a developer to change that for the better and that you need to stay true to yourself. I like that the course doesn't really end's here. That there is homework and that you encourage us to stay in contact. You inspired me to become a better developer and gave me the energy to become the best that I can be.
Sergey O ⋅ Java Programmer The course exceeded my expectations, because it focuses on fundamentals, essential knowledge, and things that actually matters rather than superfluous content. It has put me on a continuous and never-ending path of self-improvement, empowering me to take control of my professional journey. Thank you!
Anita R. ⋅ Java Solutions Architect Just wow. It's been fantastic two days with unique content that made me think and even rethink how I see and write code. The part about Domain-Driven Design (DDD) was enlightening and better explained than any book I've read on the topic. This workshop has delivered on the promise, improved me as a dev/architect, and opened new learning opportunities beyond the workshop. Kudos for great Slack conversations.
Ivan Shevchuk ⋅ Software Architect Fantastic course, and I'm glad I picked it. As a Senior Java Architect, I was hoping to not get bored too much :) But I have to say it went waaaay beyond my expectations and even reignited my passion for improving legacy code. What a cool way to do OOP, DDD, and services! So now I'm eager to learn more, apply and share what I've learned, and most importantly, enjoy the process. The best takeaway is re-discovering the fun in dealing with mundane legacy code most devs work with. Loved your energy and enthusiasm!
Lin Jin ⋅ Backend Team Lead (Java) Very instructive and entertaining course. I chose it because I wanted to get deeper insights on clean code and Java architecture.. and that is exactly what we got! The course met my expectations and even exceeded them. I thought I knew a lot, but this made me realize that you can never really learn enough. 😄 Great course!
Artur Karbone ⋅ Senior Software Engineer Absolutely, the camp met my expectations. A lot of insights during the workshop. Literally the next day I combined my vision of DDD with the patterns learned in the course and started applying them immediately.
Kristina A. ⋅ Java Developer For me, this masterclass was an eye-opener. It effectively presented big and deep ideas in a friendly and light atmosphere. Eduards stands out as an exceptionally knowledgeable, energetic, and humble mentor—the kind you wish you had but probably don't have :)) An incredibly well-designed, practical, and inspiring course that you want to keep going on and on.
Jeremy R. ⋅ Java Chapter Lead Amazing masterclass! It was packed with coding techniques, design patterns, best practices, refactorings, libraries, plus a new way to look at things. Ed made complex ideas simple, in ways I couldn't have put into words. I plan to use his explanations to guide my less experienced colleagues. The slides and examples were carefully prepared, perfect for clean code tips and inspiration. Ed's dedication to craftsmanship and quality shines through in every aspect, and the positive atmposphere made for an enjoyable experience. These two days were truly worthwhile. Great job! 👏
Superskills