Cloud-native Microservices in Monorepos – Teil 2

Nachdem wir in Teil 1 die Vorteile und Herausforderungen von Microservices in Monorepos diskutiert haben, konzentrieren wir uns nun darauf, wie Nx diese Struktur für AWS CDK-basierte Anwendungen unterstützt.

Was ist Nx?

Nx ist ein JavaScript basiertes Buildsystem für Monorepos. Es ermöglicht die effiziente Ausführung aller Aufgaben wie Build und Test über mehrere Projekte in einem Monorepo, unabhängig davon, ob NPM, Yarn oder PNPM als Paketmanager verwendet wird. Nx bietet auch einen vollständig integrierten Modus, der keine separaten package.json Dateien für jedes Projekt benötigt. Dies ermöglicht eine tiefere Integration und ist besonders interessant für UI-Anwendungen mit AngularJS oder React.

Beginnen wir mit einem einfachen Beispiel. Wenn wir das Build-Skript für Service A ausführen wollen, können wir dies wie folgt tun:

npx nx build service-a

Nun gibt es in unserem Beispiel Repository (siehe Abbildung 1, Teil 1) auch die Services B und C. Wenn wir das Build-Skript für alle Projekte im Repo ausführen wollen, gehen wir wie folgt vor:

npx nx run-many -t build

Es ist interessant zu sehen, dass dies schneller funktioniert, als wenn wir es einzeln ausführen würden. Das liegt daran, dass Nx sie parallel ausführt, wenn unsere Services so konzipiert sind, dass sie zur Build-Zeit unabhängig voneinander sind (was sie bei einem guten Design auch sein sollten).

Die Stärke von Nx zeigt sich besonders im Zusammenspiel mit der Versionsverwaltung des Git-Repositories. Es ist möglich, nur die Target Scripts der Projekte und deren Abhängigkeiten auszuführen, bei denen im Vergleich zwischen Head und Base Änderungen festgestellt wurden. Angenommen, es gibt nur Änderungen im Service B in einem Branch für einen Pull Request zum Basis-Branch „dev“. Im folgenden Beispiel würde das Build-Skript nur für Service B ausgeführt werden. Die Scripts der anderen Projekte werden nicht ausgeführt.

npx nx affected -t build

Kehren wir zum Beispiel-Repository aus Teil 1 zurück. Die package.json jedes Service enthält das entsprechende CDK deploy Skript. Für Service A sieht dieses vereinfacht so aus:

"name": "service-a ",
"version": "0.1.0",
"scripts": {

   "deploy": "cdk deploy ServiceAStack …",
}, 
"dependencies": {
    "custom-lib": "*"
}

Zusätzlich haben wir eine Abhängigkeit zu einer benutzerdefinierten Bibliothek, die von allen drei Services verwendet wird. Angenommen, wir nehmen eine Änderung an dieser Bibliothek vor und führen anschließend folgenden Befehl aus:

npx nx affected -t deploy

In diesem Fall werden die Deployment-Skripte aller drei Services ausgeführt. Dies geschieht, weil sich die Bibliothek geändert hat und somit indirekt alle drei Services betroffen sind. Nx berücksichtigt also den Abhängigkeitsgraphen zwischen den einzelnen Projekten innerhalb des Monorepos. Um hier den Überblick zu behalten, bietet Nx eine nützliche Visualisierung aller im Repository enthaltenen Module und deren Abhängigkeiten. Mit dem Befehl

npx nx graph

wird lokal eine WebApp gestartet, mit deren Hilfe die Modulstrukturen und deren Abhängigkeiten untereinander im Browser untersucht werden können.

Das alles zusammen ist sehr mächtig, wenn man bedenkt, dass für praktisch jede Aufgabe wie Build, Unit Tests, Code Style Checks, Integrationstests, Audit, Deployment und vieles mehr in den Projekten entsprechende Target-Skripte in der package.json definiert werden können. Durch die konsistente Benennung dieser Skripte über die Projekte hinweg können für jede dieser Aufgaben separate automatisierte Workflows (z.B. mit GitHub Actions) bereitgestellt werden. Diese sind so allgemeingültig, dass sie nicht einmal angepasst werden müssen, wenn weitere Projekte wie Services oder Bibliotheken hinzugefügt werden. Damit haben wir ein effektives Mittel, um möglichen Problemen eines monolithischen CI/CD Prozesses zu begegnen.

Nx und AWS CDK: Passt das zusammen?

Mit AWS CDK steht uns ein Framework für Infrastructure as Code zur Verfügung, das es ermöglicht, die gesamte serverlose Infrastruktur in TypeScript zu definieren. Bei der Strukturierung wird empfohlen, sowohl den Infrastrukturcode als auch den Businesscode in einer Applikation zu vereinen. Jeder Service wird somit zu einer separaten CDK-Applikation mit eigenen Stacks.

Nx ermöglicht die einfache Organisation von AWS CDK-Applikationen in separaten Paketen. Dieses Zusammenspiel ermöglicht eine übersichtliche und gut organisierte Entwicklung von Cloud-Anwendungen, bei der AWS CDK die Infrastrukturaspekte effizient handhabt und Nx die Flexibilität bietet, die verschiedenen Teile der Anwendung in einem Monorepo zu verwalten.

Für unser Beispiel-Repository würde dies stark reduziert wie folgt aussehen:

monorepo/
├── apps/
│ ├── service-a/
│ │ ├── bin/
│ │ │ └── service-a-app.ts
│ │ ├── lib/
│ │ │ └── service-a-stack.ts
│ │ ├── cdk.json
│ │ └── package.json
│ ├── service-b/
│ │ └── …
│ ├── service-c/
│ │ └── …
│ └── ui/
│   └── …
├── libs/
│ └── custom-lib/
│   ├── index.ts
│   └── package.json
├── nx.json
└── package.json

In dieser Struktur gibt es auf der obersten Ebene zwei verschiedene Workspaces. Einen für alle Applikationen (service-a, service-b, service-c und ui) unterhalb des apps-Ordners. Jede Applikation folgt der empfohlenen Struktur für eine einzelne CDK-Applikation. Der zweite Workspace libs enthält die gemeinsame Bibliothek custom-lib mit ihrer eigenen Struktur und package.json. Die Datei nx.json dient zur Konfiguration von Nx und enthält lediglich Standardeinstellungen für das gesamte Monorepo.

Diese Struktur kann beliebig um weitere Services, Libraries und ganze Workspaces erweitert werden, indem einfach neue Packages hinzugefügt werden.

CI/CD leicht gemacht

In der bisherigen Struktur haben wir das Monorepo für eine Architektur aus mehreren Cloud-Native Microservices definiert, die als separate CDK-Applikationen existieren. Nx ermöglicht uns eine effiziente Verwaltung dieser Anwendungen.

Allerdings reicht es in der Praxis oft nicht aus, ein Deployment-Skript nur für ausgewählte Services effizient auszuführen. Ein gängiger Ansatz ist es, die einzelnen CDK-Stacks der Applikationen über eine AWS CodePipeline zu erstellen und in die gewünschten Ziel-Accounts der verschiedenen Stages bereitzustellen. Dieser Ansatz ist mit dem Monorepo-Ansatz vereinbar, führt jedoch dazu, dass für jede Service-Applikation eine separate Pipeline verwaltet werden muss. Dieses Vorgehen ähnelt einem Multi-Repo-Ansatz, und der Verwaltungsaufwand wächst mit der Anzahl der Services.

Eine alternative Variante besteht darin, eine einzige Pipeline aufzubauen, die alle Stacks aller Services erstellt, testet und bereitstellt. Dabei besteht jedoch das Risiko eines monolithischen, zeitaufwändigen CI/CD-Prozesses, wie im Teil 1 beschrieben. Zusätzlich gehen die Vorteile von Nx verloren, da AWS CodePipeline bisher keine Integration dafür bietet.

Abbildung 2: Monorepo CI/CD

Daher möchten wir an dieser Stelle eine weitere Variante betrachten, die in Abbildung 2 dargestellt ist. Mit diesem Ansatz versuchen wir, die oben genannten Möglichkeiten zu kombinieren. Insbesondere während der Entwicklung profitieren wir stark vom Monorepo-Ansatz in Verbindung mit Nx und können viele Entwicklungsschritte automatisieren. Da wir GitHub als Repository verwenden, können viele Aufgaben für unser Monorepo als GitHub Actions implementiert werden, unter anderem das Deployment der einzelnen Service CDK Stacks in einen AWS Dev-Account. All dies basiert auf dem Nx affected-Feature und ermöglicht so eine sehr automatisierte und effiziente Entwicklungsumgebung.

Für das Deployment der Gesamtapplikation in die weiteren notwendigen Stages (QA, STG, PROD) haben wir im Monorepo zusätzlich ein Pipeline-Projekt aufgesetzt, das alle notwendigen Stacks verbindet und konfiguriert, in welche Ziel-Accounts diese je nach Stage deployt werden sollen. Dabei ist uns die atomare und native Bereitstellung innerhalb des AWS Kosmos über eine AWS CodePipeline wichtiger als die Effizienz.

Schlussfolgerung

Unsere Betrachtung hat gezeigt, dass der Entwicklungsprozess von mehreren Microservices in Monorepos mit Nx auch für CDK-Applikationen sehr effizient sein kann. Insbesondere einzelne Teams profitieren von den klaren Vorteilen des vereinfachten Dependency Managements, der erleichterten Zusammenarbeit und der einfachen Möglichkeit, umfangreiche Refactorings durchzuführen, was Monorepos zu einer attraktiven Option macht. Bei teamübergreifenden Projekten hängt der Erfolg stark davon ab, wie gut die Teams zusammenarbeiten können. Eine effektive Abstimmung auf gemeinsame Richtlinien und Patterns ist entscheidend.

Trotz der offensichtlichen Vorteile von Monorepos bleibt die Gestaltung von CI/CD-Prozessen eine Herausforderung. Durch den geschickten Einsatz geeigneter Werkzeuge können jedoch schlanke und klare Prozesse geschaffen werden. Der Monorepo-Ansatz in Kombination mit den richtigen Werkzeugen kann eine vielversprechende Möglichkeit bieten, die Entwicklung und Bereitstellung von Cloud-nativen Microservices effizient zu gestalten. Dabei gilt es, die Vorteile zu maximieren und mögliche Herausforderungen gezielt anzugehen.

Cloud-native Microservices in Monorepos – Teil 1

In der Software-Architektur von Webanwendungen hat sich in den vergangenen Jahren ein Paradigmenwechsel vollzogen. Weg von monolithischen Strukturen hin zu heterogenen Architekturen, die sich durch die Implementierung verschiedener Microservices auszeichnen. Auch in größeren, komplexen, serverlosen und Cloud-native Webanwendungen für Amazon Web Services (AWS) wird dieses Vorgehen empfohlen. Dabei wird üblicherweise der Infrastrukturcode für unterschiedliche Technologien, der Businesscode sowie die notwendigen CI/CD-Prozesse mithilfe des AWS Cloud Development Kit (CDK) je Service in einer Applikation zusammengefasst. Diese Applikationen werden typischerweise jeweils in einem eigenen Repository untergebracht.

Die Aufteilung in verschiedene Microservices unter Anwendung von Domain-Driven Design erweist sich selbst für individuelle Teams, innerhalb von Teilprojekten, oder für kleinere Projekte als sinnvoll. Manchmal übernimmt ein Team auch aus organisatorischen Gründen die Verantwortung für mehrere Services.

Parallel zu dieser Strukturierung gibt es jedoch auch immer wiederkehrende Herausforderungen im Bereich Infrastrukturcode und technischer Lösungen für Querschnittsaspekte, die eine einheitliche und zentralisierte Bereitstellung erfordern. Hierbei entsteht für einzelne Teams jedoch ein erheblicher Mehraufwand in Bezug auf die Bereitstellung verschiedener Bibliotheksversionen, die Verwaltung von Abhängigkeiten und die Pflege von CI/CD-Prozessen in unterschiedlichen Repositories.

Ein Ansatz zur Bewältigung dieser Herausforderungen besteht darin, die Verwendung eines Monorepos in Betracht zu ziehen. Im Kontext von Microservices-Architekturen auf Basis des CDK stellt sich die Frage: Warum nicht alle Services und Abhängigkeiten in einem gemeinsamen Repository zusammenfassen, ohne jedoch eine monolithische Struktur zu schaffen?

Abbildung 1: Von Monolithen zu Microservices in Multi-Repos und wieder zurück zu Monorepos?

Abbildung 1 zeigt beispielhaft ein derartiges Szenario. Eine ursprünglich entwickelte und gewachsene Anwendung, die sich in einem Repository als Monolith befand, wurde zunächst in eine Microservices-Architektur mit mehreren Repositories umgewandelt. Diese Architektur besteht aus verschiedenen CDK-Applikationen und Bibliotheken. Schließlich erfolgte im Rahmen der Software-Evolution die Zusammenführung der einzelnen Komponenten und Services in ein Monorepo. Dies ist lediglich ein Beispiel aus einem existierenden Projekt und keine generelle Empfehlung, obwohl solche Migrationen in der Praxis häufig vorkommen. Bei Projektbeginn sollte man sich bewusst über die geeignete Strategie sein und kann, nach sorgfältiger Abwägung, direkt mit dem Monorepo-Ansatz starten. Alternativ kann es jedoch auch klare Gründe gegen ein Monorepo geben und eher für einen Multi-Repo-Ansatz sprechen. Betrachten wir zunächst näher, warum wir die Entscheidung für Monorepos treffen möchten und welche Konsequenzen sich daraus ergeben. Im zweiten Teil werden wir genauer beleuchten, wie eine Monorepo Strategie effektiv mit AWS CDK und dem Buildsystem Nx funktionieren kann.

Vorteile von Monorepos

Die zentrale Stärke eines Monorepos liegt in seiner Funktion als alleinige Quelle der Wahrheit. Hieraus ergeben sich diverse weitere Vorteile:

  1. Vereinfachtes Abhängigkeitsmanagement: Das Repository beherbergt die gesamte Codebasis und jede Komponente ist mit ihrer Hauptversion integriert, was das Abhängigkeitsmanagement erheblich vereinfacht. Dies macht den Einsatz von Artefakt-Repositories (z.B. CodeArtifact, Nexus) überflüssig.
  2. Vereinfachter Zugriff: Teams können mühelos zusammenarbeiten, da sie Einblick in das gesamte Repository haben.
  3. Groß angelegte Code-Refaktorisierung: Atomare Commits im gesamten Code erleichtern moduleübergreifende Refaktorisierungen und Implementierungen erheblich.
  4. Continuous Deployment Pipeline: Keine bzw. wenig neue Konfiguration erforderlich, um weitere Services hinzuzufügen.

Umgang mit möglichen Nachteilen von Monorepos

Natürlich gibt es auch Konsequenzen bei der Verwendung von Monorepos. Einige Nachteile können von vornherein aufgefangen werden, wenn bestimmte Voraussetzungen erfüllt sind. Dazu gehören idealerweise eine Einigung auf die verwendeten Technologien und die Wahl ähnlicher CI/CD-Prozesse über alle Services hinweg. Auch muss berücksichtigt werden, dass die Zugriffkontrolle i.d.R. nicht feingranular eingestellt werden kann und jeder Zugriff auf die gesamte Codebasis hat. Dies kann besonders wichtig werden, wenn mehrere Teams in einem Monorepo arbeiten. Andernfalls können viele der Vorteile von Monorepos schnell verloren gehen und ein Multi-Repo-Ansatz könnte besser geeignet sein.

Es gibt drei weitere Einschränkungen oder Gefahren, die berücksichtigt werden müssen:

Eingeschränkte Versionierung

Alle Service liegen immer in ihren jeweiligen aktuellen Versionen vor. Ein Service kann nicht einfach eine ältere Version eines anderen Services referenzieren. Bei der Konzeption von Microservices ist daher besonderes Augenmerk auf die Schnittstellenverträge der Services innerhalb des Monorepos zu legen. Diese sollten im Idealfall semantisch versioniert und dokumentiert werden. Etablierte Standards wie OpenAPI, GraphQL und JSON Schema unterstützen dies. Bei der Verwendung gemeinsamer Bibliotheken ist auf Abwärtskompatibilität zu achten, da Änderungen sonst Anpassungen in allen Modulen erfordern, die die Bibliothek verwenden.

Hohe Kopplung möglich

Die Vorteile eines Monorepos, nämlich die schnelle und effiziente Zusammenarbeit durch eine zentrale Codebasis, können sich schnell ins Gegenteil verkehren. Dies geschieht, wenn Services direkt auf Bausteine anderer Services referenzieren oder wenn die Wiederverwendbarkeit von Code falsch verstanden wird und dazu führt, dass die Geschäftslogik der Services in gemeinsame Bibliotheken ausgelagert wird. Dadurch entsteht schnell eine Architektur mit hoher Kopplung zwischen den einzelnen Bausteinen. Insbesondere unter Zeitdruck bei der Entwicklung neuer Features ist die Versuchung groß, technische Schulden einzugehen. Häufen sich diese, besteht die Gefahr, dass aus Angst vor Breaking Changes keine Refactorings mehr durchgeführt werden, was wiederum die Wartbarkeit des Gesamtsystems erheblich beeinträchtigt.

Es ist daher wichtig, klare Regeln zu definieren und sicherzustellen, dass die Einhaltung dieser Regeln idealerweise durch statische Codeanalysen überwacht und gemessen wird. Es ist anzustreben, dass die Services während der Build-Zeit keine Abhängigkeiten untereinander haben und stattdessen zur Laufzeit über klar definierte Schnittstellen miteinander kommunizieren. Die Schnittstellenverträge können effizient als Bibliotheken zentral im Monorepo abgelegt werden.

Monolithische, langwierige CI/CD-Prozesse

Wenn sich der gesamte Code in einem einzigen Repository befindet, müssen die CI/CD-Prozesse für automatisiertes Testen, statische Codeanalyse, Build und Deployment im schlimmsten Fall bei jeder Änderung den gesamten Code durchlaufen. Mit wachsender Projektgröße führen diese längeren Wartezeiten zu Frustration, was sich negativ auf die Teamleistung auswirken kann. In einer Microservices-Architektur sollte dies jedoch nicht der Fall sein, denn dies widerspricht dem Ziel, jeden Service individuell zu betrachten. Bei Codeänderungen in einem Service sollten nur die notwendigen CI/CD-Prozesse für diesen Service und seine abhängigen Bibliotheken durchgeführt werden. Die Entwicklung sollte so schnell und isoliert erfolgen, als würde man nur an der Codebasis eines Services in einem Repository arbeiten. Es gibt geeignete Werkzeuge wie Nx um dies in einem Monorepos zu realisieren.

Mehr dazu in Teil 2.

Skalierbare Webentwicklung mit Microfrontends

Um den Anforderungen in einem sich schnell entwickelnden Marktumfeld gerecht zu werden und die Erwartungshaltung verschiedener Nutzergruppen erfüllen zu können, steigt der Bedarf an der Umsetzung komplexer Business-Anwendungen mithilfe moderner Webtechnologien stetig.

Genau aus diesem Grund ist auch das Interesse an Microservices in den letzten Jahren stark gewachsen. Sie helfen dabei, komplexe Anwendungen in kleinere beherrschbare Komponenten zu zerlegen. Dies ermöglicht eine stärkere Separation und damit ein agileres Vorgehen.

Mehr Flexibilität durch Microservices für Web-Frontends

Während im Backend Microservices bereits seit Jahren zum Standardinventar gehören, um die Parallelisierung der Entwicklung durch mehrere Teams, Diversität in den eingesetzten Technologien und die flexible Verwendung von Anwendungsbestandteilen zu erlauben, verfolgen Web-Frontends oft noch einen monolithischen Ansatz.

Aufgrund der steigenden Anwendungskomplexität, dem Wunsch nach der Integration verschiedener Anwendungsfälle in eine einzelne Endnutzerapplikation und wegen des schnelllebigen Technologie-Stacks empfiehlt sich auch im Frontend eine ähnliche Herangehensweise wie im Backend.

Abbildung 1: Aufteilung des Frontends in unterschiedliche Domänen und Teams

Doch worin liegt der große Vorteil der sogenannten Microfrontends? Den meisten Projekten, in denen ein komplexes Frontend entwickelt wird, liegt auch ein komplexes Backend zugrunde, wodurch ein sehr heterogenes Projekt-Setup entsteht. Aus diesem Grund wird die Arbeit durch nur ein Entwicklungsteam immer schwieriger und oft auf verschiedene Teams aufgeteilt. Ein monolithischer Ansatz der Frontend-Entwicklung wirkt sich oft, aufgrund der technischen Komplexität und Abhängigkeiten, negativ auf die Wartbarkeit des Systems aus. Microfrontends erlauben nun auch in der Webentwicklung eine Parallelisierung und Diversität, die im Backend schon lange zum Standard gehört.

Der Ansatz zielt darauf ab, das Frontend in unterschiedliche Domänen zu trennen. So kann dieses auch durch verschiedene Teams und mit unterschiedlichen technologischen Ansätzen entwickelt werden. Bei Erweiterungen oder Änderungen muss nicht das gesamte Frontend neu deployt werden, sondern es können einzelne Teile ausgetauscht werden. Ziel ist es, dass der User das Gefühl von nur einer performanten Anwendung bekommt, auch wenn dieses technisch auf verschiedenen Systemen aufbaut.

Vortrag zum Online-Campus

In unserem Vortrag vom ersten Online-Campus der ZEISS Digital Innovation sprechen wir darüber, für wen sich der Monolith vielleicht immer noch lohnt und wer sich eine Architektur basierend auf Microfrontends vielleicht genauer anschauen sollte. Dabei gehen wir auf unterschiedlich komplexe Projekt-Setups und deren Vor- und Nachteile ein. Wir zeigen auch, welche Webtechnologien es gibt, welche die passende Technologie für das eigene Projekt ist und welche Möglichkeiten der Umsetzung es gibt.

In Sachsen, da geht was – JUG Saxony Day 2017

Ein Bericht vom JUG Saxony Day 2017

Am 29. September 2017 fand im Hotel Radisson Blu Radebeul der nunmehr 4. JUG Saxony Day statt. Über 500 Teilnehmer zählte die Konferenz dieses Jahr und konnte damit ein erneutes Wachstum verzeichnen. Trotz bisher stetig steigender Teilnehmerzahlen konnte dennoch eine familiäre Atmosphäre bewahrt werden. Mit welchen Erwartungen wurde die Konferenz gestartet und wie sollen diese weiterhin erfüllt werden? Diese und weitere spannende Fragen konnte ich in einem Gespräch mit den “Machern der Konferenz” – dem JUG Saxony (e.V.) – klären.

Gefüllter Vortragssaal beim JUG Saxony Day 2017
© JUG Saxony e.V. Quelle: hier.

Der Ursprung der Konferenz sind die regelmäßigen Veranstaltungen des JUG Saxony, die immer an wechselnden Orten stattfinden, um eine Vernetzung von Java-Entwicklern und an der Softwareentwicklung Interessierten zu ermöglichen. Die Treffen in Form der User-Group-Veranstaltungen mit Vorträgen zu Themen rund um Java und Softwareentwicklung stellen ein Angebot für jedermann dar, der an der Lösung von praktischen Problemen in der Softwareentwicklung interessiert ist. Zusätzlich zu den vielen Informatik-Studiengängen in Sachsen, die ein theoretisches und teilweise praktisches Fundament für die Ausbildung von Softwareentwicklern in Sachsen bilden, stellen die Veranstaltungen von User Groups wie dem JUG Saxony ein praktisches Ergänzungsangebot dar.

In Sachsen, da geht was!

Die Veranstaltungen des JUG Saxony kamen gut an und das Feedback aus der Community ergab, dass eine ganztägige Veranstaltung wohl zu einer noch stärkeren Beteiligung und einem noch effizienteren Weg der Wissensvermittlung führen würde. Schließlich wurde 2014 der erste JUG Saxony Day (JSD) an der TU Dresden organisiert. Um einen “Blick über den Tellerrand” zu werfen und sich in der Community auszutauschen, kamen nun Jahr für Jahr mehr Besucher. Es treffen sich Softwareentwickler und Unternehmen aus Sachsen und ganz Deutschland.

Im nun vierten Jahr merkt man, dass alles “wie am Schnürchen“ läuft. Das Radisson Blu als aktueller Veranstaltungsort, aber auch die Organisation der Speaker-Tracks und Themen tragen dabei sehr zur angenehmen Atmosphäre auf dem JSD bei. Ab acht Uhr morgens trifft man die ersten bekannten Gesichter beim JSD. Mal ist es ein ehemaliger Kommilitone aus Studienzeiten. Dann sind es Kollegen, die früher einmal mit in derselben Firma oder sogar im selben Projekt gearbeitet haben. Ein Plausch über den Stand der aktuellen Projekte und das anstehende Programm des JSD sind dann natürlich Pflicht.

Neun Uhr ging der Keynote-Vortrag los: Stefan Zörner gab einen Einblick in die Methoden und Werkzeuge von Architekten und beantwortete die Frage, wie Software-Architektur im Team umgesetzt wird. Thematisch waren viele der Vorträge beim JSD sehr gut einem Teilgebiet der Architektur zuzuordnen. Mit Architektur als Meta-Thema und einem sehr breiten Spektrum an Vorträgen war also für jeden etwas dabei. Zwischen den Vorträgen fand man immer wieder zueinander, um weiter zu diskutieren. Man hatte das Gefühl, das Ambiente führte die Wege der Teilnehmer automatisch zueinander.

Die Größe des JSD ist laut dem JUG Saxony jetzt genau richtig – und laut einer Umfrage des JUG Saxony ist es genau die bereits erwähnte familiäre Atmosphäre, die die Teilnehmer so begeistert und nun schon seit vier Jahren immer wieder anlockt. Statt weiterem Wachstum wird die Erhaltung der Qualität angestrebt. Für die Zukunft hofft man auf eine stärkere Unterstützung von Community getriebenen Veranstaltungen wie dem JSD durch Politik und kommunale Institutionen. Denn mit dieser Konferenz hat die Java Community in Form des JUG Saxony eine Veranstaltung geschaffen, die Leute aus ganz Deutschland und auch dem Ausland anzieht und zeigt, dass in Sachsen in Sachen Softwareentwicklung was geht. Dieses Wertes sollte sich jedermann und insbesondere das Land Sachsen bewusst sein.

Mich persönlich haben dieses Jahr Vorträge zu Themen wie Refactoring von monolithischen Systemen, Überblick zu den Architekturbestandteilen bei Microservice-Umgebungen und auch das Logging in solchen Umgebungen und die Überwachung der Systeme angezogen.

Nächstes Jahr stehen dann gleich zwei Jubiläen an, die es zu feiern gilt: Der JUG Saxony e.V. veranstaltet sein 100. User-Group-Treffen und der JUG Saxony Day feiert seinen 5. Geburtstag. Ich persönlich freue mich schon sehr auf den nächsten JUG Saxony Day und bin sicher, dass ich auch nächstes Jahr bekannte Gesichter treffe und mir neue spannende Themen aus der Praxis von Profis anhören darf.