Konferenzprogramm

Die im Konferenzprogramm der OOP 2022 Digital angegebenen Uhrzeiten entsprechen der Central European Time (CET).

Per Klick auf "VORTRAG MERKEN" innerhalb der Vortragsbeschreibungen können Sie sich Ihren eigenen Zeitplan zusammenstellen. Sie können diesen über das Symbol in der rechten oberen Ecke jederzeit einsehen.

Unser Programm gibt es auch als praktische PDF-Datei >>Zum Download

Thema: Embedded

Nach Tracks filtern
Nach Themen filtern
Alle ausklappen
  • Montag
    31.01.
  • Dienstag
    01.02.
  • Mittwoch
    02.02.
, (Montag, 31.Januar 2022)
10:00 - 17:00
Mo 4
Modern C++ Design for Safe and Embedded Systems
Modern C++ Design for Safe and Embedded Systems

This tutorial will demystify some of C++ complexities by showing clear guidelines to simpler use of specific language features for designing functions and types of your system. From the experience in specifying new MISRA C++ guidelines the author will show how to write safer C++ for embedded and other systems.

Learning goals consist of

  • designing function interfaces: parameter passing styles and error reporting
  • employ strong typing for better domain values
  • conscious class design for resource management and hierarchies

Target Audience: Developers
Prerequisites: Practical knowledge of C++
Level: Advanced

Extended Abstract
This tutorial is trying to simplify your use of C++. We have many great rule sets to chose from, some partially outdated, like Scott Meyers 3rd edition, some futuristic, like the C++ core guidelines. While working on the AUTOSAR C++ and new MISRA C++ guidelines I found that many of the guidelines forbid things without giving actual guideline on how to do things and when to deviate.

Also many talks (mine included) on C++ explain the modern features and show how they work, but only few put things into context and show what to give up and how things combine sanely.

This full day tutorial is the result of thinking about that. It won’t show C++20 feature by feature, but gives a coherent set of practices to improve your design and code using existing standard C++ features where they give you benefits.

We will cover the following topics:

  • designing function interfaces in a way that they are easy to call correctly and hard to call incorrectly
  • how to report function contract violations (at least 5 different ones) and their individual benefits and liabilities, so you can make a conscious choice.
  • what parameter passing style and return value style works best under what conditions
  • how to create (parameter) type wrappers to avoid passing wrong arguments
  • class design for simple value wrappers to improve function interfaces
  • mix-in strategies for functionality and operators, so that creating value wrappers is simpler
  • provide an overview of class styles, e.g., value, manager, oo-bases and show how to select from the rules for special member functions
  • take a look at the lesser known C++11 feature of ref-qualified member functions and show why and when to use them for your member functions

If you are brave enough, bring your own examples that we can look at and discuss where they are perfect and where they could be improved.

Peter Sommerlad is a consultant and trainer for C++ and agile software development. He was professor and lead the Institute for Software at HSR Rapperswil. Peter is co-author of the books POSA Vol. 1 and Security Patterns and contributed to "97 things every programmer should know". Peter is an ACM Senior Member and member of ACCU, IEEE CS, and the ISO WG21( C++ ) and WG23 (vulnerabilities) committees. Peter participated in the creation of MISRA C++202x.
Peter Sommerlad
Peter Sommerlad
Vortrag: Mo 4
flag VORTRAG MERKEN

Vortrag Teilen

, (Dienstag, 01.Februar 2022)
09:00 - 10:30
Di 9.1
C++20: What's In There For You
C++20: What's In There For You

C++20 is now a year old. Time to take a closer look at the benefits you get when using C++ for standards 11 to 20. You learn about Coroutines by building a coroutine-based parser. The new ranges and the spaceship operator help you write less code. You will learn how Concepts help you to express constraints better and improve error messages. Doing things at compile-time saves run-time. Let‘s see how C++20 improves your code with the new features consteval and constinit. After this talk, you learned some C++20 features and saw the improvements to C++17 code.

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

Extended Abstract
C++20 is now a year old. The major compilers already provide a solid support for the new standard. It is time to take a closer look and figure out the benefits you get when using C++20. Because there are so many improvements in C++20, we will focus on: Concepts, Coroutines, ranges, the spaceship operator, and compile-time evaluation.
Coroutines are the feature that likely will have a strong impact on future finite state machine code. In a brief tour, we will see what we need to do for building a coroutine-based byte-stream parser and how this code is so much more beautiful than without Coroutines.
Less code is always a good thing. The new ranges part of the STL helps us achieve this goal. We will take a brief look at how ranges simplify our code.
Speaking about less code, how about writing a class with all comparison operations without having to write an awful amount of boilerplate code? Sounds good? Then let's see how C++20 helps us there with the spaceship operator.
And while we are speaking about less code, generic programming comes to mind. Concepts give us a whole new way to express constraints and requirements in generic code. Concepts make our code better readable while, at the same time, give us way better error messages.
We don't stop there. Together we will look at the updates to the compile-time world. With consteval and constinit we have two new keywords allowing us new things to do. A lot of former restrictions of constexpr functions were dropped as well. The most popular is probably the ability to dynamically allocate memory at compile-time. We will explore these features using some practical examples.
After this talk, you will have seen the probably most impactful features of C++20. You learned by examples how to use them. The comparisons to pre-C++20 code give you a good understanding of what your benefits are by using C++20.

Andreas Fertig, CEO of Unique Code GmbH, is an experienced trainer and lecturer 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 to 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.
Andreas Fertig
Andreas Fertig
flag VORTRAG MERKEN

Vortrag Teilen

14:00 - 14:45
Di 9.2
Leaving Template Meta-Programming Behind
Leaving Template Meta-Programming Behind

In this talk I will show a prototype of CTRE (Compile Time Regular Expressions) which uses the least amount of template metaprogramming possible. Instead, I will use constexpr, consteval functions and other features of C++20 to bring the same features as the original library but with more performance. In the course of the talk I will focus on major problematic points of the previous design of the library and will demonstrate how to replace them with mostly constexpr code.

Target Audience: Developers
Prerequisites: Template meta-programming in C++
Level: Expert

Hana Dusíková is a staff scientist in Avast Software where she is working on distributed and high-performance backend systems. She is the chair of SG7 (Study Group for Reflection and Compile-Time Programming) and Czechia National Body representative in WG21 (ISO C++ committee). Hana is also the author of the CTRE library (Compile Time Regular Expressions).
Hana Dusíková
Hana Dusíková
flag VORTRAG MERKEN

Vortrag Teilen

16:15 - 17:15
Di 9.3
C++17 Polymorphic Memory Resources (pmr) and STL Containers for Embedded Applications
C++17 Polymorphic Memory Resources (pmr) and STL Containers for Embedded Applications

For many embedded C++ applications, compliance with the AUTOSAR or Misra rules is required. Among them is AUTOSAR Rule A18-5-5 which does not allow memory allocations with new. Since new and delete violate A18-5-5, the default STL containers must not be used in applications requiring AUTOSAR compliance. This holds for many embedded applications. With the allocators available since C++17 in the namespace std::pmr (polymorphic memory resources) these requirements can often be satisfied.

Target Audience: Architects, Developers, Project Leader
Prerequisites: Good C++ knowledge
Level: Advanced

Extended Abstract
For many embedded C++ applications, compliance with the AUTOSAR or Misra rules is required. Among them is AUTOSAR Rule A18-5-5.
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.

This rule has far-reaching consequences, because per default the C++ standard library containers allocate their memory with new and free it with delete. These calls
• do not have deterministic execution times.
• can cause memory fragmentation.

Since new and delete violate A18-5-5, the default STL containers must not be used in applications requiring AUTOSAR compliance. This holds for many embedded applications.
With the allocators available since C++17 in the namespace std::pmr (polymorphic memory resources) these requirements can often be satisfied. This means that, for the first time in the history of C++, the containers and algorithms of the C++ standard library can be used in applications that require AUTOSAR Rule A18-5-5.

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.
Richard Kaiser
Richard Kaiser
flag VORTRAG MERKEN

Vortrag Teilen

17:45 - 18:45
Di 9.4
MISRA C++ 202x
MISRA C++ 202x

New MISRA C++ 202x are coming. This release will address modern C++ and thus is relevant not only for safety critical code in the automotive sector, but also for day-to-day C++ development. Expect the new MISRA rules to be less "miserable" for your day-to-day coding and use static analysis tooling to enforce them. Understand what kind of C++ will be considered unsafe, get examples of guidelines and learn which rules better to suppress in static analysis tools in non-safety-critical software.

Target Audience: Developers
Prerequisites: C++
Level: Advanced 

Extended Abstract
New MISRA C++ guidelines are coming. In contrast to the previous release in 2008, MISRA C++ will address modern C++ as it is used in modern automotive systems. It is expected that other domains with safety critical software will incorporate MISRA C++ as well. In addition many of the rules, especially those supported by corresponding static analysis tools, can make your own C++ coding practices better. The talk briefly introduce the development of safety critical software, highlight some of the modern MISRA C++ rules applicable to all kinds of code and will also show corners of the rule set, better avoided for "normal" C++ code. The latter is important to know, when you are asked to retrofit your code to the output of a static analyzer tuned to MISRA-C++.
* History of MISRA C++ guidelines
* Peculiarities of software development for safety-critical systems
* Example guidelines and how they influence coding
* "strong stuff" that should not bother in normal C++
* Outlook on further revisions

Peter Sommerlad is a consultant and trainer for C++ and agile software development. He was professor and lead the Institute for Software at HSR Rapperswil. Peter is co-author of the books POSA Vol. 1 and Security Patterns and contributed to "97 things every programmer should know". Peter is an ACM Senior Member and member of ACCU, IEEE CS, and the ISO WG21( C++ ) and WG23 (vulnerabilities) committees. Peter participated in the creation of MISRA C++202x.
Peter Sommerlad
Peter Sommerlad
flag VORTRAG MERKEN

Vortrag Teilen

, (Mittwoch, 02.Februar 2022)
14:30 - 15:30
Mi 7.3
Die Zukunft beginnt jetzt – Machine Learning für AIoT-Systeme in MLOps-Umgebungen
Die Zukunft beginnt jetzt – Machine Learning für AIoT-Systeme in MLOps-Umgebungen

Machine Learning (ML) auf leistungsfähigen Systemen gehört längst zum Alltag. Inzwischen beginnt ML, sich auch auf eingebetteten Systemen zu verbreiten, da die Inferenz auf Edge-Geräten eine signifikante Reduktion von Datenströmen erlaubt. Im Gegensatz zu programmierfokussierten Frameworks wie TensorFlow bieten MLOps-Werkzeuge einen durchgängigen Prozess für Machine Learning, der keine Programmierung erfordert und auch Datenanalysten unterstützt. Der Vortrag illustriert dies mittels eines konkreten Beispiels anhand der MLOps-Umgebung Edge Impulse.

Zielpublikum:
Datenanalysten, Architekt:innen, Entwickler, Entscheidungsträger
Voraussetzungen: Grundkenntnisse AI/ML, Grundkenntnisse in eingebetteten Systemen
Schwierigkeitsgrad: Fortgeschritten

Extended Abstract

Machine Learning (ML) spielt in der Software-Entwicklung mittlerweile eine bedeutende Rolle, speziell bei verteilten und leistungsfähigen Systemen. Zunehmend erfasst diese Entwicklung auch eingebettete Systeme. Durch Inferenz auf Edge-Geräten lassen sich Datenströme reduzieren und Energieverbrauch einsparen. Mächtige Frameworks wie TensorFlow bzw. Tensorflow Lite spielen hierbei eine zentrale Rolle. Sie benötigen allerdings aufwendige Programmierung und unterstützen die Aufgabenteilung zwischen Entwicklern und Datenanalysten nur unzureichend.

MLOps-Werkzeuge adressieren diese Herausforderung, indem sie einen durchgängigen Prozess für Machine Learning zur Verfügung stellen, beginnend mit der Modellerstellung, über manuellen oder programmatischen Datenimport sowie Feature Extraction bis hin zum Training und der Installation kompakter Inferenzlaufzeitsysteme auf Endgeräten.

Der Vortrag illustriert anhand eines praktischen Beispiels, wie sich ML-Modelle mit Hilfe des MLOps-Werkzeugs Edge Impulse trainieren, erstellen und auf AIoT-Geräten installieren lassen, welche Vorteile sich daraus ergeben, und welche Beschränkungen (momentan) zu beachten sind.

Prof. Dr. Michael Stal forscht bei Siemens Technology an Themen rund um Software-Architektur und ist seit drei Jahrzehnten international als Experte auf diesem Gebiet renommiert.
Michael Stal
Michael Stal
flag VORTRAG MERKEN

Vortrag Teilen

Zurück