Pragmatic Clean Architecture

For a small application, the speed of development typically outweighs the design concerns. Getting your code to production as fast as possible becomes your first goal. And nothing is faster than building a (messy) monolith. However, not many months of development later, or when the team grows bigger, you need to change your attitude. Keeping the design clean becomes crucial to the long-term survival of your project in the ever-changing environment of today.

This training covers the most important architectural concepts and principles underlying the most widely used architectures today, that every developer should be familiar with before implementing any production code. Inspired by the Domain-Driven Design (DDD) movement and Adam Bien's book Rethinking Java EE Patterns, the course introduces a strategy for evolutionary architectures, allowing you to expand the design to accommodate growing complexity in the requirements.

This is the recording of a 3.5 hours live webinar that took place in June 2021.

Note: After watching the recording you can ask me any question you have via email.

Agenda

• Adapter Design Pattern and the Anti-Corruption Layer (DDD)
• Dependency Inversion Principle - stop external systems from polluting our Domain
• Facade Design Pattern and the Application Service (DDD)
• Layered Architecture and Relaxed- variant
• “Light-CQRS” - Separate Read/Write Models in a pragmatic way
• Repository Pattern - when to design a separate Persistence Model?
• Data Transfer Objects (DTOs) - why/when to keep them out of our Domain
• The Universal Architecture (aka Clean-, aka Hexagonal-, aka Ports-and-Adapters, aka Onion-)
• A pragmatic approach to evolving the architecture to cope with increasing complexity
• Breaking down a monolith into independent verticals - an incremental technique
• Stages of decoupling: data links, inter-domain calls, and events, transactions, database links and replication, cross-domain queries, microservices.
• Applying incremental constraints to the architecture

What to expect?

The course is mainly composed of debates about architecture styles, design concerns, pitfalls, and tradeoffs. To demonstrate some of the incremental decoupling techniques, we often jump to code to experiment with the ideas (30-50% of the time). Along the lines, you'll also learn a number of pragmatic coding tricks you should have in your toolbox, some related to Spring Framework, but most - framework-agnostic.

After following this course you’ll acquire a solid knowledge of the core design principles, applied to a range of scenarios. You’ll be able to understand “the why” behind your current architecture or perhaps challenge the status-quo to further simplify your code. Of course, any questions you might have after watching the recording are warmly welcome.

After the purchase you will get: the video recording, all the slides, and the code zipped together with Git commit history.

This Training is for you because:

• You want to rethink your current project architecture - migrating to microservices, modularizing the codebase, or just cleaning it up
• You are about to start a new project (or recently started) and you want to make sure you are on the right track
• You simply want to know more about software architectures, and how you can make the best design decisions tomorrow

Prerequisites:

• Some prior contact with design decisions/architectures is recommended, or
• Enthusiasm about software design.

Technical Requirements

I would recommend you get yourself a black coffee and pay close attention to the discussion, stop the recording at any moment, debate the ideas with your colleagues and perhaps try to reproduce my coding on your own machine. Next to the video you can download the code zipped together with the git history, so you can explore my commits if you get lost.

To run the project you will need a Java 8+ SDK installed, a decent IDE, and access to GitHub and Maven Central.