Evolutionary architectural patterns with Clean and Hexagonal Architecture

-- Description

This training helps you to recognize problems of layered architecture and provides you with a toolbox of exercises that you can use to implement clean and hexagonal architecture. After the training, you will be able to continuously test your architecture and apply the evolutionary architecture mindset.

When expanding existing systems, we repeatedly stumble across rigid architectures that cannot be expanded or even grown systems that no longer allow any expansion that matches the architecture, as there is no longer any recognizable architecture. As a result, the underlying business model can no longer evolve. But how can we prevent this scenario? How can we implement an architecture in our software system that can withstand the evolution of the system?

Both the Clean and the Hexagonal Architecture promise a clear separation of the functional domain from the infrastructural aspects. The core idea, the Ports and Adapters Pattern, is powerful and helps to realize technical, functional and organizational flexibility in the software architecture. Building on this, we will examine the Clean and Hexagonal Architectures in the context of Evolutionary Architecture and present implementation options for Fitness Functions for these architecture patterns.

In the training “Evolutionary Software Architecture” we will talk about similarities, differences, benefits, trade-offs and pragmatic development approaches for these architecture patterns. Using a demo application in Java, we will analyze code examples together and implement them ourselves using a functional example. We will use the building blocks of tactical domain-driven design and learn how to implement them embedded in the clean architecture. You will be given access to the demo application with Spring Boot and Java and will have the opportunity to study the topic in more depth afterwards.

-- Agenda

**Day 1

Software architecture as structure and methodology

• Functional system decomposition and modularization
• Architectural patterns, architectural principles, design patterns and pattern language
• Time-to-adaptation and structural quality of software architecture

Ports & adapters as architectural patterns

• The weaknesses of layered architecture
• From layered architecture to ports & adapters architecture patterns

Creating an isolated domain

• Implementation of business objects and specialized values according to the principle of the rich domain model
• Implement domain-related data validation
• Distribute different tasks to the class stereotypes Service, Root Entity, Entity and Value Object
• Code exercise: Domain model

Hexagonal Architecture

• Implementation of business objects and specialist values according to the principle of the rich domain model
• Implement domain-related data validation
• Distribute different tasks to the class stereotypes Service, Root Entity, Entity and Value Object
• Code exercise: Domain model

Clean Architecture

• The domain in the clean architecture
• The use case ring of the clean architecture
• Principles of the use case section
• The framework ring of the clean architecture
• Call flow through the clean architecture
• Code exercise: Use case ring and framework ring

**Day 2

**Mapping strategies

• One-way, two-way and full mapping strategy
• Simplifying mappings with third-party libraries
• Mappers, converters and factories
• Code exercise: Two-way mapping strategy

Domain-Driven Modularization

• Modularization with domain modules using root entities
• Structuring domain modules
• Design patterns for relationships between domain modules
• Coding exercise: Dependencies between domain modules

**Evolutionary architecture

• Motivation for architecture discipline based on the Broken Window Theory
• The mindset of evolutionary architecture
• Fitness Functions for Clean and Hexagonal Architecture
• Coding exercise: Clean Architecture Fitness Functions with ArchUnit

-- Audience

This training is aimed at software architects and developers who want to understand these architectural patterns and their application in everyday project work. Participants should have the following experience and knowledge:

• More than 12 months of practical experience in software development in a team of medium to large software systems.
• Knowledge and practical experience in at least one high-level programming language (Java will be used for the course examples)
• Familiar with layered architecture, SOLID principles, design patterns, dependency injection and modularization concepts (modules, packages, namespaces)
• Familiar with the creation of domain-oriented object models in Java or a comparable programming language

-- Training Objectives