Hinweis: Die aktuelle OOP-Konferenz finden Sie hier!

RÜCKBLICK AUF DAS PROGRAMM 2021

Thema: Programming Languages

Nach Tracks filtern
Nach Themen filtern
Alle ausklappen
  • Montag
    08.02.
  • Dienstag
    09.02.
  • Mittwoch
    10.02.
  • Freitag
    12.02.
, (Montag, 08.Februar 2021)
10:00 - 17:00
Mo 1
C++20 - Eine Einführung
C++20 - Eine Einführung

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 zur Compile-Zeit runden das Release ab.

Dieses Tutorial gibt einen ersten umfassenden Überblick über alle diese Themen, gewürzt mit ersten Beispielen und Erfahrungen aus der Praxis.

Zielpublikum: Entwickler:innen, Programmierer:innen, Projektleiter:innen im C++-Umfeld
Voraussetzungen: C++-Kenntnisse
Schwierigkeitsgrad: Fortgeschritten

Nicolai Josuttis ist seit 30 Jahren als Entwickler, Autor und Trainer und in der Software-Entwicklung tätig. Sein Schwerpunkt liegt dabei auf C++, über das er etliche Bücher geschrieben hat und wo er an der Standardisierung beteiligt ist.

Nicolai Josuttis
Nicolai Josuttis
flag VORTRAG MERKEN

Vortrag Teilen

14:00 - 17:00
Mo 12
Really Simple Reactive Architecture and Programming
Really Simple Reactive Architecture and Programming

Applications, services, and systems are changing out of necessity because of the kinds of platforms that are available today: distributed and multi-core. Have you been curious about Reactive Architecture and Programming but haven't had time to dig in? Join this session.

Maximum number of participants: 75

Target Audience: Architects and Developers
Prerequisites: Java Programming
Level: Advanced

Extended Abstract:
Applications, services, and systems are changing out of necessity because of the kinds of platforms that are available today: distributed and multi-core. Have you been curious about Reactive Architecture and Programming but haven't had time to dig in? Join this session and you will be in a good position to put Reactive to use on your projects. We will start from foundational building blocks and scale up to full Reactive implementations. If you bring your laptop and Java 1.8+ or C# for .NET Core 2.1+ you can try out Reactive during the session.

Vaughn Vernon is an entrepreneur, software developer, and architect with more than 35 years of experience in a broad range of business domains. Vaughn is a leading expert in Domain-Driven Design and Reactive, and champions simplicity. He consults and teaches around Domain-Driven Design and Reactive software development, helping teams and organizations realize the potential of business-driven and reactive systems as they transform from technology-driven legacy web implementation approaches. Vaughn is the author of three best-selling books published by Pearson/Addison-Wesley, and has been commissioned by them as the curator and editor of his own Vaughn Vernon Signature Series.
Vaughn Vernon
Vaughn Vernon
flag VORTRAG MERKEN

Vortrag Teilen

, (Dienstag, 09.Februar 2021)
16:15 - 17:15
Di 3.3
Decoupled Streaming Microservices Architecture with Apache Kafka, Kubernetes and Istio Service Mesh
Decoupled Streaming Microservices Architecture with Apache Kafka, Kubernetes and Istio Service Mesh

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.

Kai Wähner ist Field CTO bei Confluent. Er arbeitet mit Kunden auf der ganzen Welt und mit internen Teams wie Engineering und Marketing zusammen. Kais Hauptfachgebiet liegt in den Bereichen Data Streaming, Analytics, Hybrid Cloud Architekturen, Internet of Things und Blockchain. Kai ist regelmäßiger Sprecher auf internationalen Konferenzen, schreibt Artikel für Fachzeitschriften und teilt seine Erfahrungen mit neuen Technologien auf seinem Blog.

Kai Wähner
Kai Wähner
flag VORTRAG MERKEN

Vortrag Teilen

, (Mittwoch, 10.Februar 2021)
09:00 - 10:45
Mi 4.1
pmr::STL Containers for Embedded Applications
pmr::STL Containers for Embedded Applications

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.

Prof. Richard Kaiser führt seit vielen Jahren Seminare für Firmen durch, vor allem über Software-Entwicklung und die Programmiersprachen C# und C++ sowie C. Zu seinen Kunden gehören renommierte Weltkonzerne und kleine und mittelständische Unternehmen.
Nach dem Studium der Mathematik an der Universität Tübingen und der FU Berlin war er an der Pädagogischen Hochschule Reutlingen in der Lehrerausbildung tätig und hat sich intensiv mit Mathematikdidaktik beschäftigt. Danach war er Software-Entwickler (v.a. für technische Anwendungen), bei einigen Firmen Leiter der Software-Abteilung, über 20 Jahre Professor an der Dualen Hochschule Lörrach, über 30 Jahre freiberuflicher Trainer für C, C++, C#, Speaker bei Konferenzen, Mitglied im DIN Normierungsausschuss Informationstechnik NI-22, usw.
C++20 Templates: The Next Level
C++20 Templates: The Next Level

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

Andreas Fertig, CEO of Unique Code GmbH, is an experienced trainer and consultant for C++ for standards 11 to 20.
Andreas is involved in the C++ standardization committee, in which the new standards are developed. At international conferences, he presents how code can be written better. He publishes specialist articles, e.g., for iX magazine, and has published several textbooks on C++.
With C++ Insights (https://cppinsights.io), Andreas has created an internationally recognized tool that enables users to look behind the scenes of C++ and thus understand constructs even better.
Before working as a trainer and consultant, he worked for Philips Medizin Systeme GmbH for ten years as a C++ software developer and architect focusing on embedded systems.

Richard Kaiser
Andreas Fertig
Richard Kaiser
Vortrag: Mi 4.1-1

Vortrag Teilen

Andreas Fertig
Vortrag: Mi 4.1-2
flag VORTRAG MERKEN

Vortrag Teilen

11:00 - 11:45
Mi 3.2
Automatisiertes Erstellen von Cloudinfrastrukturen mit Azure
Automatisiertes Erstellen von Cloudinfrastrukturen mit Azure

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.

Anett Hübner entwickelt und entwirft seit 13 Jahren Softwaresysteme in verschiedenen Branchen. Sie optimiert Entwicklungsprozesse, sammelt und entwirft Best Practices u.a. für Cloud-Plattformen.
Cedric Rische ist seit 2016 ein Full-Stack Developer. Dabei konnte er Erfahrung zu verschiedenen Infrastrukturthemen sammeln. Im Rahmen seiner Ausbildung bei Volkswagen beschäftigte er sich mit dem Cloud-Dienst Azure und erstellt Infrastruktur mit Code.
Anett Hübner, Cedric Rische
Anett Hübner, Cedric Rische
flag VORTRAG MERKEN

Vortrag Teilen

11:00 - 11:45
Mi 4.2
Mit C++ Modules in eine neue Ära der Modularisierung
Mit C++ Modules in eine neue Ära der Modularisierung

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.

Stephan Roth ist Trainer und Berater bei der oose Innovative Informatik eG, mit Schwerpunkten in den Bereichen modellbasiertes Systems Engineering und Softwaretechnik mit UML/SysML, Software-Architektur und -design, Software Craft und Clean Code. Mit der Programmiersprache C++ im professionellen Kontext ist Stephan seit 2001 vertraut. Er ist zudem Fachbuchautor und regelmäßiger Sprecher auf Konferenzen.
Stephan Roth
Stephan Roth
flag VORTRAG MERKEN

Vortrag Teilen

14:30 - 15:30
Mi 4.3
Structure and Interpretation of Test Cases in C++
Structure and Interpretation of Test Cases in C++

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

Kevlin Henney is an independent consultant, speaker, writer and trainer. His development interests are in programming, practice and people. He is co-author of two volumes in the ”Pattern-Oriented Software Architecture” series, and editor and contributor for multiple books in the ”97 Things” series. He lives in Bristol and online.

Kevlin Henney
Kevlin Henney
flag VORTRAG MERKEN

Vortrag Teilen

17:00 - 18:00
Mi 4.4
C++20 - Ein Überblick
C++20 - Ein Überblick

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

Nicolai Josuttis ist seit 30 Jahren als Entwickler, Autor und Trainer und in der Software-Entwicklung tätig. Sein Schwerpunkt liegt dabei auf C++, über das er etliche Bücher geschrieben hat und wo er an der Standardisierung beteiligt ist.

Nicolai Josuttis
Nicolai Josuttis
flag VORTRAG MERKEN

Vortrag Teilen

, (Freitag, 12.Februar 2021)
09:00 - 16:00
Fr 1
(AUSGEBUCHT) Reaktiv in die Zukunft: Reactive-Streams Architekturkonzeption und Programmierung mit Java
(AUSGEBUCHT) Reaktiv in die Zukunft: Reactive-Streams Architekturkonzeption und Programmierung mit Java

Reactive-Streams wenden die bewährtesten Architektur-Paradigmen auf verteilte Systeme in Internet-Dimension an. Non-Blocking Back-Pressure ist der Schlüssel zur Entkopplung bei individueller Versorgung unterschiedlichster Clients. Mit der Klasse Flow haben sie es ins JDK geschafft und gehören somit in den Werkzeugkasten der versierten Java-Entwickler:innen. In diesem Tutorial erlenen Sie die effiziente Architekturkonzeption und Programmierung mit Reactive-Streams. So lernen Sie auch einzuschätzen, für welche Use-Cases dieses Paradigma geeignet ist.

Maximale Teilnehmerzahl: 25

Zielpublikum: Entwickler/Architekt:innen mit Bezug zu nachrichtenbasierten, reaktiven, nebenläufigen Systemen
Voraussetzungen: Java-Sprachverständnis
Schwierigkeitsgrad: Anfänger

Extended Abstract:
Back to the Future:Reactive-Streams greifen die Lehren aus Jahrzehnten der Software-Architektur auf und wenden die etabliertesten Patterns und Paradigmen auf die Anforderungen des Internet-Zeitalters an. Sie treten mit dem Versprechen an, Architekturziele wie Skalierbarkeit, Resilienz, Verfügbarkeit und Wartbarkeit zu erreichen. Dafür postuliert das Reactive-Manifesto einen Architekturstil, der Lose Kopplung der Komponenten eines verteilten Systems mit individueller und kontinuierlicher Versorgung aller Clients mit spezifischen Datenströmen durch das Konzept des Non-Blocking Back-Pressure verbindet, „Observer Pattern done right“.

Heute ist das Reactive-Streams-Paradigma ein fundamentaler Baustein für APIs in unterschiedlichsten Anwendungsfeldern, von Netflix APIs bis hin zu Datenbank- und Netzwerkschnittstellen, und mit der Klasse Flow hat es Eingang ins JDK gefunden. Somit gehört es zum Basiswissen eines jeden versierten Entwicklers und Architekten.

In diesem Tutorial erlernen Sie den praktischen Umgang mit Reactive-Streams unter Verwendung der umfangreichen RxJava-Bibliothek, die ein Baukasten für die Realisierung verschiedenster Anwendungsfälle ist.

Sie sehen, wie Entkopplung elegant durch implizite Asynchronität realisiert werden kann, und Sie setzen Reactive-Streams ein, um zentrale nichtfunktionale Anforderungen, wie Skalierbarkeit und Performance, durch Parallelität und Nebenläufigkeit zu erreichen.

Sie erhalten einen tiefen Einblick in die Realisierungsstrategien aktueller Reactive-Streams Frameworks. Sie lernen dadurch einzuschätzen, für welche Use-Cases diese geeignet sind, und wie sie sich hinsichtlich funktionaler und nichtfunktionaler Charakteristika von anderen Technologien unterscheiden. Auf dieser Basis können Sie dann tragfähige Technologie- und Architekturentscheidungen für Ihre Projekte treffen.

Marwan Abu-Khalil ist Softwarearchitekt in der Siemens AG und Trainer im Siemens Zertifizierungsprogramm für Software Architekten. Er unterrichtet seit Jahren leidenschaftlich Parallele Programmierung für die unterschiedlichsten Programmiersprachen und Umgebungen.
Marwan Abu-Khalil
Marwan Abu-Khalil
flag VORTRAG MERKEN

Vortrag Teilen

09:00 - 16:00
Fr 5
(AUSGEBUCHT) Refactoring to Immutability
(AUSGEBUCHT) Refactoring to Immutability

It has been said that immutability changes everything. But what does that mean in practice? What does it mean for existing code that looks more like the mutant apocalypse than an elegant application of mathematical thinking?

Full immutability is not always possible. Refactoring, on the other hand, is all about the art of the possible. In this hands-on workshop (bring a laptop!), we'll be looking at some tricks and tips to help reduce mutability in code.

Maximum number of participants: 16

Target Audience: Developers, Architects
Prerequisites: Java or C# knowledge
Level: Advanced

Extended Abstract:
It has been said that immutability changes everything. But what does that mean in practice? What does it mean for existing code that looks more like the mutant apocalypse than an elegant application of mathematical thinking? Mainstream programming languages are normally grounded in imperative styles — from updating local variables to updating records in databases. But although they have grown from imperative roots, languages such as C# and Java are expressive and evolved enough that they can embrace many different approaches. Indeed, trends in the development of many languages have made immutability and the reduction of mutability easier to support.

Immutability is attractive because it makes code easier to reason about, reduces the possibility of many classes of bug, improves the testability of code, reduces the amount of validation and error-handling code, makes code more scalable when threaded and makes code more thread-safe. However, immutability can be an ideal that is hard to reach, and much advice doesn’t cover enough of the situations developers find in their codebases. Refactoring, on the other hand, is all about the art of the possible.

Whether you’re working in the cloud or on the desktop, in the mobile space or on the web, steering your code and design style towards immutability offers both short-term and long-term practical benefits. In this hands-on workshop, we’ll be looking at guidance and practice to help reduce the mutability of state in your codebase.

So bring a laptop, but don't worry about IDEs, editors, compilers and all that — just a browser and WiFi access! We'll be running the hands-on part using cyber-dojo.org, working with unit tests and good humour :-)

Kevlin Henney is an independent consultant, speaker, writer and trainer. His development interests are in programming, practice and people. He is co-author of two volumes in the ”Pattern-Oriented Software Architecture” series, and editor and contributor for multiple books in the ”97 Things” series. He lives in Bristol and online.

Kevlin Henney
Kevlin Henney
flag VORTRAG MERKEN

Vortrag Teilen

Zurück