Apache Kafka became the de facto standard for microservice architectures. Decoupled applications and Domain-driven Design (DDD) are key benefits. However, that also introduces new challenges like observability of the whole ecosystem. This session explores the problems of distributed Microservices communication and how Kafka, Kubernetes and a Service Mesh like Istio address them. Learn some approaches for combining them to build a reliable and scalable microservice architecture with decoupled and secure microservices.

Target Audience: Software Architects, Consultants, Developers, Project Leads
Prerequisites: Experience with distributed systems / messaging frameworks is helpful
Level: Advanced

Extended Abstract:
Apache Kafka became the de facto standard for microservice architectures. It goes far beyond reliable and scalable high-volume messaging. In addition, you can leverage Kafka Connect for integration and the Kafka Streams API for building lightweight stream processing microservices in autonomous teams. Decoupled applications and Domain-driven Design (DDD) are key benefits. However, microservices also introduce new challenges like observability of the whole ecosystem.

A Service Mesh technology like Istio (including Envoy) complements the architecture. It describes the network of microservices that make up such applications and the interactions between them. Its requirements can include discovery, load balancing, failure recovery, metrics, and monitoring. A service mesh also often has more complex operational requirements, like A/B testing, canary rollouts, rate limiting, access control, and end-to-end authentication.

This session explores the problems of distributed Microservices communication and how both Apache Kafka and Service Mesh solutions address it together on top of Kubernetes. I cover different approaches for combining both to build a reliable and scalable microservice architecture with decoupled and secure microservices.

Der Vortrag findet in Englisch statt / The lecture will be in English

Per default, the standard library containers allocate their memory with new and release it with delete. These calls
• do not have deterministic execution times
• can lead to memory fragmentation
In many embedded applications this is not tolerable. Therefore, using standard library containers is not allowed.
With the allocators available since C++17 in the std::pmr namespace (polymorphic memory resources) these disadvantages can often be avoided. With the pmr containers, standard library containers can be used for the first time in the history of C++ in many embedded applications.

Zielpublikum: Architects, Developers, Project Leader, Manager, Decision Makers
Voraussetzungen: Basic C++ experience
Schwierigkeitsgrad: Fortgeschritten

Extended Abstract:
Per default, the standard library containers allocate their memory with new and release it with delete. These calls
• do not have deterministic execution times
• can lead to memory fragmentation
In many embedded applications this is not tolerable. AUTOSAR Rule A18-5-requires:
Memory management functions shall ensure the following:
(a) deterministic behavior resulting with the existence of worst-case execution time,
(b) avoiding memory fragmentation,
(c) avoid running out of memory,
(d) avoiding mismatched allocations or deallocations,
(e) no dependence on non-deterministic calls to kernel.
With the allocators available since C++17 in the std::pmr namespace (polymorphic memory resources) these disadvantages can often be avoided. With the pmr containers, standard library containers can be used for the first time in the history of C++ in many embedded applications.

C++20 is more or less out the door. It is probably the biggest change to the language since ever. In this session we will look into some changes that templates received with C++20. The biggest change is the introduction of Concepts.

We don’t stop there. We will also talk about improvements to CTAD and NTTP. Of course, we will also look into how templated lambdas work in C++20.

By the end of the talk you have learned about the newest C++20 template updates and how to apply them.

Target Audience: Developers
Prerequisites: Knowledge about at least C++11
Level: Basic

Moderne Cloudarchitekturen ermöglichen es, via Quellcode IT-Landschaften versioniert abzulegen und jederzeit automatisiert auf- und abzubauen. Mit dem Einsatz von Templates können Aspekte wie Sicherheit projektübergreifend genutzt und adressiert werden.

Anhand von praktischen Beispielen werden Prinzipien für eine betreibbare und wartbare Infrastrukturautomatisierung erläutert, beispielsweise Modularisierung von Infrastrukturelementen, Trennung von Konfiguration und Automatisierung sowie Lebenszyklen für Build, Deployment und Staging.

Zielpublikum: DevOps Engineer
Voraussetzungen: Grundlegendes Verständnis von DevOps
Schwierigkeitsgrad: Anfänger

Extended Abstract:
AWS, Openstack oder Azure - es ist heutzutage sehr einfach, Infrastruktur per GUI zusammenzustellen. Eine so aufgesetzte Infrastruktur ist aber nicht robust gegen Fehler und anfällig für Fehlbedienung. Im schlimmsten Fall kann die aufgebaute Infrastruktur nach einem Fehler oder Ausfall nicht mehr hergestellt werden - ein Szenario, das für eine Produktivumgebung undenkbar und höchst kritisch wäre.

Dieser Vortrag soll dazu motivieren, Infrastruktur analog zu Softwareständen als Code abzulegen und somit nachvollziehbar und reproduzierbar zu machen.

Eine der ganz großen Innovationen im neuen C++-Sprachstandard (C++20) ist C++ Modules. Dieses Modulsystem soll das Ende der Header-Dateien und des Präprozessors, sowie der damit einhergehenden Probleme, einläuten.

In meinem Vortrag erläutere ich nicht nur die Funktionsweise, Unterschiede sowie die Vor- und Nachteile von C++ Modules im Vergleich zum alten Modularisierungskonzept mit Header- und Implementierungsdateien. Ich möchte insbesondere auch mal eine holistische Perspektive anbieten: Welchen Einfluss hat Modules auf die Software-Architektur?

Zielpublikum: Entwickler:innen, Software-Architekten:innen
Voraussetzungen: Kenntnisse in der Programmiersprache C++ sind hilfreich.
Schwierigkeitsgrad: Anfänger

Extended Abstract:
Das Interessante an dem neuen Feature "C++ Modules" ist nicht nur sein Potenzial, das mittlerweile antiquiert erscheinende, schwache und mit vielen Problemen (z.B. ODR violations) behaftete Modularisierungskonzept von der prozeduralen Programmiersprache C loszuwerden. Die Auswirkungen auch auf die Software-Architektur eines C++-Entwicklungsprojekts dürften bemerkenswert sein und die Art und Weise, wie C++-Entwicklungsprojekte in den nächsten Jahrzehnten strukturiert werden, massiv verändern. Genau diesem Aspekt möchte ich in meinem Vortrag auch Raum geben.

Throw a line of code into many codebases and it’s sure to hit one or more testing frameworks. There’s no shortage of frameworks for testing, each with their particular spin and set of conventions and, but that glut is not always matched by a clear vision of how to structure and use tests — a framework is a vehicle, but you still need to know how to drive.

Compared to many languages, C++ has had slower widespread adoption of unit testing. This talk takes a deep dive into the practices and issues, looking at examples and counterexamples in C++.

Target Audience: C++ developers
Prerequisites: C++ programming
Level: Advanced

C++20, die nächste große Revolution von C++, fängt an sich durchzusetzen.

Mit diesem neuen Release stehen etliche große neue Features zur Verfügung, die das Programmieren in C++ teilweise radikal ändern. Ranges, Concepts, Modules, und Coroutines sind die großen Themen. Etliche "Kleinigkeiten" für Concurrency, UTF8, neue Operatoren und Berechnungen möglichst auf zur Compile-Zeit runden das Release ab.

Dieser Vortrag gibt einen ersten Überblick über alle diese Themen geben, sodass eine erste Einschätzung von C++23 möglich ist.

Zielpublikumg: Entwickler, Programmierer, Projektleiter im C++-Umfeld
Vorraussetzungen: C++ Kenntnisse
Schwierigkeitsgrad: Anfänger