Development Of Software-intensive Systems Research Articles

Using reactive links to propagate changes across engineering models

AbstractCollaborative model-driven development is a de facto practice to create software-intensive systems in several domains (e.g., aerospace, automotive, and robotics). However, when multiple engineers work concurrently, keeping all model artifacts synchronized and consistent is difficult. This is even harder when the engineering process relies on a myriad of tools and domains (e.g., mechanic, electronic, and software). Existing work tries to solve this issue from different perspectives, such as using trace links between different artifacts or computing change propagation paths. However, these solutions mainly provide additional information to engineers, still requiring manual work for propagating changes. Yet, most modeling tools are limited regarding the traceability between different domains, while also lacking the efficiency and granularity required during the development of software-intensive systems. Motivated by these limitations, in this work, we present a solution based on what we call “reactive links”, which are highly granular trace links that propagate change between property values across models in different domains, managed in different tools. Differently from traditional “passive links”, reactive links automatically propagate changes when engineers modify models, assuring the synchronization and consistency of the artifacts. The feasibility, performance, and flexibility of our solution were evaluated in three practical scenarios, from two partner organizations. Our solution is able to resolve all cases in which change propagation among models were required. We observed a great improvement of efficiency when compared to the same propagation if done manually. The contribution of this work is to enhance the engineering of software-intensive systems by reducing the burden of manually keeping models synchronized and avoiding inconsistencies that potentially can originate from collaborative engineering in a variety of tool from different domains.

Formal Methods in Railways: A Systematic Mapping Study

Formal methods are mathematically based techniques for the rigorous development of software-intensive systems. The railway signaling domain is a field in which formal methods have traditionally been applied, with several success stories. This article reports on a mapping study that surveys the landscape of research on applications of formal methods to the development of railway systems. Following the guidelines of systematic reviews, we identify 328 relevant primary studies, and extract information about their demographics, the characteristics of formal methods used and railway-specific aspects. Our main results are as follows: (i) we identify a total of 328 primary studies relevant to our scope published between 1989 and 2020, of which 44% published during the last 5 years and 24% involved industry; (ii) the majority of studies are evaluated through Examples (41%) and Experience Reports (38%), while full-fledged Case Studies are limited (1.5%); (iii) Model checking is the most commonly adopted technique (47%), followed by simulation (27%) and theorem proving (19.5%); (iv) the dominant languages are UML (18%) and B (15%), while frequently used tools are ProB (9%), NuSMV (8%), and UPPAAL (7%); however, a diverse landscape of languages and tools is employed; (v) the majority of systems are interlocking products (40%), followed by models of high-level control logic (27%); and (vi) most of the studies focus on the Architecture (66%) and Detailed Design (45%) development phases. Based on these findings, we highlight current research gaps and expected actions. In particular, the need to focus on more empirically sound research methods, such as Case Studies and Controlled Experiments, and to lower the degree of abstraction, by applying formal methods and tools to development phases that are closer to software development. Our study contributes with an empirically based perspective on the future of research and practice in formal methods applications for railways. It can be used by formal methods researchers to better focus their scientific inquiries, and by railway practitioners for an improved understanding of the interplay between formal methods and their specific application domain.

Contracts in System Development: From Multiconcern Analysis to Assurance With the Architecture Analysis and Design Language

We advocate a broader application of the notion of contracts to support the development of software-intensive systems. We discuss how system development can benefit from a contract-driven approach and review examples that utilize the Architecture Analysis and Design Language.

Communication Problems in Software Development — A Model and Its Industrial Application

Attaining effective communication within and across organizational units is among the most critical challenges for success in software development organizations. This paper presents a novel model, supporting analysis of problems in inter-departmental communication events. The model was developed and designed based on industrial needs emphasizing flexibility, applicability and scalability. The model covers central communication aspects in order to provide a useful approximation of communication problems rather than in-depth modeling on message-by message basis. Other event-specific information, such as costs, can then be attached to enrich analysis and understanding. To exemplify and evaluate the model and collect feedback from industry, it was applied to 16 events at a Swedish automotive manufacturer where communication between two departments had broken down during development of software-intensive systems. The evaluation showed that the model helped structure and conduct systematic data collection and analysis of dysfunctional communication patterns. We found that insufficient understanding of the matters being communicated was prevalent, but also more specifically, requirements were insufficiently balanced, detailed and specified over the full system development cycle. Besides, the long-term cost for the company was analyzed in depth for each event, yielding a total estimated cost for the analyzed communication events of 11.2MUS$.

Secure and trusted partial grey-box verification

A crucial aspect in the development of software-intensive systems is verification. This is the process of checking whether the system has been implemented in compliance with its specification. In many situations, the manufacture of one or more components of the system is outsourced. We study the case of how a third party (the verifier) can verify an outsourced component effectively, without access to all the details of the internal design of that component built by the developer. We limit the design detail that is made available to the verifier to a diagram of interconnections between the different design units within the component, but encrypt the design details within the units and also the intermediate values passed between the design units. We formalize this notion of limited information using tabular expressions to describe the functions in both the specifications and the design. The most common form of verification is testing, and it is known that black-box testing of the component is not effective enough in deriving test cases that will adequately determine the correctness of the implementation, and the safety of its behaviour. We have developed protocols that allow for the derivation of test cases that take advantage of the design details disclosed as described above. We can regard this as partial grey-box testing that does not compromise the developer’s secret information. Our protocols work with both trusted and untrusted developers, as well as trusted and untrusted verifiers, and allow for the checking of the correctness of the verification process itself by any third party, and at any time. Currently our results are derived under the simplifying assumption that the software design units are linked acyclically. We leave the lifting of this assumption as an open problem for future research.

Future smart energy software houses

Software is the key enabling technology (KET) as digitalization is cross-cutting future energy systems spanning the production sites, distribution networks, and consumers particularly in electricity smart grids. In this paper, we identify systematically what particular software competencies are required in the future energy systems focusing on electricity system smart grids. The realizations of that can then be roadmapped to specific software capabilities of the different future ‘software houses’ across the networks. Our instrumental method is software competence development scenario path construction with environmental scanning of the related systems elements. The vision of future software-enabled smart energy systems with software houses is mapped with the already progressing scenarios of energy systems transitions on the one hand coupled with the technology foresight of software on the other hand. Grounding on the Smart Grid Reference Architecture Model (SGAM), it tabulates the distinguished software competencies and attributes them to the different parties—including customers/consumers (Internet of People, IoP)—involved in future smart energy systems. The resulting designations can then be used to recognize and measure the necessary software competencies (e.g., fog computing) in order to be able to develop them in-house, or for instance to partner with software companies, depending on the future desirability. Software-intensive systems development competence becomes one of the key success factors for such cyber-physical-social systems (CPSS). Further futures research work is chartered with the Futures Map frame. This paper contributes preliminarily toward that by identifying pictures of the software-enabled futures and the connecting software competence-based scenario paths.

Substantially Evolutionary Theorizing in Designing Software-Intensive Systems

Useful inheritances from scientific experience open perspective ways for increasing the degree of success in designing of systems with software. One such way is a search and build applied theory that takes into account the nature of design and the specificity of software engineering. This paper presents a substantially evolutionary approach to creating the project theories, the application of which leads to positive effects that are traditionally expected from theorizing. Any implementation of the approach is based on a reflection by designers of an operational space of designing onto a semantic memory of a question-answer type. One of the results of such reflection is a system of question-answer nets, the nodes of which register facts of interactions of designers with accessible experience. A set of such facts is used by designers for creating and using the theory that belongs to the new subclass of Grounded Theories. This sub-class is oriented on organizationally behavioral features of a project’s work based on design thinking, automated mental imagination, and thought experimenting that facilitate increasing the degree of controlled intellectualization in the design process and, correspondingly, increasing the degree of success in the development of software-intensive systems.

The GRADE taxonomy for supporting decision-making of asset selection in software-intensive system development

ContextThe development of software-intensive systems includes many decisions involving various stakeholders with often conflicting interests and viewpoints. ObjectiveDecisions are rarely systematically documented and sporadically explored. This limits the opportunity for learning and improving on important decisions made in the development of software-intensive systems. MethodIn this work, we enable support for the systematic documentation of decisions, improve their traceability and contribute to potentially improved decision-making in strategic, tactical and operational contexts. ResultsWe constructed a taxonomy for documentation supporting decision-making, called GRADE. GRADE was developed in a research project that required composition of a common dedicated language to make feasible the identification of new opportunities for better decision support and evaluation of multiple decision alternatives. The use of the taxonomy has been validated through thirty three decision cases from industry. ConclusionThis paper occupies this important yet greatly unexplored research gap by developing the GRADE taxonomy that serves as a common vocabulary to describe and classify decision-making with respect to architectural assets.

Measuring object-oriented design principles: The results of focus group-based research

Object-oriented design principles are fundamental concepts that carry important design knowledge and foster the development of software-intensive systems with a focus on good design quality. They emerged after the first steps in the field of object-oriented programming and the recognition of best practices in using this programming paradigm to build maintainable software. Although design principles are known by software developers, it is difficult to apply them in practice without concrete rules to follow. We recognized this gap and systematically derived design best practices for a number of design principles and provide tool support for automatic measurement of these practices. The aim of this paper is to examine the relationship between design best practices and 10 selected design principles. This should provide evidence whether the key design aspects of the design principles are covered. We conducted focus group research with six focus groups and 31 participants in total. In parallel, each group discussed five design principles and assessed the coverage by using the Delphi method. Despite suggestions of additional design practices that were added by the participants, the result reveals the impact of each design best practice to the design principle and shows that the main design aspects of the design principles are covered by our approach and is therefore feasible to derive concrete design improvement actions.

Debugging Autonomous Driving Systems Using Serialized Software Components

In the development of software-intensive systems in a vehicle, like an autonomous driving system, defects are often only recognized during trials on the physical vehicle. In contrast to a simulation environment, a physically executed maneuver does not offer the possibility to pause and debug critical code sections or to reproduce and repeat faulty trials. Furthermore, development space and capacities are limited inside the car. Therefore, it is best practice to analyze faults observed during a physical execution offline and to reproduce faulty trials in a simulation environment. The repetition in a simulation environment is a time consuming effort but necessary for pushing the software component towards a state in which it showed the faulty behavior. This paper shows an approach for executing the faulty state again in a simulation environment by serializing the exact state of the software system and summarizes practical experience gained by this approach.

Requirements communication and balancing in large-scale software-intensive product development

ContextSeveral industries developing products on a large-scale are facing major challenges as their products are becoming more and more software-intensive. Whereas software was once considered a detail to be bundled, it has since become an intricate and interdependent part of most products. The advancement of software increases the uncertainty and the interdependencies between development tasks and artifacts. A key success factor is good requirements engineering (RE), and in particular, the challenges of effectively and efficiently coordinating and communicating requirements. ObjectiveIn this work we present a lightweight RE framework and demonstrate and evaluate its industrial applicability in response to the needs of a Swedish automotive company for improving specific problems in inter-departmental requirements coordination and communication in large-scale development of software-intensive systems. MethodA case study approach and a dynamic validation were used to develop and evaluate the framework in close collaboration with our industrial partner, involving three real-life cases in an ongoing car project. Experience and feedback were collected through observations when applying the framework and from 10 senior industry professionals in a questionnaire and in-depth follow-up interviews. ResultsThe experience and feedback about using the framework revealed that it is relevant and applicable for the industry as well as a useful and efficient way to resolve real problems in coordinating and communicating requirements identified at the case company. However, other concerns, such as accessibility to necessary resources and competences in the early development phases, were identified when using the method, which allowed for earlier pre-emptive action to be taken. ConclusionOverall, the experience from using the framework and the positive feedback from industry professionals indicated a feasible framework that is applicable in the industry for improving problems related to coordination and communication of requirements. Based on the promising results, our industrial partner has decided upon further validations of the framework in a large-scale pilot program.

KnowLang: Knowledge Representation for Self-Adaptive Systems

The KnowLang framework models uncertainty into the development of software-intensive systems to create enhanced possibilities for self-adaptation.

The lean gap: A review of lean approaches to large-scale software systems development

Lean approaches to product development (LPD) have had a strong influence on many industries and in recent years there have been many proponents for lean in software development as it can support the increasing industry need of scaling agile software development. With it's roots in industrial manufacturing and, later, industrial product development, it would seem natural that LPD would adapt well to large-scale development projects of increasingly software-intensive products, such as in the automotive industry. However, it is not clear what kind of experience and results have been reported on the actual use of lean principles and practices in software development for such large-scale industrial contexts. This was the motivation for this study as the context was an ongoing industry process improvement project at Volvo Car Corporation and Volvo Truck Corporation.The objectives of this study are to identify and classify state of the art in large-scale software development influenced by LPD approaches and use this established knowledge to support industrial partners in decisions on a software process improvement (SPI) project, and to reveal research gaps and proposed extensions to LPD in relation to its well-known principles and practices.For locating relevant state of the art we conducted a systematic mapping study, and the industrial applicability and relevance of results and said extensions to LPD were further analyzed in the context of an actual, industrial case.A total of 10,230 papers were found in database searches, of which 38 papers were found relevant. Of these, only 42 percent clearly addressed large-scale development. Furthermore, a majority of papers (76 percent) were non-empirical and many lacked information about study design, context and/or limitations. Most of the identified results focused on eliminating waste and creating flow in the software development process, but there was a lack of results for other LPD principles and practices.Overall, it can be concluded that research in the much hyped field of lean software development is in its nascent state when it comes to large scale development. There is very little support available for practitioners who want to apply lean approaches for improving large-scale software development, especially when it comes to inter-departmental interactions during development. This paper explicitly maps the area, qualifies available research, and identifies gaps, as well as suggests extensions to lean principles relevant for large scale development of software intensive systems.

Problems and their mitigation in system and software architecting

ContextToday, software and embedded systems act as enablers for developing new functionality in traditional industries such as the automotive, process automation, and manufacturing automation domains. This differs from 25–30years ago when these systems where based on electronics and electro-mechanical solutions. The architecture of the embedded system and of the software is important to ensure the qualities of these applications. However, the effort of designing and evolving the architecture is in practice often neglected during system development, whilst development efforts are centered on implementing new functionality. ObjectiveWe present problems and success factors that are central to the architectural development of software intensive systems in the domain of automotive and automation products as judged by practitioners. MethodThe method consisted of three steps. First, we used semi-structured interviews to collect data in an exploratory manner. As a second step, a survey based on problems extracted from the interview data was used to investigate the occurrence of these problems at a wider range of organizations. In order to identify and suggest how to mitigate the problems that were considered important, we finally performed root cause analysis workshops, and from these a number of success factors were elicited. ResultsA total of 21 problems have been identified based on the interview data, and these are related to the technical, organizational, project, and agreement processes. Based on the survey results, the following four problems were selected for a root cause analysis: (1) there is a lack of process for architecture development, (2) there is a lack of method or model to evaluate the business value when choosing the architecture, (3) there is a lack of clear long-term architectural strategy, and (4) processes and methods are less valued than knowledge and competence of individuals. ConclusionIn conclusion, the following identified success factors are crucial components to be successful in developing software intensive systems: (1) define an architectural strategy, (2) implement a process for architectural work, (3) ensure authority for architects, (4) clarify the business impact of the architecture, and (5) optimize on the project portfolio level instead of optimizing each project.

Experiences in teaching a graduate course on model-driven software development

Model-driven software development (MDSD) aims to support the development and evolution of software intensive systems using the basic concepts of model, metamodel, and model transformation. In parallel with the ongoing academic research, MDSD is more and more applied in industrial practices. After being accepted both by a broad community of researchers and the industry, it is now being introduced in university courses. This article describes the experiences of three years of teaching of the graduate course Model-Driven Software Development at Bilkent University in Turkey. The lessons learned can be useful for peer educators who teach or aim to teach a similar course.

On the communication problem between domain engineering and application engineering

Software Product Line Engineering enables customization and reuse during the development of software intensive systems. A typical product line process consists of a domain engineering process and several application engineering processes. We use two different heuristics to characterize artifact redundancies in a product line system: 1) artifacts should not be developed redundantly across domain engineering and application engineering and 2) no two application engineering teams should develop same artifacts redundantly. To provide a formal basis for the heuristics, we derive consistency equations by using mathematical notations of sets. We also use these consistency equations to describe artifact redundancies that occur due to conflicts-of-interests between domain engineering and application engineering. In particular, conflicts-of interests during product line scoping, product instantiation and product line evolution are covered. Furthermore, based on a literature review, we elicit several requirements to address the conflicts-of-interests and artifact redundancies.

Systems Engineering Perspectives on Technology Readiness Assessments in Software-Intensive System Development

Technology readiness assessments as formal technologymaturity validation tools play an important role in system development and acquisition. Because of the particular diversity of technologies in software-intensive systems, such assessments pose a special challenge. This paper’s objective is to show how technology readiness assessments control the technology transition process from research to productization and to demonstrate that effective execution of this transition requires sophisticated systems engineering perspectives. To achieve this objective, a rigorous attempt was made to seek out and clarify the ambiguous elements of the process and to provide tangible guidance on the topic. Examples from the emerging technology-rich domains of unmanned aerial vehicles are used to facilitate a deeper understanding of the concepts introduced.

Creation and Usage of Project Ontology in Development of Software Intensive Systems

The key problem of successful developing of the software intensive system (SIS) is adequate conceptual interactions of designers during the early stages of development. The success of the development can be increased by using of a project ontology, the creation of which is being embedded into the processes of conceptual solving the project tasks and specifying the project solutions. The essence of the conceptual design is a specification of conceptualization. The main suggestion of this paper is a creation of the project ontology in the form of a specialized SIS that supports the conceptual activity of designers. For creation of the project ontology of such type, the instrumental shell was developed. For creation of the project ontology the designers should fill this shell with the adequate information. The basic reasons for evolving the content of the ontology are negative results of testing of the used text units according to the conformity to the ontology. Such shell (in any state of its using) includes the created ontology and its working version (working dictionary) which helps to manage the informational flows, to register the life cycles of the conceptual units and to provide the representativity of their usages.

Towards the development of a methodology to develop information systems in a research and development environment

This paper critiques a previous attempt at methodology selection for R&D environments, and on the basis of the findings of this critique proposes the development of a multi-stream meta-methodology to apply systems engineering to the development of software intensive systems in R&D environments. This methodology is intended to provide expert support to inexperienced project managers leading R&D projects, providing a just-in-time, on-demand training resource. The paper describes an interactive prototype tool for guiding users through this meta-methodology.

Avoiding semantic and temporal gaps in developing software intensive systems

Development of software intensive systems (systems) in practice involves a series of self-contained phases for the lifecycle of a system. Semantic and temporal gaps, which occur among phases and among developer disciplines within and across phases, hinder the ongoing development of a system because of the interdependencies among phases and among disciplines. Such gaps are magnified among systems that are developed at different times by different development teams, which may limit reuse of artifacts of systems development and interoperability among the systems. This article discusses such gaps and a systems development process for avoiding them.