Domain-specific modelling languages defined by extending or constraining the Unified Modelling Language (UML) through the profiling mechanism have historically relied on graphical notations to maximise human understanding and facilitate communication among stakeholders. Other notations, such as text-, form-, or table-based are, however, often preferred for specific modelling purposes, due to the nature of a specific domain or the available tooling, or for personal preference. Currently, the state of the art support for UML-based languages provides an almost completely detached, or even entirely mutually exclusive, use of graphical and textual modelling. This becomes inadequate when dealing with the development of modern systems carried out by heterogeneous stakeholders. Our intuition is that a modelling framework based on seamless blended multi-notations can disclose several benefits, among which: flexible separation of concerns, multi-view modelling based on multiple notations, convenient text-based editing operations (inside and outside the modelling environment), and eventually faster modelling activities. In this paper we report on: (i) a proof-of-concept implementation of a framework for UML and profiles modelling using blended textual and graphical notations, and (ii) an experiment on the framework, which eventually shows that blended multi-notation modelling performs better than standard single-notation modelling.
Domain-specific modelling languages, in particular those described in terms of UML profiles, use graphical notations to maximise human understanding and facilitate communication among stakeholders. Nevertheless, textual notations are preferred for specific purposes, due to the nature of a specific domain, or for personal preference. The mutually exclusive use of graphical or textual modelling is not sufficient for the development of complex systems developed by large heterogeneous teams. We envision a modern modelling framework supporting seamless hybrid graphical and textual modelling. Such a framework would provide several benefits, among which: flexible separation of concerns, multi-view modelling based on multiple notations, convenient text-based editing operations, and text-based model editing outside the modelling environment, and faster modelling activities. In this paper we describe our work towards such a framework for UML and profiles. The uniqueness is that both graphical and textual modelling are done on a common persistent model resource, thus dramatically reducing the need for synchronisation among the two notations.
High-performance embedded computing is developing rapidly since applications in most domains require a large and increasing amount of computing power. On the hardware side, this requirement is met by the introduction of heterogeneous systems, with highly parallel accelerators that are designed to take care of the computation-heavy parts of an application. There is today a plethora of accelerator architectures, including GPUs, many-cores, FPGAs, and domain-specific architectures such as AI accelerators. They all have their own programming models, which are typically complex, low-level, and involve explicit parallelism. This yields error-prone software that puts the functional safety at risk, unacceptable for safety-critical embedded applications. In this position paper we argue that high-level executable modelling languages tailored for parallel computing can help in the software design for high performance embedded applications. In particular, we consider the data-parallel model to be a suitable candidate, since it allows very abstract parallel algorithm specifications free from race conditions. Moreover, we promote the Action Language for fUML (and thereby fUML) as suitable host language.
The Black Pearl is a custom made autonomous underwater vehicle developed at Mälardalen University, Sweden. It is built in a modular fashion, including its mechanics, electronics and software. After a successful participation at the RoboSub competition in 2012 and winning the prize for best craftsmanship, this year we made minor improvements to the hardware, while the focus of the robot's evolution shifted to the software part. In this paper we give an overview of how the Black Pearl is built, both from the hardware and software point of view.
Product line architectures play a vital role in the automotive industry in supporting cross-product development involving several hardware and software variation points for different vehicle variants. The effective resolution of multiple variation points for the generation of valid variants is complex, especially when dealing with both software and hardware components implying timing constraints, simultaneously. EAST-ADL is a well-known domain-specific modelling language supporting cross-product development using different levels of abstraction. Furthermore, it offers timing extensions to perform system and component-level timing verification. In this article, we propose an EAST-ADL-compliant and timing-Aware variability resolution approach to generate valid product variants effectively. The method relies on existing EAST-ADL product line architecture for system modelling, where several variation points at different levels of abstraction are identified. We propose a variability resolution algorithm where several configuration decisions, starting from the topmost vehicle level down to the design level, are incor-porated for seamless variability resolution. Furthermore, timing decisions based on analysis and design prototypes are provided to generate variant-specific timing constraints. The approach is validated on the car wiper use case provided by our industrial partner, Volvo, an international original equipment manufacturer in the automotive domain. In the use case, three product variants comprising a full system model with associated timing constraints are generated successfully. The results show the feasibility of the proposed approach and indicate its effectiveness in managing timing-Aware product variants.
Design and development of domain-specific modeling languages are crucial activities in model-driven engineering. At the core of these languages we find metamodels, i.e. descriptions of concepts and rules to combine those concepts in order to build valid models. Both in research and practice, metamodels are created and updated more or less frequently to meet certain business requirements. Although there exist several workbenches for metamodeling, some textual (e.g., JetBrains MPS) and some graphical (e.g., Eclipse Modeling Framework - EMF), it still remains a sensitive and complex task, where several stakeholders with different skill-sets need to be able to properly exchange ideas and reach agreements.To maximize the throughput of metamodeling activities, in this paper we propose a Blended Metamodeling Framework (BMF) that enables the development of metamodels through both graphical and textual (natural language) notations interchangeably, by utilizing the concepts of Natural Language Processing and model-driven engineering. The feasibility of the framework is demonstrated via the Portable test and Stimulus Standard (PSS) use case, where a DSML is developed by seamlessly blending the use of textual (natural language) and graphical (EMF) notations. Moreover, for demonstration purposes we also generate a domain-specific language structure reflecting the metamodel in JetBrains MPS.
EAST-ADL is a domain-specific modelling language for the design and analysis of vehicular embedded systems. Seamless modelling through multiple concrete syntaxes for the same language, known as blended modelling, offers enhanced modelling flexibility to boost collaboration, lower modelling time, and maximise the productivity of multiple diverse stakeholders involved in the development of complex systems, such as those in the automotive domain. Together with our industrial partner, which is one of the leading contributors to the definition of EAST-ADL and one of its main end-users, we provided prototypical blended modelling features for EAST-ADL. In this article, we report on our language engineering work towards the provision of blended modelling for EAST-ADL to support seamless graphical and textual notations. Notably, for selected portions of the EAST-ADL language (i.e., timing and variability packages), we introduce ad-hoc textual concrete syntaxes to represent the language's abstract syntax in alternative textual notations, preserving the language's semantics. Furthermore, we propose a full-fledged runtime synchronisation mechanism, based on the standard EAXML schema format, to achieve seamless change propagation across the two notations. As EAXML serves as a central synchronisation point, the proposed blended modelling approach is workable with most existing EAST-ADL tools. The feasibility of the proposed approach is demonstrated through a car wiper use case from our industrial partner - Volvo. Results indicate that the proposed blended modelling approach is effective and can be applied to other EAST-ADL packages and supporting tools.
Blended modeling is an emerging trend in Model-Driven Engineering for complex systems. It enables the modeling of diverse system-related aspects through multiple editing notations seamlessly, interchangeably, and collaboratively. Blended modeling is expected to significantly improve productivity and user-experience for multiple stakeholders. Case-specific solutions providing blended modeling, to a certain extent, for domain specific languages have been provided in the last few years. Nevertheless, a generic and language-agnostic full-fledged blended modeling framework has not been proposed yet.
In this paper, we propose a comprehensive and generic blended modeling framework prototype that provides automated mechanism to generate graphical and textual notations from a given domain-specific modeling language. Moreover, it offers a flexible editor to get expert’s feedback on the mapping between graphical and textual notations. The proposed prototype is validated through a proof-of-concept on the Portable test and Stimulus Standard use-case. Our initial results indicate that the proposed framework is capable of being applied in different application scenarios and dealing with multiple domain-specific modeling standards.
We present what is destined to become the de-facto standard for hardware platforms for next generation cyber-physical systems. Heterogeneous System Architecture (HSA) is an initiative to harmonize the industry around a common architecture which is easier to program and is an open standard defining the key interfaces for parallel computation. Since HSA is supported by virtually all major players in the silicon market we can conjecture that HSA, with its capabilities and quirks, will highly influence both the hardware and software for next generation cyber-physical systems. In this paper we describe HSA and discuss how its nature will influence architectures of system software and application software. Specifically, we believe that the system software needs to both leverage the hyperparallel nature of HSA while providing predictable and efficient resource allocation to different parallel activities. The application software, on the other hand, should be isolated from the complexity of the hardware architecture but yet be able to efficiently use the full potential of the hyperparallel nature of HSA.
The growing enactment of Global Software Engineering in industry has triggered educational institutions to perceive the importance of preparing students for distributed software development. During the last twelve years we have disclosed advantages and pitfalls of GSE to our students through our Distributed Software Development course. After running the projects according to the iterative process model for eleven years, we decided to shift to an agile development model, SCRUM. This decision was due to the growing industrial adoption of agile methods, but more importantly to increase proactiveness, sense of responsibility, and to balance the workload among the project team members. In this paper we describe the process and outcomes of our first attempt at introducing SCRUM in our distributed course.
The organizational shift from local to global settings in many software development initiatives has triggered the need for entailing it when educating the future software engineers. Several educational institutions have embraced this need and started collaborating for the provision of global software engineering courses. The rather complex nature of such courses results in a wider range of risks, in comparison to standard software engineering courses, that arise in different dimensions, ranging from course- to result-related, and for different reasons. In this work we provide an assessment of such a variety of risks as well as their causes, and we give a hint on how they may affect each other based on our 10-year-long experience with a tightly integrated GSD course.
Teaching Distributed Software Development with real distributed settings is a challenging and rewarding task. Distributed courses are idiosyncratically more challenging than standard local courses.We have experienced this during our distributed course, which has been run for 14 consecutive years. In this paper, we present and analyze the emerging diversities specific to distributed project-based courses. We base our arguments on our experience and we exploit a three-layered distributed course model, which we use to analyze several course elements throughout the 14-years lifetime of our distributed project-based course. In particular, we focus on the changes that the course underwent throughout the years, combining findings obtained from the analyzed data with our own teaching perceptions. Additionally, we propose insights on how to manage the various diversity aspects.
This paper introduces a novel model-driven methodology for the software development of real-time distributed vehicular embedded systems on single- and multi-core platforms. The proposed methodology discloses the opportunity of improving the cost-efficiency of the development process by providing automated support to identify viable design solutions with respect to selected non-functional requirements. To this end, it leverages the interplay of modelling languages for the vehicular domain whose integration is achieved by a suite of model transformations. An instantiation of the methodology is discussed for timing requirements, which are among the most critical ones for vehicular systems. To support the design of temporally correct systems, a cooperation between EAST-ADL and the Rubus Component Model is opportunely built-up by means of model transformations, enabling timing-aware design and model-based timing analysis of the system. The applicability of the methodology is demonstrated as proof of concepts on industrial use cases performed in cooperation with our industrial partners.
In 2014, a new software development approach started to get a foothold: low-code development. Already from its early days, practitioners in software engineering have been showing a rapidly growing interest in low-code development. In 2021 only, the revenue of low-code development technologies reached 13.8 billion USD. Moreover, the business success of low-code development has been sided by a growing interest from the software engineering research community. The model-driven engineering community has shown a particular interest in low-code development due to certain similarities between the two. In this article, we report on the planning, execution, and results of a multi-vocal systematic review on low-code development, with special focus to its relation to model-driven engineering. The review is intended to provide a structured and comprehensive snapshot of low-code development in its peak of inflated expectations technology adoption phase. From an initial set of potentially relevant 720 peer-reviewed publications and 199 grey literature sources, we selected 58 primary studies, which we analysed according to a meticulous data extraction, analysis, and synthesis process. Based on our results, we tend to frame low-code development as a set of methods and/or tools in the context of a broader methodology, often being identified as model-driven engineering.
The adoption of model-driven engineering in the automotive domain resulted in the standardization of a layered architectural description language, namely EAST-ADL, which provides means for enforcing abstraction and separation of concerns, but no support for automation among its abstraction levels. This support is particularly helpful when manual transitions among levels are tedious and error-prone. This is the case of design and implementation levels. Certain fundamental analyses (e.g., timing), which have a significant impact on design decisions, give precise results only if performed on implementation level models, which are currently created manually by the developer. Dealing with complex systems, this task becomes soon overwhelming leading to the creation of a subset of models based on the developers experience; relevant implementation level models may therefore be missed. In this work, we describe means for automation between EAST-ADL design and implementation levels to anticipate end-to-end delay analysis at design level for driving design decisions.
Agile development aims at switching the focus from processes to interactions between stakeholders, from heavy to minimalistic documentation, from contract negotiation and detailed plans to customer collaboration and prompt reaction to changes. With these premises, requirements traceability may appear to be an overly exigent activity, with little or no return-of-investment. However, since testing remains crucial even when going agile, the developers need to identify at a glance what to test and how to test it. That is why, even though requirements traceability has historically faced a firm resistance from the agile community, it can provide several benefits when promoting precise alignment of requirements with testing. This paper reports on our experience in promoting traceability of requirements and testing in the data communications for mission-critical systems in an industrial Scrum project. We define a semi-automated requirements tracing mechanism which coordinates four traceability techniques. We evaluate the solution by applying it to an industrial project aiming at enhancing the existing Virtual Router Redundancy Protocol by adding Simple Network Management Protocol support.
The size, complexity and heterogeneity of vehicular software systems has been constantly increasing. As a result, there is a growing consensus on the need to leverage modelbased techniques for automating, thus taming, error-proneness of tedious engineering tasks. Our methodology employs a one-tomany model transformation for generating a set of implementation models from a single design model. Then, it evaluates the appropriateness of each generated model by means of modelbased timing analysis. In this ongoing work, we discuss an enhancement of our methodology where model-based timing analysis is extended for running on a single model with uncertainty.
Models and model transformations, the two core constituents of Model-Driven Engineering, aid in software development by automating, thus taming, error-proneness of tedious engineering activities. In most cases, the result of these automated activities is an overwhelming amount of information. This is the case of one-to-many model transformations that, e.g. in designspace exploration, can potentially generate a massive amount of candidate models (i.e., solution space) from one single model. In our scenario, from one design model we generate a set of possible implementation models on which timing analysis is run. The aim is to find the best model from a timing perspective. However, multiple implementation models can have equally good analysis results. Therefore, the engineer is expected to investigate the solution space for making a final decision, using criteria which fall outside the analysis criteria themselves. Since candidate models can be many and very similar to each other, manually finding differences and commonalities is an impractical and errorprone task. In order to provide the engineer with an expressive representation of models commonalities and differences, we propose the use of modelling with uncertainty. We achieve this by elevating the solution space to a first-class status, adopting a compact notation capable of representing the solution space by means of a single model with uncertainty. Commonalities and differences are thus represented by means of uncertainty points for the engineer to easily grasp them and consistently make her decision without manually inspecting each model individually.
Developing distributed real-time systems is a complex task that has historically entailed specialized handcraft. In this paper, we propose a retrospective on the (r)evolutionary changes that led to the transition from low-level programming to industrial full-fledged model-based development embodied by the Rubus Component Model and its tool-ecosystem. We focus on the needs, challenges, and solutions of a 15-year-long evolution journey of a software development approach that has gone from low-level and manual programming to a highly automated environment offering modeling, analysis, and development of vehicular software systems with multi-criticality for deployment on single- and multi-core platforms.
According to the Model-Driven Engineering paradigm, one of the entry requirements when realising a seamless tool chain for the development of software is the definition of metamodels, to regulate the specification of models, and model transformations, for automating manipulations of models. In this context, we present a metamodel definition for the Rubus Component Model, an industrial solution used for the development of vehicular embedded systems. The metamodel includes the definition of structural elements as well as elements for describing timing information. In order to show how, using Model-Driven Engineering, the integration between different modelling levels can be automated, we present a model-to-model transformation between models conforming to EAST-ADL and models described by means of the Rubus Component Model. To validate our solution, we exploit a set of industrial automotive applications to show the applicability of both the Rubus Component Model metamodel and the model transformation.
There are various methodologies that support the extraction of timing models from EAST-ADL design-level models during the development of vehicular embedded software systems. These timing models are used to predict timing behavior of the systems by performing end-to-end timing analysis. This paper presents, for the first time, a comparative evaluation of three methodologies. We present an evaluation framework that consists of several evaluation features. Using the framework, we compare and evaluate the methodologies against each feature. Eventually, the evaluation results can be used as guidelines for the selection of the most suitable methodology with respect to the end-to-end timing behavior of a given vehicular embedded application.
Software in modern vehicles consists of multi-criticality functions, where a function can be safety-critical with stringent real-time requirements, less critical from the vehicle operation perspective, but still with real-time requirements, or not critical at all. Next-generation autonomous vehicles will require higher computational power to run multi-criticality functions and such a power can only be provided by parallel computing platforms such as multi-core architectures. However, current model-based software development solutions and related modelling languages have not been designed to effectively deal with challenges specific of multi-core, such as core-interdependency and controlled allocation of software to hardware. In this paper, we report on the evolution of the Rubus Component Model for the modelling, analysis, and development of vehicular software systems with multi-criticality for deployment on multi-core platforms. Our goal is to provide a lightweight and technology-preserving transition from model-based software development for single-core to multi-core. This is achieved by evolving the Rubus Component Model to capture explicit concepts for multi-core and parallel hardware and for expressing variable criticality of software functions. The paper illustrates these contributions through an industrial application in the vehicular domain.
The vehicular industry has exploited model-based engineering for design, analysis, and development of single-core vehicular systems. Next generation of autonomous vehicles will require higher computational power, which can only be provided by parallel computing platforms such as multi-core electronic control units. Current model-based software development solutions and related modelling languages, originally conceived for single-core, cannot effectively deal with multi-core specific challenges, such as core-interdependency and allocation of software to hardware. In this paper, we propose an extension to the Rubus Component Model, central to the Rubus model-based approach, for the modelling, analysis, and development of vehicular systems on multi-core. Our goal is to provide a lightweight transition of a model-based software development approach from single-core to multi-core, without disrupting the current technological assets in the vehicular domain.
Modeling languages and frameworks have been the key technology for advancing model-driven engineering (MDE) methods and tools. Many industrial and research tools have been realized and are used across many domains. Hence, we think it is the right time to define what should be the future of modeling technologies, especially the requirements for the next generation of modeling frameworks and languages.
Although Model-Based Software Engineering (MBE) is a widely accepted Software Engineering (SE) discipline, no agreed upon core set of concepts and practices (i.e., a Body of Knowledge) has been defined for it yet. With the goals of characterizing the contents of the MBE discipline, promoting a global consistent view of it, clarifying its scope with regard to other SE disciplines, and defining a foundation for the development of educational curricula on MBE, this paper proposes the contents for a Body of Knowledge for MBE. We also describe the methodology that we have used to come up with the proposed list of contents, as well as the results of a survey study that we conducted to sound out the opinion of the community on the importance of the proposed topics and their level of coverage in existing SE curricula.
Mobile robots operate in various environments (e.g. aquatic, aerial, or terrestrial), they come in many diverse shapes and they are increasingly becoming parts of our lives. The successful engineering of mobile robotics systems demands the interdisciplinary collaboration of experts from different domains, such as mechanical and electrical engineering, artificial intelligence, and systems engineering. Research and industry have tried to tackle this heterogeneity by proposing a multitude of model-driven solutions to engineer the software of mobile robotics systems. However, there is no systematic study of the state of the art in model-driven engineering (MDE) for mobile robotics systems that could guide research or practitioners in finding model-driven solutions and tools to efficiently engineer mobile robotics systems. The paper is contributing to this direction by providing a map of software engineering research in MDE that investigates (1) which types of robots are supported by existing MDE approaches, (2) the types and characteristics of MRSs that are engineered using MDE approaches, (3) a description of how MDE approaches support the engineering of MRSs, (4) how existing MDE approaches are validated, and (5) how tools support existing MDE approaches. We also provide a replication package to assess, extend, and/or replicate the study. The results of this work and the highlighted challenges can guide researchers and practitioners from robotics and software engineering through the research landscape.
Context: Teaching global software engineering is continuously evolving and improving to prepare future software engineers adequately. Geographically distributed work in project-oriented software development courses is both demanding and rewarding for student teams, who are susceptible to various risks stemming from different internal and external factors, being the sources of stress and impacting team performance. Objective: In this paper, we analyze the resilience of teams of students working in a geographically fully distributed setting. Resilience is analyzed in relation to two representative stress factors: non-contributing team members and changes to customer project requirements. We also reason on team collaboration patterns and analyze potential dependencies among these collaboration patterns, team resilience and stress factors. Method: We conduct a longitudinal case-study over five years on our Distributed Software Development (DSD) course. Based on empirical data, we study team resilience to two stress factors by observing their impact on process and product quality aspects of team performance. The same performance aspects are studied for identified collaboration patterns, and bidirectional influence between patterns and resilience is investigated. Results: Teams with up to two non-contributing members experience graceful degradation of performance indicators. A large number of non-contributing students almost guarantees the occurrence of educationally undesirable collaboration patterns. Exposed to requirements change stress, less resilient teams tend to focus on delivering the functional product rather than retaining a proper development process. Conclusions: Practical recommendations to be applied in contexts similar to our case have been provided at the end of the study. They include suggestions to mitigate the sources of stress, for example, by careful planning the team organization and balancing the number of regular and exchange students, or by discussing the issue of changing requirements with the external customers before the start of the project.
Distributed Software Development course is a joint project-based course involving three universities, from Croatia, Sweden and Italy, running each year since 2003. Distributed student teams work on all phases of a complex software engineering project, solving several challenges of working in a global environment, thus obtaining a valuable experience for their future careers. The course is very well received
With the increasing adoption of Model-Driven Engineering (MDE) the support of distributed development and hence model versioning has become a necessity. MDE research investigations targeting (meta-)model versioning, conflict management, and model co-evolution have progressively recognized the importance of tackling the problem at higher abstraction level and a number of solving techniques have been proposed. However, in general existing mechanisms hit the wall of semantics, i.e. when not only syntax is involved in the manipulations the chances for providing precision and automation are remarkably reduced. In this paper we illustrate a novel version management proposal that leverages on the separation between linguistic and ontological aspects involved in a (meta-)modelling activity. In particular, we revisit the main versioning tasks in terms of the mentioned separation. The aim is to maximize the amount of versioning problems that can be automatically addressed while leaving the ones intertwined with domain-specific semantics to be solved separately, possibly by means of semi-automatic techniques and additional precision.
Model-Driven Engineering has been widely recognised as a powerful paradigm for shifting the focus of software development from codingto modelling in order to cope with the rising complexity of modern systems. Models become the main artefacts in the development process and therefore undergo evolutions performed in different ways until the final implementation is produced. Moreover, modelling languages are expectedto evolve too and such evolutions have to be taken into account when dealing with model versioning. Since consistency between models and related metamodels is one of the pillars on which model-driven engineering relies, evolution of models and metamodels cannot be considered as independentevents in a model versioning system.This article exploits model comparison and merging mechanisms toprovide a solution to the issues related to model versioning when considering metamodel and model manipulations as concurrent and even misaligned. A scenario-based description of the challenges arising from versioning of models is given and a running example is exploited to demonstrate the proposed solutions.
Multi-view modelling is a widely accepted technique to reduce the complexity in the development of modern software systems. It allows developers to focus on a narrowed portion of the specification dealing with a selected aspect of the problem. However, multi-view modelling support discloses a number of issues mainly due to consistency management, expressiveness, and customization needs. A possible solution to alleviate those problems is to adopt a hybrid solution for multi-view modelling based on an arbitrary number of custom views defined on top of an underlying modelling language. In this way it is possible to benefit from the consistency by-construction granted by well-formed views while at the same time providing malleable perspectives through which the system under development can be specified. In this respect, this paper presents an approach for supporting synchronization mechanism based on model differences in hybrid multi-view modelling. Model differences allow to focus only on the manipulations operated by the user in a particular view, and to propagate them to the other views in a incremental way thus reducing the overhead of a complete recomputation of modified models.
Model-Driven Engineering aims at shifting the focus of software development from coding to modelling in order to reduce the complexity of realizing nowadays applications. In this respect, models are expected to evolve due to refinements, improvements, bug fixes, and so forth. Because of the same reasons, also modelling languages (i.e. metamodels) are expected to be changed, even though at a different speed if compared to models. The relevant corpus of research grown up in the latest years and dealing with both these problems considers them as separate events; however, in normal practice not all the models are migrated instantaneously due to a metamodel adaptation, rather the co-adaptation is required when commits are attempted from a local workspace to the model repository, which can demand for different management policies. This paper illustrates the challenges arising in coping with concurrent metamodel and model versioning. In particular, it details a set of desired behaviours among which the user would usually select the appropriate management for the scenario into consideration together with entailed problems. Moreover, the work proposes corresponding solutions and discusses open issues.
As software complexity increases in embedded systems domain, component-based development becomes increasingly attractive. A main challenge in this approach is however to analyze the system's extra-functional properties (such as timing properties, or resource requirements), an important step in a development of embedded systems. Analysis of such properties are computational and time consuming, and often difficult. For this reason reuse of the results of the analysis is as important as the reuse of the component itself, especially in case of modifications of the context in which the component is used. This paper presents concepts and mechanisms that allow to automatically discover whether a property value is still valid when related components evolve: a value context language is proposed to formally define the validity conditions and identify possible threats
Modern software systems require advanced design support capable of mastering rising complexity, as well as of automating as many development tasks as possible. Model- Driven Engineering (MDE) is earning consideration as a solid response to those challenges on account of its support for abstraction and domain specialisation. However, MDE adoption often shatters industrial practice because its novelty opposes the need to preserve vast legacy and to not disband the skills matured in pre-MDE or alternative development solutions. This work presents the CHESS tool environment, a novel approach for cross-domain modelling of industrial complex systems. It leverages on UML profiling and separation of concerns realised through the specification of well-defined design views, each of which addresses a particular aspect of the problem. In this way, extra-functional, functional, and deployment descriptions of the system can be given in a focused manner, avoiding issues pertaining to distinct concerns to interfere with one another.
Over the years, a number of approaches have been proposed on the description of systems and software in terms of multiple views represented by models. This modelling branch, so-called multi-view software and system modelling, praises a differentiated and complex scientific body of knowledge. With this study, we aimed at identifying, classifying, and evaluating existing solutions for multi-view modelling of software and systems. To this end, we conducted a systematic literature review of the existing state of the art related to the topic. More specifically, we selected and analysed 40 research studies among over 8600 entries. We defined a taxonomy for characterising solutions for multi-view modelling and applied it to the selected studies. Lastly, we analysed and discussed the data extracted from the studies. From the analysed data, we made several observations, among which: (i) there is no uniformity nor agreement in the terminology when it comes to multi-view artefact types, (ii) multi-view approaches have not been evaluated in industrial settings and (iii) there is a lack of support for semantic consistency management and the community does not appear to consider this as a priority. The study results provide an exhaustive overview of the state of the art for multi-view software and systems modelling useful for both researchers and practitioners.
Modern embedded systems present an ever increasing complexity and model-driven engineering has been shown to be helpful in mitigating it. In our previous works we exploited the power of model-driven engineering to develop a round-trip approach for aiding the evaluation and assessment of extra-functional properties preservation from models to code. In addition, we showed how the round-trip approach could be employed to evaluate different deployment strategies, and the focus was on homogeneous CPUbased platforms. Due to the fact that the assortment of target-platforms in the embedded domain is inevitably shifting to heterogeneous solutions, our goal is to broaden the scope of the round-trip approach towards mixed CPU-GPU configurations. In this work we focus on the modelling of heterogeneous deployment and the enhancement of the current automatic code generator to synthesize code targeting such heterogeneous configurations.
Models are means for unification and UML was born with the ambition of providing "unified" modelling language and methodology. The myriad of competing proprietary tools, with every tool provider only focusing on its own interests, resulted in the creation of a multitude of similar but still different solutions and "dialects", which clashes with UML's ambition. A glaring example is the appalling number of action languages and code generators defined for UML.With this work we recognise the need of a unified effort towards an open source baseline for getting the best out of UML. More specifically, we contribute by showing how to simplify the transition from the use of programming languages for modelling fine-grained behaviours within models to model-aware action languages in industrial MDE leveraging open source tools. This is achieved by making our solution for the automated translational execution of the Action Language for Foundational UML cooperate with existing UML-based code generators that exploit programming languages for defining action code.
Model-driven engineering can help in mitigating ever-growing complexity of modern software systems. In this sense, the Unified Modelling Language (UML) has gained a thick share in the market of modelling languages adopted in industry. Nevertheless, the generality of UML can make it hard to build complete code generators, simulators, model-based analysis or testing tools without setting variability in the semantics of the language. To tailor semantics variability the notion of semantic variation point has been introduced in UML 2.0. Our research focuses on the semantic variation point that leaves the rules for matching multiplicities of connected instances of components and ports undecided in UML composite structures. In order to allow model analysability, simulation and code generation, this semantics needs to be set. At the same time, leaving the burden of this task to the developers is often overwhelming for complex systems. In this paper we provide a solution for supporting modelling and automatic calculation and generation of explicit interconnections in complex UML composite structures. This is achieved by (i) defining a set of connection patterns, in terms of a UML profile, and related semantic rules for driving the calculation, (ii) providing a generation algorithm to calculate the explicit interconnections.
The complexity of modern systems is continuously growing, thus demanding novel powerful development approaches.In this direction, model-driven and component-based software engineering have reached the status of promising paradigms for the development of complex systems. Moreover, in the embedded domain, their combination is believed to be helpful in handling the ever-increasing complexity of such systems.However, in order for them and their combination to definitively break through at industrial level, code generated from models through model transformations should preserve system properties modelled at design level.
This research work focuses on aiding the preservation of system properties throughout the entire development process across different abstraction levels. Towards this goal, we provide the possibility of analysing and preserving system properties through a development chain constituted of three steps: (i) generation of code from system models, (ii) execution and analysis of generated code, and (iii) back-propagation of analysis results to system models.With the introduction of steps (ii) and (iii), properties that are hard to predict at modelling level are compared with runtime values and this consequently allows the developer to work exclusively at modelling level thus focusing on optimising system models with the help of those values.
Ever increasing complexity of modern software systems demands new powerful development mechanisms. Modeldriven engineering (MDE) can ease the development process through problem abstraction and automated code generation from models. In order for MDE solutions to be trusted, such generation should preserve the system?s properties defined at modelling level, both functional and extra-functional, all the way down to the target code. The outcome of our research is an approach that aids the preservation of system?s properties in MDE of embedded systems. More specifically we provide generation of full source code from design models defined using the CHESS-ML, monitoring of selected extra-functional properties at code level, and back-propagation of observed values to design models. The approach is validated against industrial case-studies in the telecommunications applicative domain.
To manage the rapidly growing complexity of software development, abstraction and automation have been recognised as powerful means. Among the techniques pushing for them, Model-Driven Engineering has gained increasing attention from industry for, amongst others, the possibility to automatically generate code from models. To generate fully executable code, models should describe complex behaviours. While pragmatically this is achieved by employing programming languages for defining actions within models, the abstraction gap between modelling and programming languages can undermine consistency between models and code as well as analysability and reusability of models. In light of this, model-aware action languages should be preferred. This is the case of the Action Language for Foundational UML (ALF). In this paper we provide a solution for the fully automated translational execution of ALF towards C++. Additionally, we give an insight on how to simplify the transition from the use of programming languages for modelling fine-grained behaviours to model-aware action languages in industrial MDE. The solution presented in this paper has been assessed on industrial applications to verify its applicability to complex systems as well as its scalability.
In order for model-driven engineering to succeed, automated code generation from models through model transformations has to guarantee that extra-functional properties modelled at design level are preserved at code level. A full round-trip engineering approach could be needed in order to evaluate quality attributes of the embedded system by code execution monitoring/analysis tools and then provide backpropagation of the target code analysis results to modelling level. In this way, properties that can only be estimated statically are evaluated against runtime values and this consequently allows to optimize the design models for ensuring preservation of analysed extra-functional aspects. This paper presents an approach to support the whole round-trip process starting from the generation of source code for a target platform, passing through the monitoring of selected system quality attributes at code level, and nishing with the back-propagation of measured values to modelling level. The technique is validated against an industrial casestudy in the telecommunications applicative domain.
Model-driven and component-based software engineering have been widely recognized as promising paradigms for development of a wide range of systems. Moreover, in the embedded real-time domain, their combination is believed to be helpful in handling the ever-increasing complexity of such systems design.However, in order for these paradigms and their combination to definitely break through at an industrial level for development of embedded real-time systems, both functional and extra-functional properties need to be addressed at each level of abstraction.
This research focuses on the preservation of extra-functional properties. More specifically, the aim is to provide support for easing such preservation throughout the entire development process at different abstraction levels.The main outcome of the research work is a round-trip engineering approach aiding the preservation of extra-functional properties by providing code generators, supporting monitoring and analysis of code execution, and then enabling back-propagation of the results to modelling level. In this way, properties that can only be roughly estimated statically are evaluated against runtime values and this consequently allows to optimize the design models for ensuring preservation of analysed extra-functional properties.
Moreover, a solution for managing evolution of computational context in which extra-functional properties are defined by means of validity analysis is provided. Such solution introduces a new language for the description of the computational context in which a given property is provided and/or computed by some analysis, enables detection of changes performed to the context description, and analyses the possible impacts on the extra-functional property values based on a precise representation of differences between previous and current version of the model.
Due to the increasing complexity of software systems, model-driven engineering has been introduced to shift the developer's focus from machine-centric program code to human-centric models of the software under development. In model-driven approaches, program code in conventional programming languages (e.g., C++, Java) is commonly generated from models and then compiled or interpreted. Intermediate translation of models to program code raises two fundamental issues: 1) semantic inconsistency and information loss between an executable and its source model, and 2) suboptimality of executables, since compilers are unable to exploit model semantics. These issues are not tolerable in embedded real-time and safety-critical applications. To tame them, we propose direct compilation of models bypassing intermediate translations to conventional programming languages.
Scientists without specific software programming skills are increasingly required to express their problems in terms of software to exploit the computational power of heterogeneous parallel hardware. Producing software for this hardware is very cumbersome for the experienced programmer; for the novice, it is just impracticable. We aim to grant scientists across disciplines access to heterogeneous hardware via a model-driven holistic approach. Via proper software modelling, we suppress the need to write resource-specific software functions and complex offloading and communication code; we will do this by devising a comprehensive modelling language that implicitly underpins multiple execution semantics (sequential, data-/task-parallel). Current code generators neglect model semantics while compilers expect in input too detailed software descriptions; we will devise an innovative semantics-aware model compiler with automatic parallelization. Overall, we aim at giving researchers and practitioners better tools to focus more on the problem to solve than learning how to master complex techniques and languages to describe it in terms of software. Moreover, the learning curve and technological hindrances for beginners approaching hybrid software will be pushed down dramatically.