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
- Artificial Intelligence Now!
- C++ and Programming of Embedded Systems
- DevOps & Automation Now!
- Diversity & Inclusion
- From Projects to Products/Services: Aligning Architecture and Organization for Sustainable Speed
- Full Day Tutorial
- Fusion: IT-Future-Society
- Half Day Tutorial
- Modern Software Architecture
- Product Development in Times of Digitalization
- Signature Track: The Time is Now!
- Social Integration
- Software Architecture Communication & Assessment
- Testing & Quality
- Trends & Techniques
- Use Domain-Driven Design Now!
- Artificial Intelligence
- Domain-Driven Design
- Product Development
- Programming Languages
- Requirements Engineering
- Soft Skills/Social Skills
- Software Engineering
- Talks with Limited Attendance
- Testing & Quality
- Virtual Reality
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++
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.
Target audience: Developers, Architects
Prerequisites: Solid background in programming from other C-like languages
Rust has recently gained significant popularity. It has been achieving top rankings in the Most Loved Language-category of the Stack Overflow developer survey for many years in a row. The reasons for Rust’s success are manifold. The language is statically typed but with zero-cost abstractions, it eliminates entire classes of bugs because of its memory safeness, it generates blazingly fast code, you can build a wide variety of application types ranging from embedded systems for IoT devices to RESTful web APIs in the cloud, etc.
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
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.
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++
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
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.
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.
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
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
The adoption of static analysis of C++ and Java requires that the findings and errors can be prioritised in an efficient way. Our work shows that Machine learning (ML) can support this presentation of static analysis results to end-users. The ML engine learns from the codebase itself, and also observes the violations that the user fixes and which he ignores. The ML uses this to suggest the next best violations to fix, relying on probability of violations to be harmful or most likely to be a noise.
Target Audience: Developer Managers, R&D Managers, Software Architects, Software Engineers
Prerequisites: English, Software development, Coding experience, C++, Java, C#.
Static code analysis is often understood as a mandatory part for checking the source code compliance to government and industry regulations, company-wide guidelines and practices. It can play, however, a more fundamental role in estimating the quality of the code in general, understanding the amount of technical debt, creating the strategy to reduce the amount of technical debt, as well as a helper in making decisions on how to speed up the development by creating a more maintainable, understandable, sociable codebase.
However, by its nature, static code analysis is bound to produce a large amount of noise and false alerts that can distract the team from the actual bugs in the code and prevent them from working thoroughly with the findings. One of the reasons for that is the level of soundness of the static analysis tool. If we want to be sure that the analysis is bound to find all errors in the code, the static analysis tool has to report all possible candidates. The more sound the tool is configured to be, the larger the number of the possible errors is reported, which increases the number of false positives as well.
To improve the user experience of working with static analysis technology, we have developed a machine learning (ML) based approach to presenting the results of the static analysis to users. The ML engine can learn from the code base itself, from a user's preferences, as well as from the interaction within the team. At the code level, our engine learns from the syntactical and semantical structure of the analyzed code to understand which violations are more likely to cause more harm, which violations are more likely to be noise, what underlying problems can be fixed to drastically reduce the number of reported violations. At the user level, the ML engine observes which violations the user fixes and which violations the user ignores. Based on these observations, the ML engine builds a model and uses it to suggest the next best violations to fix.
Maintaining a database containing millions of products can be very challenging, especially when the information you require of these products is subject to changes over time.
We show how we used state of the art Deep Learning methods (such as Transformers, BERT) in connection with smart text matching in order to extract relevant information from free-form text.
We also explain how we leveraged the existing database to create an automatically labelled training dataset.
Our model enables us to continuously update idealos database automatically.
Target Audience: Decision Makers, Technical Project Leaders, Developers
Prerequisites: Basic knowledge of machine learning methodology
To maintain idealos product base, product information in the form of values of predefined product attributes needs to be extracted from free-form text product descriptions.
Before the use of a Machine Learning based solution, this process required a lot of manual work to define rules to extract this information. There is also a high effort connected to keeping these rules consistent across the whole database and different types of products, especially since the source of this information (the product descriptions) as well as the required information (the product properties) are subject to changes over time.
In this talk we present a machine learning solution, based on fine tuned state-of-the-art models such as BERT, which is able to extract product information automatically from product descriptions with production-ready performance.
Our solution contains two different models, each following one of the well-known problem settings in Natural Language Processing (NLP): Semantic Segmentation of text (also known as Token Classification) and Question Answering. We will present both models in detail, as well as discussing their advantages and disadvantages for solving the task at hand and how we measured its performance (metrics).
We will also emphasize the importance of identifying aspects of your data that ensure that the developed model can actually fulfill your business needs before curating your dataset.
This highlights another benefit of implementing a Machine Learning model for a huge database: You will get sanity checks of your existing data “for free”, as consistent data is a prerequisite for a successful Machine Learning project.
One problem that is very common in large organisations is that there is often no or only very little training data in the form of labels for specific text sections available. We show how we mitigated this problem by leveraging the existing database to generate a large artificial training dataset. This allowed us to only use a few thousand manually labelled examples for training and testing to reach sufficient performance.
C++20, die nächste große Revolution von C++, ist dabei sich durchzusetzen.
Mit Concepts, Ranges, Koroutinen und Modulen stehen große neue Features zur Verfügung, die das Programmieren in C++ teilweise radikal ändern. "Kleinigkeiten" wie neue Operatoren, Erweiterungen zu Multi-Threading und Concurrency, Kalender und Zeitzonen, formatierte Ausgabe, neue Template-Features und Sprachmittel zum Compile-Zeit-Computing runden das Release ab.
Dieses Tutorial gibt einen umfassenden Überblick gewürzt mit Beispielen und ersten Erfahrung aus der Praxis.
Voraussetzungen: Grundkenntnisse in C++