API Expand Contract ist ein Pattern zur Weiterentwicklung von APIs. Aber was verbirgt sich hinter der Idee? Wie kann ich damit eine API weiterentwickeln, ohne dass Client und/oder Server im Wartungsaufwand alter Schnittstellen(-Versionen) ersticken?

In der Realität erweist sich Management von APIs und deren Versionen als gar nicht so einfach. Diese Session zeigt mögliche Wege und Alternativen, um der Versionierungshölle zu entkommen und dabei das oberste Gebot beim API-Design - nämlich „Don’t break the Client“ - jederzeit einzuhalten.

Zielpublikum: Architekt:innen, Entwickler:innen, Projektleiter:innen
Voraussetzungen: Kenntnisse in der API-Entwicklung, Projekterfahrung
Schwierigkeitsgrad: Fortgeschritten

Extended Abstract:
Der Thoughtworks-Technologie-Radar empfiehlt, das Pattern „Expand-Contract“ auf APIs anzuwenden.
Aber was verbirgt sich hinter der Idee?
Und wie kann ich das in der Praxis realisieren?

Wie kann ich sicherstellen, dass trotz Weiterentwicklung alle meine Clients weiterhin funktionieren und dennoch APIs unabhängig vom Server aktualisiert werden können - und das Ganze am besten ohne, dass Client und/oder Server im Wartungsaufwand alter Schnittstellen(-Versionen) ersticken?

Welche Versionierungsstrategie sollte ich in welcher Situation fahren und wie implementiere ich die verschiedenen Strategien geschickt?
In der Realität erweist sich Management von APIs und deren Versionen als gar nicht so einfach. Diese Session zeigt mögliche Wege und Alternativen, um der Versionierungshölle zu entkommen und dabei das oberste Gebot beim API-Design - nämlich „Don’t break the Client“ - jederzeit einzuhalten.

Microservices sind der Hammer, aber nicht alles ist ein Nagel. Trotzdem ist man leicht in der Versuchung, immer diesen Hammer auszupacken, wenn man eine gut modularisierte Software-Architektur zimmern will. Genau das hatten wir mit unserem System auch vor. Wir erzählen euch die Geschichte, warum wir unsere erste Entscheidung revidiert und mit modularen Monolithen ein passenderes Architektur-Werkzeug für uns gefunden haben.

Zielpublikum: Architekt:innen, Entwickler:innen
Voraussetzungen: Grundlagen zu Architektur- und Designpatterns
Schwierigkeitsgrad: Fortgeschritten

Extended Abstract:
Woran lässt sich erkennen, ob das jeweilige Architekturproblem in die Kategorie „Nagel“ fällt oder nicht? Das kommt auf die Rahmenbedingungen an: Hat man die Domain schon so gut verstanden, dass die Modellgrenzen oder „Bounded Contexts“ klar sind? Ist es wichtig, einzelne Bausteine unabhängig ausrollen zu können? Wenn nicht, können Modulare Monolithe anstelle von Microservices zwei Vorteile bringen: Erstens verbinden sie ein einfaches Deployment mit einer fachlichen Modularisierung. Damit gewinnt man die Flexibilität, den Code einfach umzubauen. Zweitens spart man sich den Verwaltungs-Overhead von Microservices, ohne dabei den Weg zu einer stärkeren Trennung zu verbauen.

Das klingt attraktiv, aber der Teufel steckt im Detail. Wie stellt man sicher, dass die einzelnen Module getrennt bleiben und kein „Big Ball of Mud“ entsteht? Wie kann man auf der anderen Seite eine Kommunikation zwischen den Modulen erlauben, um fachliche Abhängigkeiten abzubilden?

Wir zeigen euch an unserem System, wie wir die Trennung der fachlichen Module, aber auch die Kommunikation zwischen ihnen umgesetzt haben, auf welche Probleme wir gestoßen sind, welche Lösungen wir gefunden haben und welche Kompromisse wir eingegangen sind.
Damit möchten wir euch einen Eindruck vermitteln, welche Herausforderungen wir mit dem Werkzeug „Modularer Monolith“ meistern konnten, damit ihr es ebenfalls in euren Architektur-Werkzeugkoffer aufnehmen könnt.

With GraphQL a modern and flexible way of providing APIs for our data is emerging.
The clients specify which data they need, the provisioning of data becomes more flexible and dynamic. Over-fetching or under-fetching are history.
But does this mean we have to rewrite all APIs to benefit? How can we retrofit a GraphQL API onto our existing API landscape?
We will explore three different approaches.

Target Audience: Architects, Developers
Prerequisites: Basic knowledge in API design and Java
Level: Advanced

Extended Abstract:
In this talk we explore three different alternatives:
- The Developer Way: Writing a GraphQL API layer by hand
- The Cloud-native Way: Using lightweight API gateways such as Gloo or Tyk
- The Serverless Way: Using Cloud Provider native services
We will look at all three approaches conceptually and justify when and why each makes sense. Additionally, we will show in a live demo how GraphQL APIs can be added to an existing REST API.

How to structure your program right? This has been a central question since the beginning of software development. Layers are a start, but not enough. Hexagonal, Onion, and Clean Architecture have joined the club together with DDD's Tactical Design and Pattern Languages. Great system design is not achieved with one of these alone. Putting all the ingredients together we can build the Architecture Hamburger – the combination that makes high quality software possible.

Target Audience: Architects, Developers
Prerequisites: Experience in mid-size to large projects
Level: Advanced

One of the fundamental strategies of Agile Modeling is that artifacts, including architecture models, should be just barely good enough (JBGE). Another way of saying this is your models should be sufficient for the task at hand, no more and no less. But sufficiency is contextual in nature, it depends.
In this session we will look at the issue of model sufficiency, exploring the risk factors that motivate us to model more as well as the conditions that enable us to model less.

Target Audience: Software Architects, Software Developers
Prerequisites: Basic knowledge of agile, understanding of software architecture
Level: Advanced

Extended Abstract:
One of the fundamental strategies of Agile Modeling is that artifacts, including architecture models, should be just barely good enough (JBGE). Another way of saying this is your models should be sufficient for the task at hand, no more and no less. But sufficiency is contextual in nature, it depends.

In this session we will look at the issue of model sufficiency, exploring the risk factors that motivate us to model more as well as the conditions that enable us to model less. We model to think things through, to identify potential avenues for moving forward so that we can choose what we believe to be the most likely path for success. But the more effort we spend doing so potentially motivates us to make commitments earlier than we should and to lose time, and value, doing so. Balancing these tensions is how we determine model sufficiency in the context that we face. Proven agile architecture strategies that enable us to invest in less up-front modeling will also be explored. It's never just about modeling.

Agenda:
1. Architecture throughout the agile lifecycle.
2. What is initial architecture modeling?
3. What does it mean to be just barely good enough (JBGE)?
4. What risk factors motivate us to invest in more up-front modeling?
5. What factors enable us to invest in less up-front modeling?
6. What are the development practices that support an agile approach to architecture?

In a microservices architecture, services shall be as loosely coupled as possible. Still, they need to communicate with each other in order to fulfill business requirements. This talk will help you shape an answer for the typical questions (like shall I be synchronous or asynchronous and what's a good protocol to use?). You will better understand not only the architectural implications but also the effect on the productivity of your teams.

Target Audience: Developers, Architects
Prerequisites: Basic programming skills helpful
Level: Advanced

Extended Abstract:
In a microservices architecture, services shall be as loosely coupled as possible. Still, they need to communicate with each other in order to fulfill business requirements. Now there are so many questions about this communication:

•    What are the general possibilities to communicate? For example, synchronous, asynchronous, or event-driven communication. What are the tradeoffs and which communication style should you prefer?
•    What is the influence on the coupling of your services? For example, asynchronous communication reduces temporal coupling between services.
•    What do I have to consider when selecting a certain communication style?

For example, you need to apply certain resilience patterns if you want to use synchronous communication.
This talk will help you answer these questions for your project. You will better understand not only the architectural implications but also the effect on the productivity of your teams.

APIs sind die Bindeglieder moderner Architekturen und nicht selten integriert ein System APIs im zweistelligen Bereich. Damit die API-Integration nicht zur Irrfahrt wird, unterstützen API-Guidelines die Developer Experience. Mit einem Blick auf öffentliche Guidelines und APIs gibt der Vortrag einen Eindruck von der allgemeinen Situation und liefert Impulse für das eigene API-Management. Da es in der Regel zu kurz gegriffen ist, einfach öffentliche API-Guidelines zu referenzieren, geben wir Tipps für eigene API-Guidelines und deren Etablierung.

Zielpublikum: Architekt:innen und Entwickler:innen
Voraussetzungen: Erfahrung oder Interesse am Design von Remote APIs
Schwierigkeitsgrad: Anfänger

Extended Abstract:
APIs sind die Bindeglieder unserer modernen, verteilten Systemarchitektur und nicht selten liegt die Anzahl der APIs im zweistelligen Bereich, wenn ein System integriert werden muss. Damit der Überblick gelingt und die API-Integration nicht zur Irrfahrt wird, unterstützen API Style Guidelines bei einer besseren Developer Experience und sind ein wichtiger Bestandteil der API Governance.
Mit einem Blick auf öffentlich zugängliche API-Guidelines und der Analyse öffentlicher APIs werden wir uns einen Eindruck von der allgemeinen Situation verschaffen und liefern Impulse für das eigene API-Management und -Design.

Hierüber wird auch schnell klar, warum es in der Regel zu kurz gegriffen ist, einfach eine öffentliche API-Guideline zu referenzieren. Deshalb werden wir auch Wege zur eigenen API-Design-Guideline aufzeigen und Tipps geben, die bei der Etablierung im Unternehmen helfen werden.

Eine der größten Herausforderungen im Systems Engineering ist die viel beschworene Beherrschung der Komplexität. Bisher in der Praxis etablierte Ansätze betrachten die Strukturierung von Anforderungen und die Dokumentation der Realisierung durch die entsprechenden Architekturelemente. Aber was ist mit den Testfällen, dem Feature-Tree für Produktvarianten und der Organisationsstruktur? Diese Strukturen gilt es im Rahmen der Systementwicklung angemessen zu berücksichtigen und nachvollziehbar mit anderen Arbeitsergebnissen in Beziehung zu setzen.

Zielpublikum: Entwickler:innen, Architekt:innen, Requirements-Engineers, Systems Engineers
Voraussetzungen: Verständnis zum Zusammenspiel der Entwicklungsdisziplinen
Schwierigkeitsgrad: Experte

Extended Abstract:
Bei der Entwicklung von komplizierten technischen Systemen treffen unterschiedliche Disziplinen wie Anforderungs- und Architekturentwicklung, Test und Abnahme etc. aus verschiedenen Gewerken (Software- und Hardwareentwicklung) aufeinander. Trotz unterschiedlicher Ausrichtungen und Schwerpunkte leisten alle Beteiligten einen Beitrag in Form von Arbeitsergebnissen zum fertigen Produkt. Jedoch unterscheiden sich diese Arbeitsergebnisse häufig in ihrer Darstellung, betrachten aber letztlich doch das gleiche System und stehen dadurch inhaltlich in einem Zusammenhang.

Eine wesentliche Herausforderung ist es, diese Zusammenhänge in den Arbeitsergebnissen (Anforderungen, Architekturdokumentation, Testfälle etc.) transparent zu machen und zu nutzen, um dadurch disziplinen- und gewerkübergreifend eine durchgängige Systementwicklung zu gewährleisten. Für Anforderungen und Architekturdokumentationen haben sich dafür sowohl das Twin-Peaks-Modell als auch das SPES 2020-Framework mit dem RFLP-Ansatz etabliert. Beide Modelle vernachlässigen allerdings weitere Disziplinen der Systementwicklung wie z. B. Integration, Test und Abnahme oder das Produkt- und Portfoliomanagement und verzichten auf eine Betrachtung der dabei erzeugten Arbeitsergebnisse. Und wie sind diese Disziplinen eigentlich in der Organisation verortet? Welche Abteilung oder welches Team leistet welchen Beitrag am Gesamtprodukt?

Ziel dieses Vortrages ist es, ein Denkmodell zu vermitteln, das unterschiedliche, graphen- oder baumartige Strukturen und Sichten miteinander in Beziehung setzt, um dadurch typische Probleme in der Systementwicklung wie z. B. unklare Verantwortlichkeiten transparent zu machen und zu lösen. Anhand eines durchgängigen Beispiels erfahren Sie, welche weiteren Sichten neben den Anforderungen und der Architekturdokumentation auf unterschiedlichen Abstraktionsebenen in der Systementwicklung (System, Subsysteme, Komponenten) sinnvoll sein können. Neben einer Motivation, den Inhalten dieser Sichten und deren Wechselwirkungen erhalten Sie einen Einblick, welche Probleme mithilfe dieses Denkmodells gelöst werden können.

Software Development based on a distributed architecture provides both several advantages and new challenges. In order to take advantage of the distribution it requires implementation of service discovery, routing, load-balancing, resilience mechanisms and more. These requirements can be covered by language frameworks or the underlying platform.

This talk will walk through a comparison of various approaches with focus on frameworks, Kubernetes and extending options like Service Meshes and eBPF. The talk will be lecture style with demo.

Target Audience: Developers, Architects, DevOps
Prerequisites: Introductory style, basic IT and dev skills probably helpful, but not required
Level: Basic

Extended Abstract:
Software Development based on a cloud-native (or distributed) architecture provides both several advantages and new challenges. In order to take advantage of the distribution it requires implementation of service discovery, routing, load-balancing, resilience mechanisms and more. Initially software frameworks provided dedicated implementations for API Gateways, Service Registries, Circuit Breakers and many more. These functionalities are declared as code dependencies and need to be set at build time.

With Kubernetes there are alternative options to address these requirements. Kubernetes provides concepts for service discovery, load-balancing and resilience. So-called service meshes extend this functionality with more granular network interaction. They are not part of the application code and can hence be added during runtime. A fairly new approach is emerging with the eBPF technology, which claims to enable service meshes with minimal overhead.

With this talk Matthias wants to explain "the why" of cloud-native application design and how various cloud-native technologies facilitate this. It shows the possibilities and limitations of technologies and which forms of integration can make sense. The talk mostly consists of graphical visualisations/explanations and contains a live demo.