In the automotive industry, specifications often consist of a large number of textual requirements. These requirements are linguistically ambiguous and written in informal language. Utilizing Structured English for requirements eliminates ambiguity, improves data quality, and supports further automated processing while maintaining readability. The recent development of large language models enables a fully automated translation approach using few-shot learning. To deal with the limited context size of large language models, an improved algorithm, OptKATE, is presented to find an ideal set of requirements for few-shot learning. Structured English can be used as a basis for further formalization. This capability is key in creating an interface between natural language processing and verification, in our case, consistency analysis using the Z3 SMT solver. We implemented a grammar for translating Structured English into TCTL using the MontiCore workbench. Furthermore, since SMT-based methods currently rely on manual precondition satisfaction and do not tackle conflicting preconditions automatically, we propose a scenario generation algorithm that generates potential scenarios using the specification and checks the requirements against them. Through this approach, we can better identify and resolve conflicting preconditions, ultimately improving the consistency of requirements. Our toolchain is evaluated using an automotive requirements dataset provided by former Daimler AG.

Turn-based games such as chess are very popular, but tool-chains tailored for their development process are still rare. In this paper we present a model-driven and generative toolchain aiming to cover the whole development process of rule-based games. In particular, we present a game description language enabling the developer to model the game in a logics-based syntax. An executable game interpreter is generated from the game model and can then act as an environment for reinforcement learning-based self-play training of players. Before the training, the deep neural network can be modeled manually by a deep learning developer or generated using a heuristics estimating the complexity of mapping the state space to the action space. Finally, we present a case study modeling three games and evaluate the language features as well as the player training capabilities of the toolchain.

Agent-based simulation is an important testing tool for the development of autonomous vehicle software. Simulators enable engineers to test autonomous driving behavior in virtual environments, which is cheaper, faster, and safer than using a physical vehicle. An important aspect of autonomous driving software is its real-time capability, i.e. its ability to react to unforeseen events and new sensor inputs within a very short amount of time to prevent accidents. In this paper, we present a modular agent-based simulator architecture, which not only simulates the physical behavior of the vehicle, controlled by the software under test, but also its electrical/electronic (E/E) network. In particular, each ECU is simulated using a hardware emulator, which enables us to test the software as if it is run on the actual target hardware. Furthermore, the hardware emulator estimates the execution delays for the software under test, which enables more realistic approximations of the real behavior. In an evaluation example we analyze empirically how well the timing estimates reflect the reality. We show that modeling the memory hierarchy and instruction decoding has a crucial effect on the precision of this estimation.

Systems engineering, in particular in the automotive domain, needs to cope with the massively increasing numbers of requirements that arise during the development process. The language in which requirements are written is mostly informal and highly individual. This hinders automated processing of requirements as well as the linking of requirements to models. Introducing formal requirement notations in existing projects leads to the challenge of translating masses of requirements and the necessity of training for requirements engineers. In this paper, we derive domain-specific language constructs helping us to avoid ambiguities in requirements and increase the level of formality. The main contribution is the adoption and evaluation of few-shot learning with large pretrained language models for the automated translation of informal requirements to structured languages such as a requirement DSL.

Machine learning is a discipline which has become ubiquitous in the last few years. While the research of machine learning algorithms is very active and continues to reveal astonishing possibilities on a regular basis, the wide usage of these algorithms is shifting the research focus to the integration, maintenance, and evolution of AI-driven systems. Although there is a variety of machine learning frameworks on the market, there is little support for process automation and DevOps in machine learning-driven projects. In this paper, we discuss how metamodels can support the development of deep learning frameworks and help deal with the steadily increasing variety of learning algorithms. In particular, we present a deep learning-oriented artifact model which serves as a foundation for build automation and data management in iterative, machine learning-driven development processes. Furthermore, we show how schema and reference models can be used to structure and maintain a versatile deep learning framework. Feasibility is demonstrated on several state-of-the-art examples from the domains of image and natural language processing as well as decision making and autonomous driving.

Mapping the logical software architecture of a vehicle to a technical solution is not a straightforward task. A particular challenge is communication: software components developed by different teams and deployed across the E/E architecture need to be able to exchange data. Middleware solutions have been developed to enable low coupling of distributed logical software components. Building a distributed architecture on a middleware solution is mostly accomplished by encapsulating logical components into middleware wrappers. This is not only time-consuming, but also requires platform-specific understanding, and results in a multitude of architectural variants tailored for particular set-ups. For instance, lengthy validation processes ensuring functional correctness and safety require simulations of intelligent vehicle systems in different simulators, environments, and on different abstraction levels. This leads to the necessity of individual integration schemes for both simulation and deployment. We propose a component-based modeling approach separating platform-agnostic logical models from middleware aspects. Therefore, the model compiler is instrumented with middleware tags related to the elements of the logical model. Generating the required middleware code automatically, we aim at better component re-usability minimizing the need for hand-crafted glue-code for interprocess and simulator integration.

Diagnostic trouble codes (DTCs) are steadily produced by a vehicle's control units to support the diagnosis process when the vehicle is maintained or to initiate predictive maintenance. Although, DTCs carry a lot of information, possibly including environmental data such as the engine temperature, the velocity, etc., they are of little help to an automotive engineer if seen without a context. In fact, a concrete problem can mostly be diagnosed if an already known pattern of DTCs is present. However, detecting new patterns in masses of vehicle data gathered each day from thousands of vehicles and recognizing known patterns accurately cannot be performed manually by automotive engineers. We propose an unsupervised DTC pattern learning framework supporting the daily field data analysis of original equipment manufacturers (OEMs).

The field of deep learning has become more and more pervasive in the last years as we have seen varieties of problems being solved using neural processing techniques. Image analysis and detection, control, speech recognition, translation are only a few prominent examples tackled successfully by neural networks. Thereby, the discipline imposes a completely new problem solving paradigm requiring a rethinking of classical software development methods. The high demand for deep learning technology has led to a large amount of competing frameworks mostly having a Python interface - a quasi standard in the community. Although, existing tools often provide great flexibility and high performance, they still lack to deliver a completely domain oriented problem view. Furthermore, using neural networks as reusable building blocks with clear interfaces in productive systems is still a challenge. In this work we propose a domain specific modeling methodology tackling design, training, and integration of deep neural networks. Thereby, we distinguish between three main modeling concerns: architecture, training, and data. We integrate our methodology in a component-based modeling toolchain allowing one to employ and reuse neural networks in large software architectures.

Summary Efficient testing is a crucial prerequisite to engineer reliable automotive software successfully. However, manually deriving test cases from ambiguous textual requirements is costly and error‐prone. Model‐based software engineering captures requirements in structured, comprehensible, and formal models, which enables early consistency checking and verification. Moreover, these models serve as an indispensable basis for automated test case derivation. To facilitate automated test case derivation for automotive software engineering, we conducted a survey with testing experts of the BMW Group and conceived a method to extend the BMW Group's specification method for requirements, design, and test methodology by model‐based test case derivation. Our method is realized for a variant of systems modeling language activity diagrams tailored toward testing automotive software and a model transformation to derive executable test cases. Hereby, we can address many of the surveyed practitioners' challenges and ultimately facilitate quality assurance for automotive software.

Component and Connector (C&C) models, with their corresponding code generators, are widely used by large automotive manufacturers to develop new software functions for embedded systems interacting with their environment; C&C example applications are engine control, remote parking pilots, and traffic sign assistance. This paper presents a complete toolchain to design and compile C&C models to highly-optimized code running on multiple targets including x86/x64, ARM and WebAssembly. One of our contributions are algebraic and threading optimizations to increase execution speed for computationally expensive tasks. A further contribution is an extensive case study with over 50 experiments. This case study compares the runtime speed of the generated code using different compilers and mathematical libraries. These experiments showed that programs produced by our compiler are at least two times faster than the ones compiled by MATLAB/Simulink for machine learning applications such as image clustering for object detection. Additionally, our compiler toolchain provides a complete model-based testing framework and plug-in points for middleware integration. We make all materials including models and toolchains electronically available for inspection and further research.