Abstract Model-Driven Engineering (MDE) has been widely adopted across various industrial sectors due to its ability to manage the complexity of modern engineering products. However, traditional modeling languages and tools are often limited to a single, specific concrete syntax, which poses challenges for the diverse stakeholders involved in the modeling process.. To address these limitations, the emerging field of blended modeling introduces the use of multiple concrete syntaxes, and in some cases, even multiple abstract syntaxes, for representing the same information. In this expert perspective, we present generalized, technology-agnostic concepts developed within a European research and development project focused on blended modeling. Specifically, we contribute a standardized terminology and ontology for blended modeling, along with a methodology for creating blended modeling environments. These concepts were developed through collaboration between academic and industrial partners, who aligned on the motivations and benefits of this approach. The insights gained from this project are not only relevant to blended MDE but also can be applied to traditional MDE practices.

Abstract Large-scale systems development commonly faces the challenge of managing relevant knowledge between different organizational groups, particularly in increasingly agile contexts. Here, there is a conflict between coordination and group autonomy, and it is challenging to determine what necessary coordination information must be shared by what teams or groups, and what can be left to local team management. We introduce a way to manage this complexity using a modeling framework based on two core concepts: methodological islands (i.e., groups using different development methods than the surrounding organization) and boundary objects (i.e., artifacts that create a common understanding across team borders). However, we found that companies often lack a systematic way of assessing coordination issues and the use of boundary objects between methodological islands. As part of an iterative design science study, we have addressed this gap by producing a modeling framework (BOMI: Boundary Objects and Methodological Islands) to better capture and analyze coordination and knowledge management in practice. This framework includes a metamodel, as well as a list of bad smells over this metamodel that can be leveraged to detect inter-team coordination issues. The framework also includes a methodology to suggest concrete modeling steps and broader guidelines to help apply the approach successfully in practice. We have developed Eclipse-based tool support for the BOMI method, allowing for both graphical and textual model creation, and including an implementation of views over BOMI instance models in order to manage model complexity. We have evaluated these artifacts iteratively together with five large-scale companies developing complex systems. In this work, we describe the BOMI framework and its iterative evaluation in several real cases, reporting on lessons learned and identifying future work. We have produced a matured and stable modeling framework which facilitates understanding and reflection over complex organizational configurations, communication, governance, and coordination of knowledge artifacts in large-scale agile system development.

Research on model-based engineering (MBE) has occasionally touched upon the relationship between development processes and concrete MBE practices. However, the alignment of these elements has rarely been the central focus of these studies. As a result, important questions regarding the alignment of MBE and development processes, as well as the impact of development processes on the utilization and success of MBE, have remained unanswered. To address this research gap, we conducted a multiple-case study involving 14 individuals from nine different companies, conducting a total of 12 interviews. Building upon seven propositions derived from existing literature, our investigation sought to understand how MBE is aligned with the development process and explore the application of MBE in this context. Additionally, we identified challenges and needs in this area. Our findings challenge some previously reported results, such as the perceived conflicts between agile development processes and MBE. Furthermore, we unearthed previously unreported issues, like the importance of considering the perspectives of tool vendors in MBE discussions. Overall, this paper makes a significant contribution by providing a comprehensive and up-to-date perspective on how MBE is integrated into development processes, along with an examination of the social and organizational aspects inherent to these processes. Editor’s note: Open Science material was validated by the Journal of Systems and Software Open Science Board.

In model-driven engineering, developing a textual domain-specific language (DSL) involves constructing a meta-model, which defines an underlying abstract syntax, and a grammar, which defines the concrete syntax for the DSL. We consider a scenario in which the meta-model is manually maintained, which is common in various contexts, such as blended modeling, in which several concrete syntaxes co-exist in parallel. Language workbenches such as Xtext support such a scenario, but require the grammar to be manually co-evolved, which is laborious and error-prone. In this paper, we present GrammarTransformer, an approach for transforming generated grammars in the context of meta-model-based language evolution. To reduce the effort for language engineers during rapid prototyping and language evolution, it offers a catalog of configurable grammar transformation rules. Once configured, these rules can be automatically applied and re-applied after future evolution steps, greatly reducing redundant manual effort. In addition, some of the supported transformations can globally change the style of concrete syntax elements, further significantly reducing the effort for manual transformations. The grammar transformation rules were extracted from a comparison of generated and existing, expert-created grammars, based on seven available DSLs. An evaluation based on the seven languages shows GrammarTransformer’s ability to modify Xtext-generated grammars in a way that agrees with manual changes performed by an expert and to support language evolution in an efficient way, with only a minimal need to change existing configurations over time.

When generating textual editors for large and highly structured meta-models, it is possible to extend Xtext’s generator capabilities and the default implementations it provides. These extensions provide additional features such as formatters and more precise scoping for cross-references. However, for large metamodels in particular, the realization of such extensions typically is a time-consuming, awkward, and repetitive task. For some of these tasks, we motivate, present, and discuss in this position paper automatic solutions that exploit the structure of the underlying metamodel. Furthermore, we demonstrate how we used them in the development of a textual editor for EATXT, a textual concrete syntax for the automotive architecture description language EAST-ADL. This work in progress contributes to our larger goal of building a language workbench for blended modelling.

Xtext is a well-known domain-specific language design framework and technology. It automatically generates a textual grammar for a language, given a meta-model specified in Ecore. These generated textual grammars are typically not user-friendly. Python-style languages are popular among developers for their usability and conciseness. We aim to propose a systematic approach to transform a DSL with a generated grammar into a Python-style DSL. To achieve this, we analyze the problems of grammars generated with Xtext, based on a lightweight architecture description language. In response to these problems, we propose a general semi-automated grammar adaptation approach. We apply the approach to two other DSLs to validate the generalization of the approach. We also discuss the limitations of this approach and prospects for the future.

Cyber-Physical Production Systems (CPPSs) are envisioned as next-generation adaptive production systems combining modern production techniques with the latest information technology. A CPPS creates a complex environment between different domains (mechanical, electrical, software engineering), requiring multidisciplinary solutions to tackle growing complexity issues and reduce (maintenance) effort. Software plays an increasingly important role in assuring an effective and efficient operation of CPPSs. However, software engineering methods applied for CPPSs seem to lag behind modern software engineering methods, where tremendous progress has been made in the last years. We initiated the Software Engineering in Cyber-Physical Production Systems Workshop (SECPPS-WS) to analyze and overcome this gap. After two instances with mostly academic participants, we conducted a full-day workshop with nine industry representatives from eight companies that develop and maintain CPPSs. Each industry representative presented their current work and challenges. We collected these challenges and condensed a categorized list of challenges backed by industry statements and literature. This paper presents the resulting list and pointers to (partial) solutions to offer guidance for academia and identify promising research opportunities in this area.

Abstract Distributed, software-intensive systems (e.g., in the automotive sector) must fulfill communication requirements under hard real-time constraints. The requirements have to be documented and validated carefully using a systematic requirements engineering (RE) approach, for example, by applying scenario-based requirements notations. The resources of the execution platforms and their properties (e.g., CPU frequency or bus throughput) induce effects on the timing behavior, which may lead to violations of the real-time requirements. Nowadays, the platform properties and their induced timing effects are verified against the real-time requirements by means of timing analysis techniques mostly implemented in commercial-off-the-shelf tools. However, such timing analyses are conducted in late development phases since they rely on artifacts produced during these phases (e.g., the platform-specific code). In order to enable early timing analyses already during RE, we extend a scenario-based requirements notation with allocation means to platform models and define operational semantics for the purpose of simulation-based, platform-aware timing analyses. We illustrate and evaluate the approach with an automotive software-intensive system.

Security protocols ensure secure communication between and within systems such as internet services, factories, and smartphones. As evidenced by numerous successful attacks against popular protocols such as TLS, designing protocols securely is a tedious and error-prone task. Model checkers greatly aid protocol verification, yet any single model checker is oftentimes insufficient to check a protocol's security in full. Instead, engineers are forced to maintain multiple overlapping and hopefully non-contradicting and non-diverging specifications, one per model-checking tool---an error-prone task.

Traceability, a classic requirements engineering topic, is increasingly used in the context of model-based engineering. However, researchers and practitioners lack a concise terminology to discuss aspects of requirements traceability in situations in which engineers heavily rely on models and model-based engineering. While others have previously surveyed the domain, no one has so far provided a clear, unambiguous set of terms that can be used to discuss traceability in such a context. We therefore set out to cut a path through the jungle of terminology for model-based traceability, ground it in established terminology from requirements engineering, and derive an unambiguous set of relevant terms. We also map the terminology used in existing primary and secondary studies to our taxonomy to show differences and commonalities. The contribution of this paper is thus a terminology for model-based traceability that allows requirements engineers and engineers working with models to unambiguously discuss their joint traceability efforts.

Distributed, software-intensive systems such as automotive electronic control units have to handle various situations employing message-based coordination. The growing complexity of such systems results in an increasing difficulty to achieve a high quality of the systemsâ requirements specifications. Scenario-based requirements engineering addresses the message-based coordination of such systems and enables, if underpinned with formal modeling languages, automatic analyses for ensuring the quality of requirements specifications. However, formal requirements modeling languages require high expertise of the requirements engineers and many manual iterations until specifications reach high quality. Patterns provide a constructive means for assembling high-quality solutions by applying reusable and established building blocks. Thus, they also gained momentum in requirements documentation. In order to support the requirements engineers in the systematic conception of formal , scenario-based requirements specification models, we hence introduce in this paper a requirement pattern catalog for a requirements modeling language. We illustrate and discuss the application of the requirement patterns with an example of requirements for an automotive electronic control unit.

Original equipment manufacturers (OEMs) build mechatronic systems using components from several suppliers in industry sectors like automation. The suppliers provide geometrical information via the standardized exchange format STEP, such that the OEM is able to virtually layout the overall system. Beyond the geometrical information, the OEM needs additional technical information for his development tasks. For that reason, STEP provides an extension mechanism for extending and tailoring STEP to project-specific needs. However, extending STEP moreover requires extending several capabilities of all involved tools, causing high development effort. This effort prevents the project-specific utilization of the STEP extension mechanism and forces the organizations to use awkward workarounds. In order to cope with this problem, we present a model-driven approach enabling the flexible specification of STEP extensions and particularly the automatic derivation of the required further capabilities for two involved tools. We illustrate and evaluate the approach with an automation production system example.

Abstract The development of software‐intensive technical systems involves several engineering disciplines like mechanical, electrical, control, and particularly software engineering. Model‐based Systems Engineering (MBSE) coordinates these disciplines throughout the development by means of discipline‐spanning processes and a system model. Such a system model provides a common understanding of the system under development and serves as a starting point for the discipline‐specific development. An integral part of MBSE is the requirements engineering on the system level. However, these requirements need to be refined for the discipline‐specific development to start, for example, into specific requirements for the embedded software. Because existing MBSE approaches lack support for this refinement step, we conceived in previous work a systematic transition from MBSE to model‐based software requirements engineering. We automated the steps of the transition where possible, in order to avoid error‐prone and time‐consuming manual tasks. In this paper, we extend this approach with support for subsequent process iterations and provide an algorithm for the automated steps. We illustrate the approach and perform a case study with an example of an automotive embedded system. Copyright © 2016 John Wiley & Sons, Ltd.

The development of software-intensive technical systems (e.g., within the automotive industry) involves several engineering disciplines like mechanical, electrical, control, and software engineering. Model-based Systems Engineering (MBSE) coordinates these disciplines throughout the development by means of discipline-spanning processes and system models. Such a system model provides a common understanding of the system under development and serves as a starting point for the discipline-specific development. An integral part of MBSE is the requirements engineering on the system level. However, for the discipline-specific development to start, these requirements need to be refined, e.g., into specific requirements for the embedded software. Since existing MBSE approaches lack support for this refinement step, we conceived a systematic transition from MBSE to model-based software requirements engineering, which we present in this paper. We automated the steps of the transition where possible, in order to avoid error-prone and time-consuming manual tasks. We illustrate the approach with an example of an automotive embedded system.

The growing complexity of today's software-intensive systems results in an increased size of requirements specifications, which are typically documented by means of natural language (NL). Large NL requirements specifications are prone to contain defects (e.g., contradictions), and the inherent ambiguity of NL impedes automatic techniques to support the requirements engineer. In order to cope with this problem, we conceived a requirements documentation approach implemented in the tool ReqPat. Using a controlled NL, it supports an efficient requirements documentation, an automatic requirements validation, and an automatic transition to models-while still keeping the requirements understandable for all stakeholders.