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.

Slides available at https://speakerdeck.com/olivergierke/it-takes-two-to-tango-designing-module-interactions-in-modulithic-spring-applications

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.

Folien unter https://speakerdeck.com/olivergierke/it-takes-two-to-tango-designing-module-interactions-in-modulithic-spring-applications

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.

Slides available at https://speakerdeck.com/olivergierke/bottom-up-architecture-bridging-the-achitecture-code-gap

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.

Folien unter https://speakerdeck.com/olivergierke/bottom-up-architecture-bridging-the-achitecture-code-gap

Spring Modulith – Spring for the Architecturally Curious Developer en de

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.

Slides available at https://speakerdeck.com/olivergierke/spring-for-the-architecturally-curious-developer.

Spring Modulith – Spring für architekturinteressierte Entwickler:innen en de

Die Architektur und das Design einer Applikation beeinflussen ihre Wartbarkeit, Testbarkeit und Qualität im Allgemeinen. Spring war schon immer ein vielseitiges Werkzeug, das Architekt:innen dabei unterstützt, Muster zu implementieren, mithilfe derer technische Bausteine der Applikation mit Domänenkonzepten und -grenzen verknüpft werden können. Es erlaubt Entwickler:innen Anwendungen zu schreiben, die ihre architektonischen Ideen deutlich reflektieren und so ultimativ änder- und damit wartbarere Anwendungen zu schreiben. Schlüsselaspekte dahin gehend sind Codeorganisation, das Spring-Bean-Arrangement und die Nutzung von Domänen-Events, um fachlich individuelle Teile der Applikation voneinander zu entkoppeln.

Der Vortrag diskutiert diese Muster und Ansätze und stellt Spring Moduliths vor, um zu zeigen, wie Entwickler:innen in die Lage versetzt werden, besonders gut strukturierte und wartbare Anwendungen zu schreiben.

Tactical Domain-Driven Design with Java en de

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.

Taktisches Domain-Driven Design mit Java en de

Die Kernbausteine des taktischen Designs in Domain-Driven Design (DDD) definieren atomare Designkonzepte für Domänenmodelle. Sie definieren Semantik, Regeln und leiten Entwickler:innen dabei, fachlichen Code zu strukturieren und so komplexe Geschäftslogik zu implementieren. Die Umsetzung in Java birgt dabei jedoch einige technische Herausforderungen.

In diesem Workshop betrachten wir verschiedene Ansätze und Werkzeuge, die Entwickler:innen dabei unterstützen reichhaltige Domänenmodelle in Java zu implementieren: die jMolecules Bibliothek ermöglicht es, DDD Konzepte direkt in Code auszudrücken und bietet darüber hinaus Integration in weitverbreitete Technologien wie Spring, Jackson und Persistenztechnologien. Für Spring Boot Applikationen unterstützt das Spring Modulith Projekt Entwickler:innen bei der Umsetzung von Modulen, der Interaktion dieser über Events, bei der individuellen Testbarkeit und dem Erzeugen von Dokumentation über diese.

Der Workshop kann in verschiedenen Längen (2 bis 8 Stunden) stattfinden und unterscheidet sich dann in der Tiefe der Betrachtung. Themenschwerpunkte können gern vom Publikum gesetzt werden.

Architecturally evident Java applications with jMolecules en de

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.

Slides available at https://speakerdeck.com/olivergierke/architecturally-evident-java-applications-with-jmolecules

Architekturexplizite Java-Applikationen mit jMolecules en de

Java-Applikationen basieren gewöhnlicherweise auf einem Framework oder einer Entwicklungsplattform. Einige davon erlauben es, architektonische Konzepte auszudrücken. Diese jedoch direkt in Code abzubilden, bleibt meist eine Herausforderung, ebenso wie die Trennung von fachlichem Code und Applikationsframework.

jMolecules ist eine Framework-unabhängige Bibliothek die es erlaubt, verbreitete, architektonische Konzepte direkt in Code darzustellen, zu überprüfen, ob Regeln bezüglich der Implementierung dieser eingehalten werden und die nötige technische Integration, sowie entsprechende Dokumentation abzuleiten.

Der Vortrag gibt einen Überblick über den grundsätzlichen Ansatz und zeigt, wie Entwickler:innen die bereitgestellten Abstraktionen nutzen können. Darüber hinaus wird konkrete Integration mit Spring, Jackson und JPA sowie die Generierung von Dokumentation am praktischen Beispiel gezeigt.

Folien unter https://speakerdeck.com/olivergierke/architecturally-evident-java-applications-with-jmolecules

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.

A Deep Dive into Spring Application Events en de

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.

Slides available at https://speakerdeck.com/olivergierke/a-deep-dive-into-spring-application-events

Spring Application Events unter der Haube en de

Events sind heutzutage Schlüsselelemente beim Design moderner Applikationen, besonders im Kontext verteilter Architekturen. Aber auch in monolithischeren Anwendungen können sie genutzt werden um die Modularität zu verbessern. In Spring basierten Applikationen bietet die ApplicationEvent Abstraktion und die daran angeschlossene Infrastruktur eine solide Implementierungsbasis dafür.

Der Vortrag beginnt mit einem Überblick über die Grundkonzepte, die Spring in Bezug auf Events bereitstellt. Danach werden verschiedene Möglichkeiten besprochen, wie diese genutzt werden kann um Spring Komponenten voneinander zu entkoppeln und wie Spring Data dabei hilft, dies sehr domänengetrieben umzusetzen. Abschließend werden erweitere Szenarien, Auswirkungen auf das Transaktionshandling und allgemeine Fehlerbehandlung besprochen.

Folien unter https://speakerdeck.com/olivergierke/a-deep-dive-into-spring-application-events