Victor Rentea

This workshop explores the key design decisions in the architecture of a backend system and studies their pros/cons. With a pragmatic attitude, we learn how to progressively introduce boundaries in our design to reduce the code complexity despite accumulating features. Along our journey we discover fundamental design principles, and we brainstorm the mainstream backend architecture styles: Layers, Hexagonal, Onion and Modulith. The concepts are put in practice by refactoring 2 sample Java applications while keeping the Java/framework specifics to a minimum.

After this workshop you will be able to:

• Develop a firm understanding of the core architectural principles.
• Learn to analyze tradeoffs of design decisions.
• Master the state-of-the-art backend architectural styles.
• Implement architectural changes incrementally, without large, risky rewrites.

This workshop is for you if:

• You are a developer (in any programming language) looking to grow into an architect.
• You are an architect / technical coach that wants an update on current trends in architectures.
• You are looking to debate design decisions in your codebase.

Agenda:

Fundamentals

• The 3 Laws of Architecture
• Cohesion/Coupling
• Design Principles: SOLID, DRY, KISS, Beck's Rules of Simple Design
• Evolutionary Architecture: Over-engineering vs Under-design
• Documenting Architecture: ADR, Diagrams, C4 Model
• Architectural Characteristics (NFRs)

Rich Domain Model  (from Domain-Driven Design)

• Ubiquitous Language in a Bounded Context
• Deep Domain Model with Value Objects
• Rich Domain Model with behavior and domain constraints
• Three Axis of Code Complexity: Cyclomatic vs Orchestration vs Data
• Exercise: refactoring to a Rich Domain Model

Agnostic Domain

• Adapter Pattern and Dependency Inversion
• Enforce boundaries with compiler and architecture fitness tests (ArchUnit)
• Exercise: extract infrastructure from core logic 
• Exercise: write one architecture fitness test on your project

Exposing an API

• API Versioning (SemVer), backwards compatibility & contract tests (Pact/SCC)
• Lab: generate breaking changes in an API
• Contract- vs Code-first API development
• Automatic Mappers Pitfall
• Command-Query Responsibility Segregation (CQRS) at 3 levels
• Task-Based UI vs a large PUT/PATCH
• Error Handling Best Practices

Logical Architecture Styles

• Layered Architecture
• Separation by Layers of Abstraction
• Exercise: push complexity from Application Service into Domain Services
• Hexagonal Architecture (aka Ports-and-Adapters)
• Onion Architecture
• Clean Architecture Rules by Uncle Bob
• Vertical-Slice Architecture by Jimmy Bogard

Modular Monolith (Modulith) Architecture

• Technical vs Functional partitioning
• Module contract: internal/external, calls/events/plugins
• Module interaction patterns, breaking module cycles
• Event Design: fine/coarse, notification/stateful
• Levels of data decoupling
• From packages to build modules (eg. Maven/Gradle)
• Steps to extract a Module as a Microservice
• Reasons to move to Microservices
• Exercises using Spring Modulith

* If you're interested in this program, please contact us at info@itkonekt.com to find out more about availability and prices.