Domain-Driven Design Building Blocks in Code with xMolecules en

A core part of tactical design in DDD are fundamental stereotypes that can be assigned to model elements. It allows assigning particular roles to them to support our ability to navigate the model and – to some degree – constrain implementation options in the solution space. Still, expressing those higher-level abstractions in code has been a challenge to development teams until today.

xMolecules is a framework-independent library that allows expressing architectural and design concepts in code of various programming languages, to verify whether it adheres to the rules the concepts imply and, optionally, derive integration into technical platforms or generate documentation.

The talk gives an overview about jMolecules, the Java flavor of the project, describes the fundamental approach applicable to other language ecosystems as well and how developers would use the provided abstractions. The examples show the integration with Spring Boot and related technologies, as well as how to extract useful documentation from the codebase.

It Takes Two to Tango – Designing Module Interactions in Modulithic Spring Applications en de

According to Russell Ackoff “A system is not the sum of the behaviors of its parts, but the product of their interactions”. That’s why the design of those interactions is of the uttermost importance. In a Spring application, the primary means to establish relationships between application components is dependency injection (DI). With higher-level structuring approaches like Spring Modulith’s application modules in place, should the interaction of those be implemented by DI as well?

The talk presents different approaches to designing application module interactions and compares them regarding their applicability, effect on testability, consistency, error scenarios and how they affect the modularity of the system overall.

Es gehören immer zwei dazu – Modulinteraktionen in Spring Applikationen gestalten en de

Ein berühmtes Zitat von Russel Ackoff lautet: „A system is not the sum of the behaviors of its parts, but the product of their interactions.“ Aus diesem Grund ist die Gestaltung der Interaktion von Applikationsteilen beim Systemdesign von großer Bedeutung. In einer Spring-Anwendung ist das primäre Mittel zur Herstellung von Beziehungen zwischen Anwendungskomponenten  Dependency Injection (DI). Gibt es jedoch Strukturierungsansätze auf höherer Ebene, wie z. B. die Application Modules von Spring Modulith, sollte dann auch die Interaktion dieser Module durch DI implementiert werden?

Der Vortrag stellt verschiedene Ansätze zur Gestaltung von Interaktionen zwischen Anwendungsmodulen vor und vergleicht sie hinsichtlich ihrer Anwendbarkeit, Auswirkungen auf Testbarkeit, Konsistenz, Fehlerszenarien und wie sie die Modularität des Systems insgesamt beeinflussen.

Bottom-up Architecture – Bridging the Architecture Code Gap en de

Hard to change code bases often suffer from two primary problems: a lack of alignment with domain boundaries and failure to effectively express architectural ideas in code. To address that critical issue, developers have turned to Separation of Concerns Architectures, such as Onion-, Clean and Hexagonal Architecture. However, these approaches typically yield mixed results, as they primarily focus on separating technical and business code, without addressing the structural aspects of the domain.

This presentation aims to delve into strategies for transferring architectural ideas and design pattern languages into code at various levels of abstraction. We will explore how different frameworks and libraries in the Java ecosystem can aid in this process, leveraging the presence of meta-information within the code to support critical aspects such as structural verification, testability, and documentation. By employing these approaches and tools, developers can write more maintainable code that is less susceptible to degradation over time.

Architektur von unten – die Brücke schlagen zwischen Code und Architektur en de

Code-Basen, die schwer zu ändern sind, leiden oft unter zwei großen Problemen: einer fehlenden Ausrichtung an Domänengrenzen und dem fehlenden Ausdruck architektonischer Ideen im Code. Um dieses kritische Problem anzugehen, greifen Entwickler auf Separation-of-Concerns-Architekturen wie Onion-, Clean- und Hexagonal-Architektur zurück. Diese Ansätze erzielen jedoch oft gemischte Ergebnisse, da sie sich hauptsächlich auf die Trennung von technischem und Business-Code konzentrieren, ohne die strukturellen Aspekte der Domäne zu berücksichtigen.

In dieser Präsentation diskutieren wir Strategien zur Übersetzung von architektonischen Ideen und Designpatterns in Code auf verschiedenen Abstraktionsebenen. Wir erkunden, wie verschiedene Frameworks und Bibliotheken im Java-Ökosystem diesen Prozess unterstützen, indem sie die im Code vorhandenen Metainformationen für eine strukturelle Überprüfung, Testbarkeit und das Generieren von Dokumentation nutzen.

A Deep Dive into Spring Application Events en

Events have become a key element of modern application design especially when it comes to distributed applications. But also in monolithic applications they can be used to improve modularity as Spring’s ApplicationEvent abstraction and the associated infrastructure components make it easy to design, publish and consume events.

The talks starts by giving an overview about the building blocks of Spring’s core event infrastructure. It continues with an example of how to decouple Spring components using events, discusses different ways of implementing a variety of interaction scenarios and how Spring Data allows to take a more domain-driven approach to event publication. We end up by discussing advanced event handling scenarios and failure handling.

German version of the abstract available, too.

Architecturally evident Java applications with jMolecules en

Java applications are usually written using a certain framework or at least based on a particular platform. Some of them provide means to express architectural concepts, but usually, there's a gap between architectural and design patterns and the actual code. Closing that gap is a challenge, and it's hard to separate code from technology.

jMolecules is a framework independent library to express well-known architectural patterns in Java code and let technical integration with frameworks, compliance with implementation heuristics and documentation of the system's current arrangement be derived from that.

The talk gives an overview about the fundamental idea and the way jMolecules allows developers to make use of it. We then discuss a variety of optional technology integration into Spring, Jackson, JPA, and MongoDB as well as how to generate, high-level, structural documentation from that.

German version of the abstract available, too.

Spring Modulith – Spring for the Architecturally Curious Developer en

The architecture and design of an application significantly influences its maintainability, testability, and quality in general. Spring has always been a versatile tool that supports architects implementing the practices and patterns that have emerged to align technical building blocks in their code bases with domain concepts and boundaries. It lets developers build applications that clearly reflect architectural ideas and that are ultimately more amendable and maintainable. Key aspects of that are code organization for encapsulation, the Spring bean relationship arrangement, and how to use domain events to decouple logically individual parts of the application even within a singular artifact.

The talk discusses those patterns and approaches to introduce Spring Modulith to, in turn, show how they uniquely position Spring developers to build better structured, more maintainable applications.

German version of the abstract available, too.

Tactical Domain-Driven Design with Java en

The building blocks of tactical Domain-Driven Design (DDD) define atomic design concepts for domain models. They define semantics, rules and guide developers how to structure code to develop complex business logic. However, the implementation of those in Java usually leads to some technical challenges.

In this workshop, we look at different approaches and tools that support developers building rich domain models in Java: the jMolecules library, that allows expressing DDD concepts in code and that provides integration with many ubiquitous technologies like Spring, Jackson and various persistence technologies. For Spring Boot applications, the Spring Modulith project supports developers to implement business modules, the interaction among them using events, their testability and documenting them.

This workshop can be delivered from 2 to 8 hours, effectively only varying in depth of the content, which can in turn vary based on the interest of the audience.