
Falk Sippach
embarc
Darmstadt, Germany
Actions
As a software architect, consultant and trainer at embarc Software Consulting GmbH, Falk Sippach is always on the lookout for that spark of passion that he can ignite in his participants, customers and colleagues. He has been supporting mostly agile software development projects in the Java environment for over 20 years. As an active part of the community (co-organizer of the JUG Darmstadt and Java Champion) he also likes to share his knowledge in articles, blog posts, as well as in presentations at conferences or user group meetings and supports the organization of various professional events.
Area of Expertise
Topics
Modernisation in practice: Modulith instead of microservices?ende
Nowadays, many companies are faced with the challenge of modernising their ageing applications, making them more flexible and structuring them appropriately. While microservices are widely used, a modulith - modular structured monolith - offers a promising alternative that is often overlooked.
This presentation provides insight into the practical work with Moduliths and the migration to them. We will also talk about experiences with suitable technologies such as Spring Modulith, xMolecules, ArchUnit and jQAssistant and discuss what to look out for when using them.
We will also discuss the advantages and challenges of the transformation to microservices. We look at aspects such as implementation effort, impact on the existing source code, fundamental risks in long-running replacement projects, test strategies, cognitive load, dependencies at business and technical level and the effects that all these topics have in practice.
Overall, the presentation offers an experience-based overview of Modulithen and is aimed at software architects, developers and IT decision-makers who are dealing with the modernisation of their existing systems.
30 years of Java - The innovations in Java 21 to 25ende
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 taking a look at the latest status. We are currently looking at exciting topics such as Pattern Matching enhancements, libraries for Virtual Threads such as Structured Concurrency, String Templates, Stream Gatherers, Flexible Constructor Bodies, Module Import Declarations, Simple Source Files and Instance Main Methods, the Class File API, Stable Values and 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 your daily work over the next few years.
As much architectural work as neededende
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 versionende
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 20 - Auf dem Weg zur nächsten LTS-Versionende
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 designende
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 automaticallyende
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?ende
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-Appende
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 ITlerde
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.
Moderne Softwarearchitekturen dokumentieren und kommunizierende
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 Softwarearchitekturdokumentationde
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.
Domain Driven Design für Dummiesde
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 Methodede
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 Schrittende
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 Cloudde
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 Architekturende
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 effizientde
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 Javadeen
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 Battlede
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 Appsde
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 bloggingde
... 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.
Hibernate ORM 6 - Next Generation of Java Persistencede
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.
Writing really good tests - the best practices for better (JUnit) testsende
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.
Data Oriented Programming in Javaende
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.
Patterns and best practices for modern software architecture workende
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.
Continuous and automated documentation - Docs-as-Code in practiceende
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.
Fantastic diagrams and how to create them yourselfende
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.
Robust and flexible string templates in Javaende
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.
Patterns and best practices for modern software architecture workende
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.
Java for the recordsende
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 23 - Overview of the new featuresende
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.
Real world architectural diagramsende
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.
From clean architecture to evolutionary architectureende
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.
Software architecture enables businessende
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.
Quality scenarios - the hidden champions in architectural workende
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.
Best practices for keeping architecture documentation up to dateende
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.
Value Objects - the next big thing in Javaende
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.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top