As much architectural work as needed en de

Every software system has an architecture, but unfortunately many have a rather accidental one. The success of the project, the maintainability of the software and the acceptance by the project stakeholders and users suffer from this.

But explicit software architecture work does not have to be difficult. I show you how to better understand the technical requirements with minimal effort and how to derive the right solutions. And how you can document it transparently for all stakeholders and easily develop it further in the future.

Java 21 - the next LTS version en de

Every half year new major releases appear every two years as LTS with more extended support (Long Term Support). Many of us are still working with the earlier LTS version 8 or have only switched to 11. So we want to take a look at what has happened in the Java universe since then. These are such exciting topics as Pattern Matching, Virtual Threads as well as many smaller features. But many more features are in the works or planned, like the Vector API, the Foreign Function & Memory API, String Interpolation, or the Primitive or Value Types.

In addition to these various JDK Enhancement Proposals (JEPs), we will of course also take a look at helpful API improvements and changes to the JVM, e.g. the garbage collectors. You will get an overview of the latest developments in the Java environment and see today what you can expect in the next years in your daily work.

Java 21 - Die nächste LTS-Version en de

Alle halben Jahre erscheinen neue Major-Releases, alle zwei Jahre als LTS mit längerer Unterstützung (Long Term Support). Viele von uns arbeiten noch mit der früheren LTS-Version 8 oder sind bisher nur auf 11 umgestiegen. Wir wollen uns daher anschauen, was sich seitdem im Java-Universum getan hat. Das sind so spannende Themen wie Pattern Matching, Virtual Threads sowie viele kleinere Funktionen. Aber es sind noch viele weitere Features in Arbeit oder der Planung, wie die Vector API, die Foreign Function & Memory API, die String Interpolation oder die Primitive bzw. Value Types.

Neben diesen verschiedenen JDK Enhancement Proposals (JEPs) werfen wir natürlich auch einen Blick auf hilfreiche API-Verbesserungen und Änderungen an der JVM, z. B. bei den Garbage Collectoren. Ihr bekommt einen Überblick über die neusten Entwicklungen im Java-Umfeld und seht heute schon, was Euch in den nächsten Jahren in der täglichen Arbeit erwarten wird.

Java 20 - Auf dem Weg zur nächsten LTS-Version en de

Seit einigen Jahren kommen nun schon halbjährlich neue Java Major-Releases heraus. Dieses Vorgehen hat sich etabliert und funktioniert erstaunlich gut. Natürlich dürft Ihr nicht den Funktionsumfang von den früheren Versionen (9 und älter) erwarten. Dafür bekommt Ihr als Entwickler aber viel regelmäßiger die aktuellen Änderungen mit. In den Preview-Phasen kann sogar Feedback gegeben und somit die aktive Weiterentwicklung von Java mitgestaltet werden. Alle zwei Jahre erscheinen zudem Long-Term-Support-Versionen, die länger mit Updates und Patches versorgt werden. Im September 2023 steht mit Version 21 bereits das nächste LTS-Release an. Zeit, auf die letzten Änderungen zu schauen, u. a.:

* Pattern Matching und Record Patterns
* Virtual Threads, Structured Concurrency und Scoped Values
* Simple Web Server
* Vector API bzw. Foreign Function & Memory API
* und noch einiges mehr

Neben den JDK Enhancement Proposals (JEPs) werfen wir natürlich auch einen Blick auf hilfreiche API-Verbesserungen und Änderungen an der JVM, z. B. bei den Garbage Collectoren. Ihr bekommt einen Überblick über die neusten Entwicklungen im Java-Umfeld und seht heute schon, was Euch in den nächsten Jahren in der täglichen Arbeit erwarten wird.

Groovy 4 the win? en

Seit vielen Jahren ist Groovy eine der innovativsten Sprachen auf der Java Plattform. Sourcecode sowohl dynamisch als auch statisch typisieren zu können, ermöglicht sowohl eine ungeahnte Flexibilität, aber auch hohe Kompiler-Sicherheit, wo es angeraten ist. Die Laufzeit- als auch Compile-Time-Metaprogrammierung beschert so manchen Entwickler magische Momente. Groovy Code lässt sich zudem sehr einfach mit Java integrieren und ist trotz der Ähnlichkeit in der Syntax deutlich prägnanter, verständlicher, besser lesbar und somit auch wartbarer.

Aber Java hat aufgeholt und sich bei vielen Features von Groovy, Scala und Co. inspirieren lassen. Zudem gab es im Groovy-Umfeld politisch motivierte Rückschläge, dann den Wechsel zur Apache Software Foundation und mittlerweile dank Gradle und Co. schwindelerregend in die Höhe geschnellte Downloadzahlen. Nun steht mit Groovy 4 wieder ein Major-Update mit vielen interessanten Neuerungen in den Startlöchern.

In diesem Vortrag schauen wir, wo sich Java und Groovy angenähert haben, wo Groovy ggf. auch von neuen Strukturen und APIs auf der Java Plattform profitiert und wo die allseits beliebte Skriptsprache aber weiterhin den gewissen Unterschied ausmacht. Falls Ihr Groovy bereits verwendet, bekommt ihr einen kompakten Überblick über die neue Features. Und falls ihr es noch nicht nutzt, dann solltet ihr erst recht in diesem Vortrag dabei sein.

A S.O.L.I.D. software design en de

Our software systems are becoming more and more complex, and the demands on architecture and design are constantly increasing. Of course, the program structure should still be comprehensible and flexible, and it must also be possible to maintain the source code well and extend it easily. Sounds quite simple. Unfortunately, many software projects are far away from this and tend rather to the much quoted Big Ball of Mud.

Haven't the S.O.L.I.D. principles been around for a long time? But what did the "I." stand for again? And what was the Liskov substitution principle all about? Through frameworks we actually use many of the principles every day, but often don't know the background (anymore). Therefore, it is time to recall them again and to put their impact on the design and decision making of modern software architectures to the test. We will use examples to discuss the strengths, but also possible risks and trade-offs. And we will look at alternative patterns and principles. This way you can apply the ideas directly to your projects.

Docs-as-Code - Create documentation continuously and automatically en de

In contrast to the classic approaches (word processing, wiki, network drives, ...), Docs-as-Code pursues the goal of treating the documentation relevant in software projects exactly like the source code. Thus, there is no media break for the developing team members. They can use the same tools (text editor, IDE, build tools, CI/CD pipeline) to store the content as lightweight text formats alongside the source code in version management, review the changes together with the sources, mark them as a release and deliver them, and integrate the target group-oriented compilation of the results into the build process. To avoid redundancies, textual content and diagrams can be generated automatically from the existing project models (source code, DB model, UML model, ...).

Any kind of documentation thus gains visibility, and through the integration into the development processes and the associated continuous further development, the quality and thus the acceptance by the readers increases. Documentation can even be executed, for example to test embedded architecture rules regularly in an automated way. In this presentation, the audience will learn how to get started with Documentation as Code, which typical pitfalls they should avoid and which concrete tools should be known.

Pattern Matching in Java ... and why do we need algebraic data types? en de

Pattern matching is a mechanism to check values against patterns. If a match is found, these values can then be broken down into their constituent parts and thus easily and safely processed further. This concept, which is primarily known from functional programming languages, is thus a very powerful and flexible alternative to classic switch statements or if/else statement cascades. For several years now, the JDK incubator project Amber has been working on the introduction of pattern matching in Java. Some of the implementations have now found their way into the OpenJDK. They promise shorter and more comprehensible source code, which can also be checked for correctness by the compiler. It is easier to read and can therefore be easily maintained and extended.

Accompanied by code examples we will take a closer look at the actual state of pattern matching in Java. You will get to know the new features like Switch Expression, Type/Record Patterns, Sealed Classes as well as Pattern Matching for switch in more detail and learn where they can be usefully applied. Afterward, we will take a look at future alternative pattern types.

The architecture of the German Corona-Warn-App en de

A lighthouse project, a cost-cutting tool, a beacon of hope and an important building block in the fight against pandemics - the German Corona Warning App System (CWA for short) consists not only of the quite prominent native iOS and Android apps that you may also have installed on your smartphone. The implementation of important use cases such as personal risk assessment, reporting or notification of (positive) test results, or exchange with warning systems in other countries also includes a multi-part server solution. It is based on a contemporary architectural style and an up-to-date technology stack. And was realized under high time pressure in a lead role by SAP and Deutsche Telekom.

Public interest in this project is high, as is the transparency of the development process. The source code is open source and the documentation is also openly accessible. In this talk you will get to know the overall solution, especially the server-side part of the Corona warning app and its implementation. We will discuss the formative architectural requirements and the choices made. Finally, we will evaluate the chosen solution approaches and work out strengths, drawbacks and trade-offs.

Portfolio-as-Code - Homepage für ITler de

Auch wenn wir als ITler, egal ob angestellt oder freiberuflich, derzeit auf dem Arbeitsmarkt umworben werden, muss man uns erstmal finden. Neben der Präsenz auf diversen beruflichen Kontaktbörsen bietet sich natürlich das Erstellen einer eigenen Internetseite an, auf der die Projektliste, Side-Projekte, Blog-Posts, Artikel, Vorträge und der Lebenslauf präsentiert werden können. Aber nicht jeder möchte sich mit Design und Layout auseinandersetzen, sondern vielmehr auf den Inhalt konzentrieren. Zum Glück gibt es mittlerweile Werkzeuge, die auf uns Entwickler zugeschnitten sind und pragmatische, aber trotzdem ansehnliche Ergebnisse produzieren.

Aufbauend auf der gewohnten Arbeitsweise wird uns durch diese Tools mit frei verfügbaren Vorlagen nicht nur die mühevolle Gestaltung abgenommen. Getreu dem Motto "Everything-as-Code" unterstützen sie auch bei der Automatisierung des kompletten Entwicklungsprozesses bis zur Auslieferung und vor allem bei der kontinuierlichen Pflege der Webseite. Wir stellen anhand von Beispielen verschiedene Lösungen basierend auf Jekyll, Hugo und JBake, sowie Plattformen wie Github, Gitlab und Netlify vor, geben unsere Erfahrungen weiter und zeigen einige Tipps und Tricks, die sich für uns bewährt haben.

Die Architektur der Corona-Warn-App unter der Lupe en de

Leuchtturmprojekt, Kostengrab, Hoffnungsträger und wichtiger Baustein in der Pandemiebekämpfung — das deutsche Corona-Warn-App-System (kurz CWA), besteht nicht nur aus den recht prominenten nativen iOS- und Android-Apps, die Ihr vielleicht auch auf Eurem Smartphone installiert habt. Zur Umsetzung wichtiger Use Cases wie der persönlichen Risikoermitttlung, dem Melden bzw. der Benachrichtigung von (positiven) Testergebnissen oder dem Austausch mit Warn-Systemen anderer Länder, gehört auch eine vielteilige Server-Lösung. Sie basiert auf einem zeitgemäßen Architekturstil und einem aktuellen Technologie-Stack. Und wurde unter hohem Zeitdruck federführend von SAP und Deutscher Telekom realisiert.

Das öffentliche Interesse an diesem Projekt ist hoch, die Transparenz bei der Entwicklung erfreulicherweise ebenfalls. Der Quellcode ist Open Source und auch die Dokumentation ist offen zugänglich. In diesem Vortrag lernt Ihr die Gesamtlösung, vor allem den serverseitigen Teil der Corona-Warn-App und seine Implementierung, kennen. Wir diskutieren die prägenden architekturrelevanten Anforderungen und die getroffenen Entscheidungen. Zum Abschluss bewerten wir die gewählten Lösungsansätze und arbeiten Stärken, Hindernisse und Kompromisse heraus.

Moderne Softwarearchitekturen dokumentieren und kommunizieren de

Unsere Software-Projekte werden immer größer und komplexer. Technologisch hat sich in den vergangenen Jahren eine Menge getan, um diese Komplexität in den Griff zu bekommen. Aber noch viel wichtiger ist die Kommunikation zwischen allen Projektbeteiligten geworden. Als Voraussetzung braucht es dafür eine möglichst aktuelle, pragmatische und zielführende Dokumentation der Softwarearchitektur. Aber leider hat das Dokumentieren häufig einen niedrigen Stellenwert in unseren Projekten. Zum Teil fehlt die Motivation bei den Verantwortlichen. Oder suboptimale Werkzeuge wie Textverarbeitung, schwergewichtige UML-Tools bzw. Wikis ersticken alle Bemühungen im Keim.

Wir wollen den Bann brechen und an konkreten Beispielen zeigen, wie Dokumentieren nicht nur Spaß machen, sondern auch leicht von der Hand gehen kann. Dazu berichten wir aus unseren Erfahrungen und rücken leichtgewichtige Tools und schlanke Text- bzw. Grafikformate in den Fokus. Sie erleichtern die automatisierte Erstellung einer effektiven, allumfänglichen und vor allem redundanzfreien Dokumentation, die sich mit wenig Aufwand für die unterschiedlichen Zielgruppen optimiert in verschiedenen Formaten ausliefern lässt. Das Einbetten dieser Documentation as Code in die Entwicklungs- und Reviewprozesse ermöglicht zudem eine gute Nachvollziehbarkeit und die kontinuierliche Verbesserung und Weiterentwicklung.

Moderne Softwarearchitekturdokumentation de

Architekturdokumentation wird sehr oft stiefmütterlich behandelt. Dabei unterstützt das Dokumentieren bei der Entwurfsarbeit, schafft Transparenz bzw. Leitplanken für die Umsetzung und Wartung der Softwarearchitektur. Einerseits ist es aber nicht einfach, die wichtigen Informationen aus dem Entwurf der Softwarearchitektur strukturiert und leicht verständlich festzuhalten. Andererseits enden die meisten Versuche auf der Suche nach einer praktikablen Handhabung zur Erstellung und Pflege in der WYSIWYG-Hölle einer Textverarbeitung oder im tiefen Schlund eines Wikis. Dieses Seminar zeigt aufbauend auf leichtgewichtigen Tools und Textformaten die Erstellung einer möglichst redundanzfreien Dokumentation, die für verschiedene Zielgruppen optimiert in ansprechenden Formaten ausgeliefert werden kann.

Anhand von vielen praktischen Übungen geht es um Begriffe wie Continuous Documentation und Documentation as Code. Das Ziel ist die moderne, effektive und pragmatische Dokumentation der Softwarearchitektur. Wir bauen auf bewährte Methoden, Formate und Tools wie AsciiDoc/Markdown, PlantUML, docToolchain, Maven/Gradle, jqAssistant und viele weitere. Im Detail kümmern wir uns um die Automatisierung des Dokumentations-Build-Prozesses, das Generieren von Inhalten aus dem Modell, Datenbankschema oder Sourcecode, die strukturierte Ablage inklusive Versionier- und Historisierbarkeit und die Verwendung bzw. Erstellung von aussagekräftigen und einfach wartbaren Grafiken.

Agile Entwicklungsteams können so die Dokumentationsarbeit in ihre täglichen Aufgaben integrieren und jederzeit aktuelle, umfassende und gut strukturierte Ergebnisse ausliefern. Zudem lässt sich die Erstellung der Dokumentation in den Reviewprozess integrieren und so stetig verbessern und weiterentwickeln.

Pattern Matching in Java ... und warum es dafür algebraische Datentypen braucht en de

Pattern Matching ist ein Mechanismus, um Werte gegen Muster abzuprüfen. Bei einem Treffer können diese Werte dann in ihre Bestandteile zerlegt und somit leicht und sicher weiterverarbeitet werden. Dieses in erster Linie aus funktionalen Programmiersprachen bekannte Konzept ist damit eine sehr mächtige und flexible Alternative zu klassischen Switch Statements bzw. if/else-Anweisungskaskaden. Seit einigen Jahren wird nun schon im JDK-Inkubatorprojekt Amber an der Einführung von Pattern Matching in Java gearbeitet. Ein Teil der Implementierungen haben mittlerweile den Weg in das OpenJDK gefunden. Sie versprechen kürzeren und verständlicheren Quellcode, der zudem vom Compiler auf Korrektheit geprüft werden kann. Er ist einfacher zu lesen und lässt sich somit leicht warten und erweitern.

Begleitet von Codebeispielen werden wir den Ist-Zustand des Musterabgleichs in Java näher beleuchten. Ihr lernt die neuen Features wie Switch Expression, Type/Record Patterns, Sealed Classes sowie Pattern Matching for switch näher kennen und erfahrt, wo sie sinnvoll eingesetzt werden können. Anschließend werfen wir einen Blick auf zukünftige, alternative Pattern-Typen.

Der S.O.L.I.D.e Softwareentwurf en de

Unsere Software-Systeme werden immer komplexer, die Anforderungen an die Architektur und das Design steigen unaufhörlich. Die Programmstruktur soll natürlich weiterhin verständlich und flexibel sein, zudem muss man den Sourcecode gut warten und leicht erweitern können. Klingt ja eigentlich ganz einfach. Leider sind viele Software-Projekte davon aber weit entfernt und tendieren eher zur viel zitierten Big Ball of Mud.

Gibt es zur Rettung da nicht schon lange die S.O.L.I.D. Prinzipien? Aber für was stand gleich nochmal das "I."? Und um was ging es eigentlich beim Liskov'schen Substitutionsprinzip? Durch Frameworks wenden wir tatsächlich viele der Prinzipien tagtäglich an, kennen aber häufig die Hintergründe nicht (mehr). Darum wird es Zeit, sie mal wieder in Erinnerung zu rufen und ihre Auswirkungen auf den Entwurf und die Entscheidungsfindung bei modernen Softwarearchitekturen auf den Prüfstand zu stellen. Wir wollen dabei anhand von Beispielen die Stärken, aber auch mögliche Risiken und Kompromisse diskutieren. Und wir werden uns alternative Muster und Prinzipien anschauen. So könnt Ihr die Ideen direkt auf Eure Projekte übertragen.

Domain Driven Design für Dummies de

Auch wenn das gleichnamige Buch von Eric Evans bereits 2003 erschienen ist, so ist Domain Driven Design gerade wieder hoch aktuell und nicht zuletzt durch den Trend zu Microservices Architekturen immer noch sehr relevant. Ziel von DDD ist die möglichst realitätsnahe Abbildung der Fachlichkeit und des Domainwissens in der Software. Das Entwickeln einer gemeinsamen domänengetriebenen Fachsprache hilft bei der Überbrückung von Kommunikationsproblemen zwischen den Fachanwendern und den Softwareentwicklern.

In diesem Vortrag wollen wir einen Blick auf die Konzepte und Muster wie Context Mapping, Bounded Contexts, Domain Events und die internen Building Blocks wie Aggregate, Entities, Value Objects, Repositories usw. werfen. Das Ziel ist die Erstellung einer qualitativ hochwertigen Software mit einer einheitlichen und ausdrucksstarken Architektur.

Stichwörter:
DDD, Bounded Context, Strategic Design, Tactical Design

Lernziele:
DDD kennenlernen
Muster und Best Practices von DDD einordnen können
Vorteile eines Software Entwurfs nach DDD erkennen

Funktionale Programmierung geht auch mit/trotz Java! de

Java ist keine funktionale Sprache, aber dank Streams und Lambdas kann man nun seit einiger Zeit auf funktionale Art und Weise programmieren. Reicht das, um ausdrucksstärkeren und besser lesbaren Sourcecode zu entwickeln? Passt dieses Programmierparadigma überhaupt zur imperativen Denkweise von uns Java-Entwicklern?

Anhand eines Real-World-Szenarios machen wir uns mit den fehlenden Puzzlestücken vertraut. Dabei geht es um Begriffe wie Value Types, Pattern Matching, Monaden (Try, Either, Optional, Validierung), Bedarfsauswertung, partielle Funktionsaufrufe, Currying, Funktionskomposition, persistente Datenstrukturen, Seiteneffektfreiheit und einige mehr. Wir diskutieren Lösungsansätze in Java und werfen vor allem einen Blick auf zusätzliche Bibliotheken wie Immutables und Vavr.

Stichwörter: Funktionale Programmierung, Vavr, Immutables

Vorkenntnisse:
Solide Kenntnisse in Java

Lernziele:
Konzepte der funktionalen Programmierung verstehen.

Bemerkungen:
Ich möchte mit diesem Vortrag Zuhörer ansprechen, die sich bisher nicht an die funktionale Programmierung herangetraut haben und sie mit praktischen und realistischen Code-Beispielen in die Materie einführen.

Ich möchte auch mal einen Vortrag halten - Wo fange ich bloß an? de

Vor einer Gruppe von Menschen einen Vortrag zu halten, ist für viele von uns eine große Hürde. Mit der richtigen Vorbereitung und etwas Übung muss das aber gar kein Problem sein und ist gerade für den beruflichen Alltag sehr nützlich. Und auch wenn es paradox klingt, bieten User Groups und Konferenzen die besten Voraussetzungen, sich mal vor Publikum auszuprobieren. Aber wie findet man ein spannendes Thema, wie schreibt man einen interessanten Abstract, wie sieht die Vorbereitung aus, wenn man angenommen wurde und was sind die besten Tricks, um auf der Bühne eine gute Figur zu machen? Ich möchte Euch von meinen Erfahrungen als Sprecher und auch Konferenz- und User Group Organisator berichten und bin mir sicher, einige zu animieren. "Nachbetreuung" ist übrigens kostenfrei und inklusive.

Anmerkungen Programmkomitee:

Ich habe den Vortrag in Berlin (Bedcon) als Kurzvortrag gehalten. Ich kann ihn auch auf 45 Minuten skalieren, wenn gewünscht. Ziel dieses Vortrages ist, frische Talente zu suchen, die auch mal einen Vortrag halten möchten. Ich organisiere bei der JavaLand das Newcomer-Programm und wir unterstützen über die JUG Darmstadt speziell Newcomer aus dem Rhein-Main-Gebiet und organisieren die SpeakerUnkonf (Speakonf) in Darmstadt.

Stichwörter: Vortragen, Themenfindung, Abstract, Präsentation

Vorkenntnisse:
Lust daran, selbst mal einen Vortrag zu halten
Präsentieren von Themen als Chance sehen, selbst voranzukommen und zu lernen

Lernziele:
Thema finden
Plattformen beobachten
Abstract schreiben
Mentoring
Vortrag vorbereiten
Vortrag halten
Feedback einholen

Legacy Code im Griff dank Mikado Methode de

Viele von uns haben tagtäglich mit Legacy Code zu tun. Mal eben schnell etwas umzubauen scheitert typischerweise an den fehlenden Tests. Fehlende Tests lassen sich aber aufgrund des oft nur schwer testbaren Quellcodes nicht so einfach hinzufügen.

In diesem Vortrag wird anhand von praktischen Code-Beispielen gezeigt, wie man zunächst ein automatisiertes Sicherheitsnetz aufspannt und anschließend komplexere Refactorings durchführt, ohne etliche Baustellen gleichzeitig aufzureißen. Die Mikado-Methode hilft dabei, den Überblick zu behalten und in möglichst kleinen und nachvollziehbaren Schritten vorzugehen. Als Ziel steht das Aufbrechen stark gekoppelter Abhängigkeiten, um gut les-, wart-, test- und wiedervendbaren Code zu erhalten.

Anmerkungen Programmkomitee

Vorkenntnisse:
Die Besucher sollten Erfahrung mit Legacy Code aus lang andauernden Projekten haben. Die Beispiele des Live-Codings sind in Java, können aber auch leicht auf andere objektorientierte Sprachen übertragen werden.

Lernziele
Den Zuhörern wird gezeigt, wie Legacy-Code mit einfachen Mitteln, aber trotzden sicher und mit möglichst wenig Nebeneffekten refactored werden kann.

Legacy Code meistern in x einfachen Schritten de

In einer idealen Welt würden wir nur "neuen" Code schreiben, der natürlich perfekt und wunderschön ist. Wir müßten nie wieder unseren Code anschauen geschweige denn 10 Jahre alte Projekte warten. Ende des Tagtraums ...

Leider ist unsere Welt nicht so ideal, unser Code von gestern ist heute schon Legacy. Diesen im Nachhinein zu verstehen, zu erweitern oder darin Fehler zu beheben ist immer eine Herausforderung, insbesondere wenn Tests fehlen. Trotzdem gibt es einfache Möglichkeiten, wie man die Qualität von Legacy Code verbessern kann. Das Wichtigste ist das Einziehen von Fangnetzen, so daß man trotz fehlender Tests guten Gewissens Änderungen durchführen kann. Wer Golden Master, Subclass to Test und Extract Pure Functions an konkreten Beispielen kennenlernen möchte, ist in dieser Session genau richtig.

Zusatz Programmkomitee:

Während eines Live-Codings werde ich an einem kleinen, realen Beispiel verschiedene Schritte/Refactorings durchführen. Die Teilnehmer sollen dabei sehen, dass man mit kleinem Aufwand bereits eine Menge erreichen kann. Meine Schritte lehnen sich an die Elemente eines Legacy Code Retreats an. Das Live-Coding führe ich in Java durch, die Idee ist aber auch auf andere objektorientierte (imperative) Programmiersprachen übertragbar.

Lessons learned:

Aufspannen eines Sicherheitsnetz bei fehlenden Tests
Einfache Schritte, wie man Legacy Code in Schuß hält

Tags: Legacy Code, Refactoring, Golden Master, Testen

Micronaut – effiziente und performante Microservices für die Cloud de

Den Chancen, die der Microservices-Ansatz bietet, stehen auch einige Herausforderungen gegenüber, die man aber gut mit Frameworks handhaben kann. Mit Micronaut hat nun ein ganz neuer Vertreter die Bühne mit dem Versprechen betreten, modulare, leicht testbare und sehr performante Anwendungen in Java, Kotlin oder Groovy entwickeln zu können.

Auch wenn Micronaut dem Platzhirsch aus dem Spring-Ökosystem ähnlich sieht, wurde es von Grund auf explizit für die Erstellung von Microservices im Cloud-Computing-Umfeld erstellt. Dank extrem kurzer Startzeiten, einem enorm niedrigen Speicherverbrauch und sehr kleinen JAR-Größen wird es die Microservices-Welt umkrempeln.

Ermöglicht wird das neuartige Programmiermodell mittels Compile-Zeit-Metaprogrammierung, wodurch die Metadaten für beispielsweise Dependency Injection und die aspektorientierte Programmierung bereits beim Kompilieren erzeugt werden. Reflection, Proxy Generierung und Data Caching zur Laufzeit entfallen dadurch. Zur Verwendung in der Cloud oder Serverless-Umgebungen gibt es zudem bereits zahlreiche fertig gestellte oder geplante Anbindungen an Service-Discovery-Dienste, Configuration Sharing, Load Balancing und Serverless Computing.

Im Rahmen dieser Session wollen wir uns die Funktionsweise näher anschauen und anhand von Codebeispielen und Performancemessungen auf den Prüfstand stellen.

Mit der Zeit gehen – Flexible Architekturen de

In der agilen Software-Entwicklung gibt es die Rolle des Architekten eigentlich nicht mehr. Paradoxerweise sind die Herausforderungen an den Entwurf moderner Software-Systeme höher als früher. Um die Digitalisierung voranzutreiben, sich von den Mitbewerbern abzuheben, sich möglichst auch einen Wettbewerbsvorteil zu erarbeiten und die sowohl technische als auch organisatorische Skalierbarkeit sicherzustellen, sind zu den altbekannten ganz neue Fragestellungen hinzugekommen:

* Laufzeit-Monolith oder irgendwas Entkoppeltes?
* DevOps oder klassischer Betrieb?
* Serverless/Cloud oder On-Premises?
* Relationale Datenhaltung oder NoSQL bzw. sogar In-Memory?
* Langlebigkeit oder Wegwerfbarkeit?

Je nach eingesetzten Architektur-Stilen und -Mustern kommen heutzutage ganz neue Herausforderungen auf Euch zu. Wir diskutieren in diesem Vortrag, wie agile Teams eine flexible und vor allem auch robuste Software-Architektur entwerfen, sie festhalten, kommunizieren und pflegen können. Und das auch, wenn von der grünen Wiese nach ein paar Monaten nicht mehr viel zu sehen ist.

Stichwörter: Softwarearchitektur, Monolith, Microservices, DevOps, Betrieb, Serverless, Cloud, NoSQL

Vorkenntnisse:
Entwickler mit grundlegenden Kenntnissen zu Softwarearchitektur
Erfahrene Softwarearchitekten

Lernziele:
Laufzeit-Monolith oder irgendwas Entkoppeltes?
DevOps oder klassischer Betrieb?
Serverless/Cloud oder On-Premises?
Relationale Datenhaltung oder NoSQL bzw. sogar In-Memory?
Langlebigkeit oder Wegwerfbarkeit?

Lebendige Architektur-Dokumentation - kontinuierlich und effizient de

Man kann zwar an vielen Stellen nachlesen, wie man Architekturdokumentation strukturiert. Aber auf der Suche nach einer praktikablen Handhabung zur Erstellung und Pflege enden die meisten Versuche in der WYSIWYG-Hölle einer Textverarbeitung oder im tiefen Schlund eines Wikis. In diesem Vortrag wollen wir uns anschauen, wie aufbauend auf bestehenden Tools und Textformaten eine möglichst redundanzfreie Dokumentation erstellt und für verschiedene Zielgruppen in ansprechenden Formaten ausgeliefert werden kann. Es wird dabei um Begriffe wie Continuous Documentation und Documentation as Code gehen.

Anmerkung fürs Programmkomitee:

Mir geht es darum, Entwickler durch diesen Vortrag wieder für das Dokumentieren zu begeistern, in dem ich Tools und Vorgehensweisen vorstelle, die das Schreiben von Dokumentation effizienter machen. Technische (Architektur-) Dokumentieren wird gern vernachlässigt. Ich möchte moderne Methoden und Werkzeuge vorstellen, die das Dokumentieren in den Entwicklungsalltag integriert und so zu vollständigerer und besser wartbaren Dokumentation führt.

Alternative Titel:
* Kontinuierliche Architekturdokumentation im agilen Umfeld
* Softwarearchitektur kontinuierlich und effizient dokumentieren
* Lebendige Architektur-Dokumentation - kontinuierlich und effizient
* Die 7 Sünden der Architekturdokumentation aus Entwicklersicht
* How-to Docs-as-Code for the busy Java developer

Lessons learned:

Wie man schlank und doch effizient dokumentiert
Wie man Dokumentatieren in den Entwicklungsprozess integriert
Wie man Dokumentaiton aktuell hält und regelmässig validiert

Keywords: Documentation as Code, Continuous Documentation, AsciiDoc, PlantUML, jQAssistant, Continuous Integration

Funktionale Programmierung mit Java de en

Funktionale Programmierung ist im Moment in aller Munde. Seit Version 8 und Lambdas/Streams stehen auch Java-Anwendern diverse Werkzeuge zur Verfügung. Daher wird es Zeit, sich mit den grundlegenden Konzepten der funktionalen Programmierung auseinanderzusetzen.

Nach diesem Vortrag wirst Du verstehen, was eine pure Funktion ist und warum referentielle Transparenz bzw. Seiteneffektfreiheit wichtige Konzepte sind. Wir schauen zudem auf Value Types und wie funktionale Datenstrukturen aufgebaut sind und wie man dank Bedarfsauswertung auch mit sehr großen Datenmengen effizient umgehen kann. Weiterhin besprechen wir die Elemente der Wiederverwendung wie Funktionskomposition, Currying, partielle Funktionsaufrufe und Funktionen höherer Ordnung. Abschließend werfen wir noch ein Blick auf die Destrukturierung von Datenstrukturen mittels Pattern Matching, das Kapseln von Seiteneffekten und wie man in seiner Softwarearchitektur einen funktionalen Kern umsetzt.

Stichwörter: Funktionale Programmierung, Vavr, Immutables

Vorkenntnisse:
Solide Kenntnisse in Java

Lernziele:
Konzepte der funktionalen Programmierung verstehen.

Bemerkungen:
Ich möchte mit diesem Vortrag Zuhörer ansprechen, die sich bisher nicht an die funktionale Programmierung herangetraut haben und sie mit praktischen und realistischen Code-Beispielen in die Materie einführen.

http://www.sippsack.de/files/talks/Falk-Sippach-Introduction-to-functional-programming-with-Java.pdf

JVM Functional Language Battle de

Funktionale Programmierung soll so viel ausdrucksstärker sein, aber leider ist dieses Programmier-Paradigma nicht ganz kompatibel zu der prozedural- und objektorientierten Denkweise von uns Java-Entwicklern. Anhand eines kleinen Algorithmus werden wir uns verschiedene Lösungen zunächst im klassischem imperativen Java (vor Java 8) und als Vergleich dazu in alternativen JVM-Sprachen (Groovy, JavaScript, Scala und Frege/Haskell) anschauen und die verschiedenen Lösungen diskutieren. Herauskommen soll eine saubere und verständlichere Struktur, die zu besser les- und wartbarem Code führen wird.

Die gewonnenen Erkenntnisse wollen wir dann letztendlich in Java 8 mittels Streams und Lambda-Ausdrücken umsetzen, so dass jeder Zuhörer die Grundideen der funktionalen Programmierung mit in seine tägliche Arbeit nehmen kann. Es sind keine speziellen Vorkenntnisse in den angesprochenen alternativen Sprachen notwendig, ein solides Verständnis für die Programmiersprache Java genügt.

Zusatz fürs Programmkomitee:

Anhand des Luhn-Algorithmus zeige ich verschiedene Implementierungen in den genannten JVM-Sprachen. Ziel ist es zu zeigen, wie schlecht les- und wartbar die klassische Java-Variante ist und wie alternative (funktionale) JVM-Sprachen das Problem eleganter lösen. Die gewonnenen Erkenntnisse sollen die Zuhörer als Key-Facts der funktionalen Programmierung mitnehmen und zum Abschluss schauen wir uns eine Umsetzung in Java 8 an, die allerdings noch auf funktionale Zusatzbibliotheken angewiesen ist.

PWA: Portable Webanwendungen statt nativer Apps de

Mobile First war gestern, Offline First heißt die neue Devise. Mit diesem Credo kommen Progressive Web Apps (PWA) nicht nur sehr nahe an native Smartphone Applikationen heran, sie erhöhen vor allem die User Experience bei fehlender oder sehr schlechter Internetverbindung und müssen nicht mehr über App Stores ausgeliefert werden. Allerdings muss zunächst bei den Nutzern die Akzeptanz für diese Art von Anwendungen geschaffen werden.

Anhand einer Beispielapplikation werden wir die Grundkonzepte wie Service Worker, Application Shell, Caching und Push Notifications diskutieren und einen Ausblick auf die mobilen Anwendungen der Zukunft und die aktuelle Unterstützung bei den Browsern werfen.

Stichwörter: PWA, Service Worker, App Shell, Notifications, Caching, Offline First

Vorkenntnisse:
Grundlegende Kenntnisse in JavaScript und Webentwicklung.

Lernziele:
Kennenlernen der Webanwendungen der Zukunft Funktionsweise verstehen Akzeptanz bei den Nutzern schaffen

Learning by teaching, speaking and blogging de

... und wie man als netten Nebeneffekt die Kunden dazu bringt, einfach selbst anzurufen.

Die stetige Weiterbildung sollte zu den Kernaufgaben aller technischen Mitarbeiter einer IT-Firma gehören. Das Ziel ist dabei nicht nur, den Kollegen die Möglichkeit des Wissensaufbaus und -austauschs zu ermöglichen. Vielmehr schafft man es mit den Ergebnissen in Form von Artikeln, Blog-Posts, Vorträgen und Schulungen sich gegenüber bestehenden und vor allem auch potentiellen neuen Kunden gut zu präsentieren. Zudem zeigt es, dass man sich mit modernen Technologien und Konzepten beschäftigt und zum Beispiel im Falle eines IT-Dienstleisters einen erheblichen Mehrwert für Kunden schaffen kann.

Leider hat man nur begrenzte Ressourcen und sollte sich deshalb auf Kernthemen fokussieren. Darum muss man sich inhaltlich in Form von Leitplanken Grenzen setzen. Zudem braucht es Messinstrumente, um die Weiterbildungsmaßnahmen zu koordinieren und den Kollegen gegenüber den Verpflichtungen im Projekt den Rücken freizuhalten bzw. die Ergebnisse einsammeln zu können. Dazu gehört auch eine enge Zusammenarbeit mit Marketing, Vertrieb und der Disposition.

Diese Ideen wurden über 20 Jahre sehr erfolgreich bei der ehemaligen Orientation in Objects GmbH umgesetzt. Ich war dort angestellt und möchte über die Vorgehensweisen berichten.

Java 20 - Auf dem Weg zur nächsten LTS-Version en de

Seit einigen Jahren kommen nun schon halbjährlich neue Java Major-Releases heraus. Dieses Vorgehen hat sich etabliert und funktioniert erstaunlich gut. Natürlich dürft Ihr nicht den Funktionsumfang von den früheren Versionen (9 und älter) erwarten. Dafür bekommt Ihr als Entwickler aber viel regelmäßiger die aktuellen Änderungen mit. In den Preview-Phasen kann sogar Feedback gegeben und somit die aktive Weiterentwicklung von Java mitgestaltet werden. Alle zwei Jahre erscheinen zudem Long-Term-Support-Versionen, die länger mit Updates und Patches versorgt werden. Im September 2023 steht mit Version 21 bereits das nächste LTS-Release an. Zeit, auf die letzten Änderungen zu schauen, u. a.:

* Pattern Matching und Record Patterns
* Virtual Threads, Structured Concurrency und Scoped Values
* Simple Web Server
* Vector API bzw. Foreign Function & Memory API
* und noch einiges mehr

Neben den JDK Enhancement Proposals (JEPs) werfen wir natürlich auch einen Blick auf hilfreiche API-Verbesserungen und Änderungen an der JVM, z. B. bei den Garbage Collectoren. Ihr bekommt einen Überblick über die neusten Entwicklungen im Java-Umfeld und seht heute schon, was Euch in den nächsten Jahren in der täglichen Arbeit erwarten wird.

So viel Architekturarbeit wie nötig en de

Jedes Software-System hat eine Architektur, nur leider haben viele eher eine zufällige. Darunter leidet der Erfolg des Projekts, die Wartbarkeit der Software und die Akzeptanz bei den Projektbeteiligten und Benutzern.

Dabei muss explizite Softwarearchitekturarbeit nicht schwer sein. Ich zeige Euch, wie ihr mit minimalen Aufwand nicht nur die technischen Anforderungen besser versteht, daraus gezielt die richtigen Lösungsansätze ableitet. Und das Ganze für alle Stakeholder transparent festhaltet, sowie zukünftig leicht weiterentwickeln könnt.

Hibernate ORM 6 - Next Generation of Java Persistence de

Wir bauen heute immer mehr verteilte Softwaresysteme, zum Beispiel mit Microservices, betreiben unsere Software in der Cloud und nutzen polyglotte Persistenzansätze unter anderem mit NoSQL. Aber in der breiten Masse kommen natürlich auch weiterhin relationale Datenbankmanagementsysteme zum Einsatz. Und aufgrund der objektrelationalen Kluft setzen wir in vielen Java Enterprise Projekten immer noch auf OR-Mapping Standards wie die Java/Jakarta Persistence API (JPA) und die entsprechenden Implementierungen wie Hibernate ORM. Gemeinsam mit Spring war Hibernate vor über 15 Jahren auch die treibende Kraft bei der Modernisierung des Java Enterprise Standards (von J2EE über Java EE bis hin zum heutigen Jakarta EE).

Mittlerweile ist nach über 6 Jahren die nächste Major-Version von Hibernate ORM herausgekommen. Im Rahmen dieses Vortrags wollen wir schauen, was sich geändert hat und welche der neuen Features in der Zukunft besonders interessant werden können. Dabei werfen wir einen Blick auf die Performance-Verbesserungen beim Lesen der Daten, das darunterliegende neue Mapping-Modell, das Redesign der Annotations im Hinblick auf Typsicherheit und die Änderungen bei der Query API sowohl in HQL als auch der Criteria API. In diesem Vortrag zeigen wir, dass Hibernate auch nach über 20 Jahren noch immer relevant ist. Ihr lernt, wie man in der heutigen Zeit Persistenz modern, effizient und performant umsetzt.

Docs-as-Code - Dokumentation kontinuierlich und automatisiert erstellen en de

Im Gegensatz zu den klassischen Ansätzen (Textverarbeitung, Wiki, Netzlaufwerke, ...) verfolgt Docs-as-Code das Ziel, die in Softwareprojekten relevante Dokumentation genau wie den Quelltext zu behandeln. Für die entwickelnden Team-Mitglieder entsteht somit kein Medienbruch. Sie können die gleichen Werkzeuge (Texteditor, IDE, Build-Tools, CI/CD-Pipeline) verwenden, um die Inhalte als leichtgewichtige Textformate neben dem Sourcecode in der Versionsverwaltung abzulegen, die Änderungen gemeinsam mit dem Quellen zu reviewen, als Release zu markieren und auszuliefern sowie die zielgruppenorientierte Zusammenstellung der Ergebnisse in den Build-Prozess einzubinden. Um Redundanzen zu vermeiden, können aus den vorhandenen Projektmodellen (Sourcecode, DB-, UML-Modell, ...) automatisiert textuelle Inhalte und Diagramme generiert werden.

Jedwede Art von Dokumentation gewinnt somit an Sichtbarkeit, durch die Eingliederung in die Entwicklungsprozesse und die damit verbundene kontinuierliche Weiterentwicklung steigt die Qualität und damit die Akzeptanz bei den Lesern. Dokumentation kann sogar ausgeführt werden, um zum Beispiel eingebettete Architekturregeln regelmässig automatisiert zu testen. Die Zuhörer erfahren in diesem Vortrag, wie sie mit Documentation as Code starten können, welche typischen Fallstricke sie umschiffen sollten und welche konkreten Tools bekannt sein sollten.

Writing really good tests - the best practices for better (JUnit) tests en de

Writing tests that can be automated is now accepted and helps us to develop high-quality software. However, tests and their architecture must be created with the same care and according to the same rules of clean code as the design of the production code. Test code can also rot. Poorly chosen names, redundancies, and high coupling of test code to implementation details lead to large maintenance efforts and, in the worst case, to the temporary, i.e. usually permanent, deactivation of tests.

This talk will first discuss which advanced onboard tools JUnit 5 already provides for writing well-maintainable tests. Furthermore, we will show you how to make your validation logic more independent from implementation details by writing your own assertion matchers. This will teach you how to make your (test) code more maintainable and robust against refactorings so that even simple modifications do not lead to large-scale adaptations of the test code.

Richtig gute Tests schreiben - die Best Practices für bessere (JUnit-) Tests en de

Das Schreiben von automatisierbaren Tests ist mittlerweile akzeptiert und hilft uns, qualitativ hochwertige Software zu entwickeln. Allerdings müssen Tests und deren Architektur mit der gleichen Sorgfalt und nach den gleichen Regeln von Clean Code entstehen, wie das Design des Produktivcodes. Auch Testcode kann verrotten. Schlecht gewählte Namen, Redundanzen und hohe Kopplung des Testcodes an Implementierungsdetails führen zu großen Wartungsaufwänden und im schlimmsten Fall zur temporären, also meist doch dauerhaften Deaktivierung von Tests.

In diesem Vortrag besprechen wir zunächst, welche fortgeschrittenen Bordmittel JUnit 5 bereits für das Schreiben gut wartbarer Tests mit sich bringt. Darüber hinaus zeigen wir Euch, wie ihr durch das Schreiben eigener Assertion-Matcher eure Validierungslogik von Implementierungsdetails unabhängiger macht. Dadurch lernt ihr, wie euer (Test-)Code wartbarer und robuster gegenüber Refactorings ist, damit nicht schon einfache Umbauarbeiten zu großflächigen Anpassungen am Testcode führen.

Data Oriented Programming in Java en de

In Object Oriented Programming (OOP), we model complex entities and processes using objects that combine state and behavior. OOP works best when we need to define and defend clear boundaries. However, for some use cases, this approach is overkill.

In data-oriented programming, we model (immutable) data separately from business logic. The Switch Expression, Sealed Classes, Records, and Pattern Matching features introduced in the Amber project help us to implement this approach in Java. Especially smaller, simple programs benefit additionally from Java's static type system.

The techniques of object-oriented and data-oriented programming do not contradict each other, they are different tools for different granularities and situations. In this talk I will show how data-oriented programming looks like we can combine the two paradigms.

Datenorientierte Programmierung mit Java en de

In der Objektorientierten Programmierung (OOP) modellieren wir komplexe Einheiten und Prozesse mit Hilfe von Objekten, die Zustand und Verhalten kombinieren. OOP funktioniert am besten, wenn wir klare Grenzen definieren und verteidigen müssen. Für manche Anwendungsfälle ist dieser Ansatz aber übertrieben.

In der datenorientierten Programmierung modellieren wir (unveränderliche) Daten getrennt von der Geschäftslogik. Die im Projekt Amber eingeführten Features Switch-Expression, Sealed Classes, Records und Pattern Matching helfen uns, diesen Ansatz in Java umzusetzen. Gerade kleinere, einfache Programme profitieren dabei zusätzlich von Javas statischem Typsystem.

Die Techniken der objektorientierten und der datenorientierten Programmierung stehen nicht im Widerspruch zueinander, sie sind unterschiedliche Werkzeuge für unterschiedliche Granularitäten und Situationen. In diesem Vortrag zeige ich, wie die datenorientierte Programmierung aussieht wir die beiden Paradigmen miteinander kombinieren können.

Patterns and best practices for modern software architecture work en de

The work on our software systems is becoming increasingly complex. In particular, the explicit design and communication of the software architecture are crucial for designing flexible, maintainable and scalable systems. Together we will look at various tried-and-tested practices to make architecture work more dynamic and to integrate architecture design into projects using agile approaches efficiently.

We will discuss ideas for basic architecture work (e.g. visualizing architecture requirements in the form of scenarios and technical debt), making decisions (e.g. last reasonable moment and just enough architecture ahead), collaboration and interaction (e.g. architecture communities and katas), and reflection (testing architecture goals). You can easily transfer these process patterns and best practices to your projects.

Vorgehensmuster und Best Practices für moderne Softwarearchitekturarbeit en de

Die Arbeit an unseren Softwaresystemen wird immer komplexer. Insbesondere der explizite Entwurf und die Kommunikation der Softwarearchitektur sind entscheidend um flexible, wartbare und skalierbare Systeme zu gestalten. Wir schauen uns gemeinsam verschiedene, praxiserprobte Praktiken an, um Architekturarbeit dynamischer zu gestalten und den Architekturentwurf effizient in Projekte nach agilen Vorgehensweisen integrieren zu können.

Wir diskutieren Ideen für die grundlegende Architekturarbeit (z. B. das Sichtbarmachen von Architekturanforderungen in Form von Szenarien und technischen Schulden), das Treffen von Entscheidungen (z. B. letzter vernünftiger Moment und gerade genug Architektur vorweg), die Zusammenarbeit und Interaktion (z. B. Architektur-Communities und -Katas) und die Reflexion (Testen von Architekturzielen). Ihr könnt viele dieser Vorgehensmuster und Best Practices leicht auf Eure eigenen Projekte übertragen.

Continuous and automated documentation - Docs-as-Code in practice en de

Documentation is often neglected. With the docs-as-code approach, the documentation relevant in software projects is treated exactly like source code, stored in version management, edited with lightweight developer tools (IDE/text editor, build tools, CI/CD pipelines) and integrated into the software development processes. Content can be managed without redundancy and some information can be generated from models or source code. The use of lightweight text and graphic formats makes it easy to compile the results in a target group-oriented manner. Processing is automated via the already existing build processes.

Any kind of documentation thus gains visibility, and by integrating it into the development processes and the associated continuous further development, the quality and thus the acceptance by the readers increases. Documentation can even be executed, for example, to test embedded architecture rules in an automated way on a regular basis. In this presentation, the audience will learn from concrete examples how they can get started with Documentation as Code, which typical pitfalls they should avoid and which concrete tools they should best work with.

Kontinuierlich und automatisiert dokumentieren – Docs-as-Code in der Praxis en de

Dokumentation wird häufig vernachlässigt. Mit dem Docs-as-Code-Ansatz wird die in Softwareprojekten relevante Dokumentation genau wie Quellcode behandelt, in der Versionsverwaltung abgelegt, mit leichtgewichtigen Entwicklerwerkzeugen (IDE/Texteditor, Build-Tools, CI/CD-Pipelines) bearbeitet und in die Softwareentwicklungsprozesse integriert. Die Inhalte können redundanzfrei verwaltet und manche Informationen aus Modellen oder dem Quellcode generiert werden. Durch die Verwendung leichtgewichtiger Text- und Grafikformate lassen sich die Ergebnisse einfach zielgruppenorientiert zusammenstellen. Die Verarbeitung erfolgt automatisiert über die schon vorhandenen Build-Prozesse.

Jedwede Art von Dokumentation gewinnt somit an Sichtbarkeit, durch die Eingliederung in die Entwicklungsprozesse und die damit verbundene kontinuierliche Weiterentwicklung steigt die Qualität und damit die Akzeptanz bei den Lesern. Dokumentation kann sogar ausgeführt werden, um zum Beispiel eingebettete Architekturregeln regelmäßig automatisiert zu testen. Die Zuhörer erfahren in diesem Vortrag an konkreten Beispielen, wie sie mit Documentation as Code starten können, welche typischen Fallstricke sie umschiffen und mit welchen konkreten Tools sie am besten arbeiten sollten.

Fantastic diagrams and how to create them yourself en de

The most important task of a software architect is to communicate the architecture. In addition to textual content, it is also important to create diagrams. True to the motto "a picture is worth a thousand words", diagrams help with effective and pragmatic documentation. For them to be effective, they must be easy to grasp, always up-to-date and correct.

In this talk, we first track down the weak points of many diagrams and then consider how to work around them. The result is a checklist for really good, almost fantastic architectural diagrams. As a bonus, we'll show how to implement diagrams in a maintainable way using the Docs-as-Code approach to keep them up-to-date and in line with the architecture at all times.

Phantastische Diagramme und wie Du sie selbst erstellst en de

Die wichtigste Aufgabe eines Software-Architekten besteht darin, die Architektur zu kommunizieren. Neben den textuellen Inhalten gilt es auch, Grafiken zu erstellen. Getreu dem Motto "ein Bild sagt mehr als tausend Worte" helfen Diagramme bei einer effektiven und pragmatischen Dokumentation. Damit sie wirken, müssen sie leicht erfassbar, stets aktuell und korrekt sein.

In diesem Talk spüren wir zuerst die Schwachstellen vieler Diagrammen auf und überlegen uns anschließend, wie wir sie umgehen können. Das Ergebnis ist eine Checkliste für richtig gute, fast schon phantastische Architektur-Diagramme. Als Bonus werden wir aufzeigen, wie Diagramme wartbar mit dem Docs-as-Code Ansatz umgesetzt werden, um sie jederzeit aktuell und im Einklang mit der Architektur halten zu können.

Robust and flexible string templates in Java en de

Java 21 was packed with exciting and groundbreaking innovations. In the shadow of the very present topics, string templates were relatively surprisingly introduced as a preview feature and are also included again in OpenJDK 22. They allow expressions to be embedded in string literals and text blocks. Thanks to self-definable template processors, this procedure is even customizable.

We discuss the use of string templates, look at the advantages but also the limitations. By creating our own template processors, we can validate and transform the embedded expressions and ultimately create any Java objects such as JSON documents or SQL result sets from Java strings. You can incorporate these ideas into your daily work and try out string interpolation now. Even though there will initially be no string templates in Java 23, they will soon return.

Robuste und flexible String Templates in Java en de

Java 21 war vollgepackt mit spannenden und bahnbrechenden Neuerungen. Im Schatten der sehr präsenten Themen wurden relativ überraschend String Templates als Preview Feature eingeführt und waren auch im OpenJDK 22 erneut dabei. Sie ermöglichen das Einbetten von Ausdrücken in String-Literalen und Textblöcken. Dank selbst definierbarer Template Prozessoren ist diese Vorgehensweise sogar anpassbar.

Wir diskutieren die Verwendung der String Templates, schauen uns die Vorteile aber auch die Grenzen an. Durch das Erstellen eigener Template Prozessoren können wir die eingebetteten Ausdrücke validieren, transformieren und aus Java Strings letztlich beliebige Java-Objekte wie JSON-Dokumente oder SQL-Resultsets erzeugen zu können. Ihr könnt diese Ideen in Eure tägliche Arbeit übernehmen und jetzt schon String Interpolation ausprobieren. Auch wenn es in Java 23 zunächst keine String Templates geben wird, kehren sie bald wieder zurück.

Patterns and best practices for modern software architecture work en de

The work on our software systems is becoming increasingly complex. In particular, the explicit design and communication of the software architecture are crucial for designing flexible, maintainable and scalable systems. Together, we will look at various tried-and-tested practices to make architecture work more dynamic and to efficiently integrate architecture design into projects using agile approaches.

We will discuss ideas for basic architecture work (e.g. visualizing architecture requirements in the form of scenarios and technical debt), making decisions (e.g. last responsible moment and just enough architecture ahead), collaboration and interaction (e.g. architecture communities and katas) and reflection (testing architecture goals). You can easily transfer many of these process patterns and best practices to your own projects.

Vorgehensmuster und Best Practices für moderne Softwarearchitekturarbeit en de

Die Arbeit an unseren Softwaresystemen wird immer komplexer. Insbesondere der explizite Entwurf und die Kommunikation der Softwarearchitektur sind entscheidend um flexible, wartbare und skalierbare Systeme zu gestalten. Wir schauen uns gemeinsam verschiedene, praxiserprobte Praktiken an, um Architekturarbeit dynamischer zu gestalten und den Architekturentwurf effizient in Projekte nach agilen Vorgehensweisen integrieren zu können.

Wir diskutieren Ideen für die grundlegende Architekturarbeit (z. B. das Sichtbarmachen von Architekturanforderungen in Form von Szenarien und technischen Schulden), das Treffen von Entscheidungen (z. B. letzter vernünftiger Moment und gerade genug Architektur vorweg), die Zusammenarbeit und Interaktion (z. B. Architektur-Communities und -Katas) und die Reflexion (Testen von Architekturzielen). Ihr könnt viele dieser Vorgehensmuster und Best Practices leicht auf Eure eigenen Projekte übertragen.

Functional programming with Java de en

Functional programming is on everyone's lips at the moment. Since version 8 and Lambdas/Streams, Java users also have various tools at their disposal. So it's time to get to grips with the basic concepts of functional programming.

After this talk you will understand what a pure function is and why referential transparency and page effect freedom are important concepts. We will also look at value types and how functional data structures are built and how to handle very large amounts of data efficiently thanks to demand evaluation. We also discuss the elements of reuse such as function composition, currying, partial function calls and higher-order functions. Finally, we take a look at the destructuring of data structures using pattern matching, the encapsulation of side effects and how to implement a functional core in your software architecture.

Keywords: Functional programming, Vavr, Immutables

Prior knowledge:
Solid knowledge of Java

Learning objectives:
Understand concepts of functional programming.

Comments:
With this lecture I would like to address listeners who have not yet dared to approach functional programming and introduce them to the subject matter with practical and realistic code examples.

Java for the records en de

Records offer many advantages over classes if you mainly work with data. However, we need to understand the details in order to be able to use them sensibly. This is not just about reducing superfluous code by having constructors, accessors and the methods equals(), hashCode(), and toString() automatically generated by the compiler. We can also use records in data-oriented programming as part of algebraic data types.

In this talk, we will discuss the details of the construction and lifecycle of records. These insights will help you to use them better in your projects and avoid surprises.

Java for the records en de

Records bieten viele Vorteile gegenüber Klassen, wenn man hauptsächlich mit Daten arbeitet. Allerdings müssen wir die Details verstehen, um sie sinnvoll einsetzen zu können. Dabei geht es nicht nur um die Reduzierung von überflüssigem Code indem Konstruktoren, Accessoren sowie die Methoden equals(), hashCode() und toString() automatisch vom Compiler erzeugt werden. Wir können Records auch in der datenorientierten Programmierung als Teil von algebraischen Datentypen verwenden.

In diesem Vortrag diskutieren die Details zur Konstruktion und des Lebenszyklus von Records. Diese Erkenntnisse helfen Euch, sie in Euren Projekten besser nutzen zu können und Überraschungen zu vermeiden.

Java 23 - Overview of the new features en de

Major releases with a multitude of new features appear every six months. Some start as incubators and many go through several preview phases. And even if we can't use the new functions directly, it's always worth looking at the latest version. We are currently working on exciting topics such as extensions for pattern matching, libraries for virtual threads, string templates, stream gatherers, statements before super, implicitly declared classes & instance main methods, and the class file API.

In addition to these various JDK Enhancement Proposals (JEPs), we will also look at helpful API improvements and changes to the JVM, e.g., the garbage collectors. You will get an overview of the latest developments in the Java environment and see today what you can expect in your daily work over the next few years.

Java 23 - Die Neuerungen im Überblick en de

Alle halben Jahre erscheinen Major-Releases mit einer Vielzahl von neuen Features. Manche starten als Inkubator und viele durchlaufen mehrere Preview-Phasen. Und auch wenn wir die neuen Funktionen nicht direkt einsetzen können, lohnt sich immer der Blick auf den aktuellsten Stand. Aktuell geht es um so spannende Themen wie Erweiterungen zum Pattern Matching, Bibliotheken rund um Virtual Threads, String Templates, Stream Gatherers, Statements before super, Implicitly Declared Classes & Instance Main Methods und die Class File API.

Neben diesen verschiedenen JDK Enhancement Proposals (JEPs) werfen wir natürlich auch einen Blick auf hilfreiche API-Verbesserungen und Änderungen an der JVM, z. B. bei den Garbage Collectoren. Ihr bekommt einen Überblick über die neusten Entwicklungen im Java-Umfeld und seht heute schon, was Euch in den nächsten Jahren in der täglichen Arbeit erwarten wird.

Real world architectural diagrams en de

Using a fictitious but realistic example, we will discuss various diagrams to capture important solution approaches and decisions. In addition to the four views (system context, building block view, runtime view, and distribution view), this also includes other visualizations such as a big picture or a quality tree. We discuss what content belongs in the respective diagram and which form and style guidelines should be adhered to. We will use freely available tools and lightweight methods such as Diagrams-as-Code, Documentation-as-Code, C4, arc42, docToolchain, kroki.io, PlantUML, Structurizr, draw.io/diagrams.net. You can apply what you have learned directly to your projects and will be able to provide your colleagues with easy-to-understand and easy-to-maintain software architecture diagrams in the future.

Real World Architekturdiagramme en de

An einem fiktiven, aber realistischen Beispiel werden wir verschiedene Diagramme diskutieren, um wichtige Lösungsansätze und Entscheidungen festzuhalten. Dazu zählen neben den vier Sichten (Systemkontext, Baustein-, Laufzeit- und Verteilungssicht) auch weitere Visualisierungen wie zum Beispiel ein Big Picture oder ein Qualitätsbaum. Wir besprechen sowohl, was inhaltlich in das jeweilige Diagramm gehört und welche Form und Style-Richtlinien eingehalten werden sollten. Dabei kommen frei verfügbare Werkzeuge und leichtgewichtige Methoden wie Diagrams-as-Code, Documentation-as-Code, C4, arc42, docToolchain, kroki.io, PlantUML, Structurizr, draw.io/diagrams.net zum Einsatz. Ihr könnt das Gelernte direkt auf Eure Projekte übertragen und werdet in Zukunft Eure Kollegen mit gut verständlichen und leicht zu wartenden Softwarearchitekturdiagrammen beglücken.

From clean architecture to evolutionary architecture en de

Software systems are becoming increasingly complex and the demands placed on them are constantly changing. Evolutionary software architecture attempts to adapt continuously and efficiently to changing framework conditions, requirements, technologies, and environments. The ideas of clean architecture are an important basis for evolutionary architecture. Through the clear separation of responsibilities, independence from libraries/frameworks, increased testability and flexibility, clean architecture provides a robust structure to facilitate further development.

In this talk, we will discuss how these two approaches pave the way for sustainable software development, in particular how they reduce risks when making changes, promote portability, and improve collaboration within the development team.

Von Clean Architecture zu evolutionärer Architektur en de

Softwaresysteme werden immer komplexer und die Anforderungen an sie wandeln sich ständig. Evolutionäre Softwarearchitektur versucht, sich kontinuierlich und effizient an sich verändernde Rahmenbedingungen, Anforderungen, Technologien und Umgebungen anzupassen. Die Ideen einer Clean Architecture stellen wichtige Grundlagen für evolutionäre Architektur dar. Denn durch die klare Trennung von Verantwortlichkeiten, die Unabhängigkeit von Bibliotheken/Frameworks, die erhöhte Testbarkeit und Flexibilität bietet Clean Architecture eine robuste Struktur, um die Weiterentwicklung einfacher zu ermöglichen.

In diesem Vortrag diskutieren wir, wie diese beiden Ansätze den Weg für eine nachhaltige Softwareentwicklung ebnen, insbesondere wie sie Risiken bei Änderungen reduzieren, die Portabilität fördern und die Zusammenarbeit im Entwicklerteam verbessern.

Software architecture enables business en de

Analyzing the technical requirements and drawing the necessary conclusions about the software architecture and implementation are not trivial. The team often does not feel "enabled" and has to consult with the product owner every time an uncertainty arises. As developers and architects, we can provide valuable input in advance and help the requirements side to identify and communicate important implicit requirements and framework conditions. In this workshop, we share experiences and provide methods and tools on how to arrive at better requirements, explicitly include quality requirements, ensure that the goals behind user stories are understood, to make good decisions, and develop suitable solutions independently with clearly defined framework conditions. Architecture reviews are also a good way of regularly checking the desired quality. We discuss a lightweight method for repeatedly putting the software architecture to the test. This provides you with a helpful tool for regularly evaluating the quality requirements against the requirements side.

Softwarearchitektur enables Business en de

Die Analyse der fachlichen Anforderungen sowie die daraus resultierenden, notwendigen Rückschlüsse auf die Softwarearchitektur und die Implementierung sind nicht trivial. Häufig fühlt sich das Team nicht „enabled“ und muss bei jeder auftretenden Unsicherheit Rücksprache mit dem Product Owner halten. Dabei können wir als Entwickler:innen und Architekt:innen schon im Vorfeld wertvollen Input liefern und der Anforderungsseite helfen, wichtige implizite Anforderungen und Rahmenbedingungen zu identifizieren und zu kommunizieren. In diesem Workshop teilen wir Erfahrungen und geben Methoden sowie Werkzeuge an die Hand, wie man zu besseren Anforderungen kommt, Qualitätsanforderungen explizit aufnimmt, dafür sorgt, dass die Ziele hinter User Stories verstanden sind und wie mit klar definierten Rahmenbedingungen selbstständig gute Entscheidungen getroffen und passende Lösungen entwickelt werden können. Zur regelmäßigen Überprüfung der gewünschten Qualität bieten sich zudem Architekturreviews an. Wir diskutieren eine leichtgewichtige Methode, um die Softwarearchitektur immer wieder auf den Prüfstand zu stellen. Damit bekommt ihr ein hilfreiches Werkzeug an die Hand, die Qualitätsanforderungen gegen die Anforderungsseite regelmäßig zu evaluieren.

Quality scenarios - the hidden champions in architectural work en de

Basic architecture work is not difficult, but it is often neglected. If the architectural goals are not clear, the decisions made will not necessarily match the specified framework conditions and necessary quality requirements and, in the worst case, may even cause the project to fail. The specialist department and the role of the product owner primarily focus on the technical requirements, so there are initially no specific architecture tasks in the product backlog.

Quality scenarios help us to make architecture work visible and thus plan it into the iterative, incremental way of working. We can also use scenarios to qualitatively evaluate our software architecture. In this presentation, we will look at what types of scenarios there are, how you can create them or keep them up to date, and how you can benefit from them in your daily work.

Qualitätsszenarien - die Hidden Champions in der Architekturarbeit en de

Grundlegende Architekturarbeit ist nicht schwierig, wird aber häufig vernachlässigt. Wenn die Architekturziele nicht klar sind, werden die getroffenen Entscheidungen aber nicht unbedingt zu den vorgegebenen Rahmenbedingungen und notwendigen Qualitätsanforderungen passen und im schlimmsten Fall das Projekt sogar zum Scheitern bringen. Der Fachbereich bzw. die Rolle des Product Owner haben in erster Linie die fachlichen Anforderungen im Blick, dementsprechend gibt es zunächst auch keine konkreten Architekturaufgaben im Product Backlog.

Qualitätsszenarien helfen uns, Architekturarbeit sichtbar zu machen und somit in die iterativ, inkrementelle Arbeitsweise einzuplanen. Außerdem können wir mit Hilfe von Szenarien unsere Softwarearchitektur qualitativ bewerten. In diesem Vortrag schauen wir, welche Arten von Szenarien es gibt, wie ihr sie erstellt bzw. aktuell haltet und wie ihr dann in Eurer täglichen Arbeit davon profitiert.

Best practices for keeping architecture documentation up to date en de

Explicit software architecture is the guarantee for successful software projects. Sufficient and up-to-date documentation is needed to support communication. The docs-as-code approach provides support by bringing the documentation closer to the source code in the form of lightweight text and graphic formats, storing it in the version management system, and editing it with developer tools (IDE/text editor, build tools, CI/CD pipelines) and integrating it into the software development processes.

The presentation introduces easy-to-use methods, templates, and tools that are used to create high-quality, self-validating software documentation. We look at approaches such as Docs-as-Code, lightweight text formats, storage in version management, and embedding in the build and review processes. Making software architecture concepts visible in the code and integrating software analysis tools enable the continuous comparison of target and actual structures and bring architecture documentation to life.

Best Practices um Architekturdokumentation aktuell zu halten en de

Eine explizite Softwarearchitektur ist der Garant für erfolgreiche Softwareprojekte. Zur Unterstützung der Kommunikation braucht es eine inhaltlich hinreichende und aktuelle Dokumentation. Der Docs-as-Code-Ansatz unterstützt, in dem die Dokumentation in Form leichtgewichtiger Text- und Grafikformate näher an den Quellcode gebracht, in der Versionsverwaltung abgelegt sowie mit Entwicklerwerkzeugen (IDE/Texteditor, Build-Tools, CI/CD-Pipelines) bearbeitet und in die Softwareentwicklungsprozesse integriert wird.

Der Vortrag stellt einfach anzuwendende Methoden, Vorlagen und Tools vor, die zum Erstellen einer hochwertigen, sich selbst validierenden Softwaredokumentation eingesetzt werden. Wir schauen uns Ansätze wie Docs-as-Code, leichtgewichtige Textformate, Ablage in der Versionsverwaltung und die Einbettung in die Build- und Review-Prozesse an. Das Sichtbarmachen von Softwarearchitekturkonzepten im Code und das Einbinden von Software-Analyse-Werkzeugen ermöglichen den kontinuierlichen Abgleich der Soll- mit den Ist-Strukturen und machen die Architekturdokumentation lebendiger.

Value Objects - the next big thing in Java en de

One of the great advantages of Java was and is the static, strong type system. This helps millions of developers detect errors at compile time and makes development more robust and efficient. However, Java's distinction between primitive and reference types has been a heavy burden. The primitive data types introduced around 30 years ago for performance reasons do not integrate well with modern approaches such as generics, stream API or pattern matching.

Value Objects will provide a remedy and combine the advantages of both worlds. This will allow us to design immutable data types (state and behavior, but without their own identity) that behave like primitive data types. This not only increases performance and reduces memory consumption, it also increases readability and maintainability, as we can then define expressive yet performant types much more easily according to the ideas of DDD.

The project Valhalla has been working on this major change to Java's type system for around 10 years. There are a number of complex issues involved, such as how to handle default values and null values, the conversion of wrapper types, and the use of generic typing. In the summer of 2024, Java's Language architect Brian Goetz announced that after a long time, a breakthrough in implementation had been achieved. So let's take a look together at how value classes, null-restricted and nullable types, and extended primitive boxing will change the way we program in the future.

Value Objects - das nächste große Ding in Java en de

Einer der großen Pluspunkte von Java war und ist das statische, starke Typsystem. Das hilft Millionen von Entwicklern, viele Fehler bereits zur Compilezeit zu entdecken und macht die Entwicklung robuster sowie effizienter. Allerdings schleppt Java mit der Unterscheidung zwischen primitiven und Referenztypen von Beginn an eine schwere Bürde mit sich mit. Die vor etwa 30 Jahren aus Performancegründen eingeführten primitiven Datentypen integrieren sich nicht gut mit modernen Ansätze wie Generics, Stream API oder Pattern Matching.

Die Value Objects werden Abhilfe schaffen und die Vorteile beider Welten kombinieren. Damit können wir in Zukunft unveränderbare Datentypen (Zustand und Verhalten, aber ohne eigene Identität) entwerfen, die sich wie primitive Datentypen verhalten. Das steigert nicht nur die Performance und senkt den Speicherverbrauch, es erhöht auch die Les- und Wartbarkeit, da wir dann viel einfacher ausdrucksstarke und trotzdem performante Typen nach den Ideen von DDD selbst definieren können.

Schon seit etwa 10 Jahren wird im Rahmen vom Projekt Valhalla an dieser großen Änderung des Java Typsystems gearbeitet. Daran hängen einige komplexe Fragestellungen, wie z. B. der Umgang mit Default-Werten sowie null-Values, der Umbau der Wrapper-Typen und die Verwendung als generische Typisierung. Im Sommer 2024 hat Java Language Architekt Brian Goetz verkündet, dass nach der langen Zeit der Durchbruch in der Umsetzung erreicht ist. Darum wollen wir gemeinsam schauen, wie Value Classes, Null-Restricted und Nullable Types sowie erweitertes Primitive Boxing die Art und Weise verändern, wie wir in Zukunft programmieren werden.