Software-intensive Systems Research Articles

Web services property sequence chart monitor: a tool chain for monitoring BPEL‐based web service composition with scenario‐based specifications

Web service composition is a new paradigm to develop distributed and reactive software-intensive systems. Owing to the autonomous nature of basic services, the validation of composite service must be extended from design-time to run-time. Here, the authors describe a novel tool chain called web services property sequence chart monitor to monitor temporal, timing and probabilistic properties in composite service based on scenario-based property specifications called property sequence chart, timed property sequence chart and probabilistic timed property sequence chart, respectively. The tool chain provides a completely graphical front-end that eliminates the need to deal with any particular textual and logical formalism. Furthermore, the framework and implementation detail of the tool chain are also presented. Finally, the feasibility and usability of the tool have been validated by the case studies and performance measurement.

Extraction and evolution of architectural variability models in plugin-based systems

Variability management is a key issue when building and evolving software-intensive systems, making it possible to extend, configure, customize and adapt such systems to customers' needs and specific deployment contexts. A wide form of variability can be found in extensible software systems, typically built on top of plugin-based architectures that offer a (large) number of configuration options through plugins. In an ideal world, a software architect should be able to generate a system variant on-demand, corresponding to a particular assembly of plugins. To this end, the variation points and constraints between architectural elements should be properly modeled and maintained over time (i.e., for each version of an architecture). A crucial, yet error-prone and time-consuming, task for a software architect is to build an accurate representation of the variability of an architecture, in order to prevent unsafe architectural variants and reach the highest possible level of flexibility. In this article, we propose a reverse engineering process for producing a variability model (i.e., a feature model) of a plugin-based architecture. We develop automated techniques to extract and combine different variability descriptions, including a hierarchical software architecture model, a plugin dependency model and the software architect knowledge. By computing and reasoning about differences between versions of architectural feature models, software architect can control both the variability extraction and evolution processes. The proposed approach has been applied to a representative, large-scale plugin-based system (FraSCAti), considering different versions of its architecture. We report on our experience in this context.

The Wonder Years

For those on the outside of the curtain of computing, there is much mystery behind the matter of software-intensive systems. To some, it looks like magic; to most, its inner workings are irrelevant in so far that it simply works. To those of us behind the curtain, however, we know that such systems are filled with chaos, regularity, and beauty. The first Web extra at http://youtu.be/HfGVE3kt8Og is an audio podcast of author Grady Booch reading his On Computing column, in which he peers behind the curtain of computing into the mystery behind software-intensive systems. To some, such systems look like magic; to most, the inner workings are irrelevant insofar that they simply work. To those of us behind the curtain, however, we know that such systems are filled with chaos, regularity, and beauty. The second Web extra at http://youtu.be/52ztwEAcmAA is a video in which Tim O'Reilly, CEO and founder of O'Reilly Media, and Grady Booch, IBM Fellow, IBM Chief Scientist for Software Engineering, and author of On Computing in IEEE Software magazine, speak with James Governor about the next stage of development of mobile apps and the focus on development practitioners prior to the IBM Impact 2013 Unconference, sponsored by IEEE Software magazine.

Integrating security mechanisms into embedded systems by domain‐specific modelling

ABSTRACTEmbedded devices are crucial enablers of the Internet of Things and become increasingly common in our daily life. They store, manipulate and transmit sensitive information and, therefore, must be protected against security threats. Due to the security and also resource constraint concerns, designing secure networked embedded systems is a difficult task. Model‐based development (MBD) is promoted to address complexity and ease the design of software intensive systems. We leverage MBD and domain‐specific modelling to characterise common issues related to security and embedded systems that are specific to a given application domain. Security‐specific knowledge relevant for a certain application domain is represented in the form of an adapted information security ontology. Further, the elements of the ontology are associated with security building blocks modelled with the MBD method SPACE. The selection of relevant security building blocks is based on (i) assets automatically elicited from the functional models, (ii) domain security knowledge captured by the security expert and (iii) the platform adopted by the embedded system engineer. A tool is developed to support the steps supporting this methodology and help to bridge between the security and embedded systems domains. We illustrate our approach with a case study from the smart metering domain. © 2013 The Authors. Security and Communication Networks published by John Wiley & Sons, Ltd.

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.

Model-based lifecycle management of software-intensive systems, applications, and services

The lifecycle of a successful system is the time period that covers all activities associated with developing, configuring, deploying, operating, and retiring the system. Variations in system lifecycles can be expected, for example, differences may arise as a result of the inclusion of physical parts in the system and the number of installations. In addition, software retirement activities may extend over a long period of time, for example, in cases where access to data provided by a system may be required long after the system is terminated. Lifecycle management has a lot to do with managing the available information about a system. A significant amount of this information can typically be found in the models produced during various development. Softwaremodels can thus play a vital role in system lifecycle management. For example, requirement models can be used to support management of requirements, feature models can be used to manage system and user specific variabilities as well as commonalities, and architecture and design models can provide information that supportmanagement of deployment and validation activities. The potential role thatmodels can play in lifecyclemanagement raises the following questions: “To what extent do the models produced during software development help (or hinder) lifecycle management?” “Should the software modeling activity be integrated with the lifecycle management of systems, and, if yes, how can this be done?” “What tools are needed to better leverage the use of models in lifecycle management?” “Does a model also have a lifecycle that needs to be managed?”

From Principles to Details: Integrated Framework for Architecture Modelling of Large Scale Software Systems

There exist numerous models of software architecture (box models, ADL’s, UML, architectural decisions), architecture modelling frameworks (views, enterprise architecture frameworks) and even standards recommending practice for the architectural description. We show in this paper, that there is still a gap between these rather abstract frameworks/standards and existing architecture models. Frameworks and standards define what should be modelled rather than which models should be used and how these models are related to each other. We intend to prove that a less abstract modelling framework is needed for the effective modelling of large scale software intensive systems. It should provide a more precise guidance kinds of models to be employed and how they should relate to each other. The paper defines principles that can serve as base for an integrated model. Finally, structure of such a model has been proposed. It comprises three layers: the upper one – architectural policy – reflects corporate policy and strategies in architectural terms, the middle one –system organisation pattern – represents the core structural concepts and their rationale at a given level of scope, the lower one contains detailed architecture models. Architectural decisions play an important role here: they model the core architectural concepts explaining detailed models as well as organise the entire integrated model and the relations between its submodels.

Software health management: a necessity for safety critical systems

As software and software intensive systems are becoming increasingly ubiquitous, the impact of failures can be tremendous. In some industries such as aerospace, medical devices, or automotive, such failures can cost lives or endanger mission success. Software faults can arise due to the interaction between the software, the hardware, and the operating environment. Unanticipated environmental changes lead to software anomalies that may have significant impact on the overall success of the mission. Latent coding errors can at any time during system operation trigger faults despite the fact that usually a significant effort has been expended in verification and validation (V&V) of the software system. Nevertheless, it is becoming increasingly more apparent that pre-deployment V&V is not enough to guarantee that a complex software system meets all safety, security, and reliability requirements. Software Health Management (SWHM) is a new field that is concerned with the development of tools and technologies to enable automated detection, diagnosis, prediction, and mitigation of adverse events due to software anomalies, while the system is in operation. The prognostic capability of the SWHM to detect and diagnose failures before they happen will yield safer and more dependable systems for the future. This paper addresses the motivation, needs, and requirements of software health management as a new discipline and motivates the need for SWHM in safety critical applications.

Safety-Critical Software [Guest editors' introduction

We live in a world in which our safety depends on software-intensive systems. This is the case for the aeronautic, automotive, medical, nuclear, and railway sectors as well as many more. Organizations everywhere are struggling to find cost-effective methods to deal with the enormous increase in size and complexity of these systems, while simultaneously respecting the need to ensure their safety. Consequently, we're witnessing the ad hoc emergence of a renewed discipline of safety-critical software systems development as a broad range of software engineering methods, tools, and frameworks are revisited from a safety-related perspective. The rise of these complex, critical systems has spawned several recent initiatives to promote reuse, both of the technical artifacts and the artifacts and procedures that certify their suitability for use in safety-related contexts. One unmistakable trend is a strong interest in applying model-driven engineering techniques to safety-critical systems development over the entire life cycle.

In Defense of Boring

On the one hand, we seek to build software-intensive systems that are innovative, elegant, and supremely useful. On the other hand, computing technology as a thing unto itself is not the place of enduring value, and therefore, as computing fills the spaces of our world, it becomes boring. And that's a very good and desirable thing. The Web extra at http://youtu.be/o8Ze4sVkBxE is an audio podcast of author Grady Booch reading his On Computing column, in which he discusses how the purpose of good software is to make the complex appear simple.

The evolution of modeling research challenges

In 2007 ICSE hosted a track called “Future of SoftwareDevelopment”(FOSD).Wewereinvitedtowriteandpresenta paper on the future of modeling for the track. The result-ing paper [1] described the state of modeling research, iden-tified some major challenges and proposed a research roadmap.Partsofthisroadmaparecurrentlybeingexplored,andprogresshasbeenmadeinaddressingsomeofthechallengeswe identified. However, there is still significant research “tobedone”withrespecttothechallengesoutlinedinthatpaper.Itisnotourintenttodiscusstheprogressthecommunityhasmadewithrespecttotheroadmapinthiseditorial(ourapolo-gies for deflating expectations in this regard; an editorial issimplynottheplaceforsuchdiscussions).Rather,wewouldliketousethiseditorialtostimulatediscussionsaroundsomeof the challenges that have arisen since we wrote that paper.Before we get into identifying specific challenges, letus first take a step back and ask “What is the grand chal-lenge addressed by researchers in the SoSyM community?”The answer has typically been “To significantly reduce thetime, cost, and effort required to develop complex software-intensive systems that meet stringent quality requirementsthrough use of models that are fit-for-purpose.” This is stillthe focus of many research programs, but we are also see-ing a broadening of the grand challenge to include not onlydevelopment problems, but problems that occur throughoutthe lifetime of a complex system, from conception to retire-ment. For example, in the FOSD paper we made referenceto emerging work on the use of models to manage software

Features meet scenarios: modeling and consistency-checking scenario-based product line specifications

Many modern software-intensive systems consist of multiple components interacting together to deliver the intended functionality. Often, these systems come in many variants (products) and are managed together as a software product line. This variability is the source of additional complexity which can cause inconsistencies and offset the economies of scale promised by product line engineering. Engineers thus need intuitive, yet precise means for specifying requirements and require tools for automatically detecting inconsistencies within these requirements. In recent work, we proposed a technique for the scenario-based specification of interactions in product lines by a combination of Modal Sequence Diagrams and Feature Diagrams. Furthermore, we elaborated an efficient consistency-checking technique based on a dedicated model-checking approach especially tailored for product lines. In this paper, we report on further evaluations that underline significant performance benefits of our approach. We describe further optimizations and detail on how we encode the consistency-checking problem for a model-checker.

Modelling unmanned surface vehicle patrol mission with Coalition Battle Management Language (C-BML)

Today, many military software intensive systems such as command and control systems, military simulations and decision support systems require the same military knowledge found in the operation plans and orders, which are mostly imported to the system in an application specific form. Due to the increased need for interoperability among those systems, many domain specific languages arise in order to formalize the inputs and outputs to obtain machine processable knowledge. A major domain specific language is the Coalition Battle Management Language (C-BML), which is currently under development. In this work, a scenario is developed and a coalition combat organization that has unmanned surface vehicle (USV) units under its command is created for fighting piracy. The orders and reports related to the patrol mission for the USVs are set up and modelled using C-BML. In order to model the orders, functional and temporal analyses of the actions in the orders are performed. The representativeness of the military orders, reports and requests in the scope of the scenario domain in C-BML is examined. Discussions about the expressiveness of C-BML are offered from a C-BML adopter perspective. Furthermore, we anticipate that this study will serve as a guideline for further C-BML studies.

Using argumentation to evaluate software assurance standards

ContextMany people and organisations rely upon software safety and security standards to provide confidence in software intensive systems. For example, people rely upon the Common Criteria for Information Technology Security Evaluation to establish justified and sufficient confidence that an evaluated information technology product’s contributions to security threats and threat management are acceptable. Is this standard suitable for this purpose? ObjectiveWe propose a method for assessing whether conformance with a software safety or security standard is sufficient to support a conclusion such as adequate safety or security. We hypothesise that our method is feasible and capable of revealing interesting issues with the proposed use of the assessed standard. MethodThe software safety and security standards with which we are concerned require evidence and discuss the objectives of that evidence. Our method is to capture a standard’s evidence and objectives as an argument supporting the desired conclusion and to subject this argument to logical criticism. We have evaluated our method by case study application to the Common Criteria standard. ResultsWe were able to capture and criticise an argument from the Common Criteria standard. Review revealed 121 issues with the analysed use of the standard. These range from vagueness in its text to failure to require evidence that would substantially increase confidence in the security of evaluated software. ConclusionOur method was feasible and revealed interesting issues with using a Common Criteria evaluation to support a conclusion of adequate software security. Considering the structure of similar assurance standards, we see no reason to believe that our method will not prove similarly valuable in other applications.

Safety assurance in NextGen and complex transportation systems

The methods currently used to assure the safety of planned changes to our air transportation systems were developed 50years ago for systems composed primarily of hardware components and of much less complexity than the systems we are building today. These methods are not powerful enough to handle the complex, human and software intensive systems being planned and introduced today. This paper describes an alternative and demonstrates it on a new NextGen procedure to allow more flight level changes over oceanic and other regions with limited radar coverage. The new approach and results are compared with the results obtained by the more traditional methods being used for NextGen.

Rich Services — A SOA Pattern for Dynamic Change in Cyber-physical Systems

Abstract Cyber-physical systems (CPS) are changing the way we interact with the physical world. From automotive to manufacturing to logistics to power-grid to virtual command and control, we now see widespread application of integrated, software-intensive systems of sensor/actuator networks connected to backbone cyber-infrastructures. In this document we develop Rich Services as an architectural pattern suitable for systematically designing and implementing CPS, with particular emphasis on dynamic change.

Review of Requirements Management Issues in Software Development

A requirement is a capability to which a product or service should conform to. A meticulous consideration to requirements engineering acts as a backbone of software projects. Ambiguous and unrealistic requirements are major source of failure in the software-intensive systems. Requirements engineering processes are complex as most of the requirements engineering documentation is written in natural languages which are less formal and often distract the designers and developers. Requirements management is a continuous process throughout the project lifecycle and relates to documenting, analyzing, tracing and prioritizing requirements and then finally controlling changes. The main issues related to requirements management are usually social, political and cultural. Software requirement engineers who gather the requirements generally consider that such issues are beyond the scope of their profession as they deem them within the project management ambit. In this study, we highlight the management issues that arise in the requirements engineering process and explore the possibilities to tackle them amicably. The study is supplemented with a critical review of the existing methodologies for resolving and managing software requirements.

Integrated Analysis Framework for Improving Production Processes in Software-intensive Systems

Abstract Software-intensive systems involve the using of software engineering that cooperate with other engineering fields to achieve common goals, e.g., to provide good quality products to the customers in the right time. In the production automation systems as examples of software-intensive systems, the projects managers want to observe the production processes, so they can check the conformance between the running systems and the planned systems, e.g., whether the systems provide the expected products in the right time, how much time needed to finish a sequence of jobs is. However, the observation of production processes in these systems is difficult because heterogeneous data models are used to represent data from business and production layers. We propose an integrated analysis framework for improving production process in the production automation systems. Current results show that the framework can help the project manager to plan and conduct production process data collection and analysis for improving the process quality.

Process of Designing Robust, Dependable, Safe and Secure Software for Medical Devices: Point of Care Testing Device as a Case Study

This paper presents a holistic methodology for the design of medical device software, which encompasses of a new way of eliciting requirements, system design process, security design guideline, cloud architecture design, combinatorial testing process and agile project management. The paper uses point of care diagnostics as a case study where the software and hardware must be robust, reliable to provide accurate diagnosis of diseases. As software and software intensive systems are becoming increasingly complex, the impact of failures can lead to significant property damage, or damage to the environment. Within the medical diagnostic device software domain such failures can result in misdiagnosis leading to clinical complications and in some cases death. Software faults can arise due to the interaction among the software, the hardware, third party software and the operating environment. Unanticipated environmental changes and latent coding errors lead to operation faults despite of the fact that usually a significant effort has been expended in the design, verification and validation of the software system. It is becoming increasingly more apparent that one needs to adopt different approaches, which will guarantee that a complex software system meets all safety, security, and reliability requirements, in addition to complying with standards such as IEC 62304. There are many initiatives taken to develop safety and security critical systems, at different development phases and in different contexts, ranging from infrastructure design to device design. Different approaches are implemented to design error free software for safety critical systems. By adopting the strategies and processes presented in this paper one can overcome the challenges in developing error free software for medical devices (or safety critical systems).

A Scientifically Experimental Approach to the Simulation of Designer Activity in the Conceptual Designing of Software Intensive Systems

The success of designing software intensive systems (SISs) may be improved by incorporating experimentation to be part of the design process. This paper presents a scientific approach to experimentation on objects that are units of designers' behavior and is aimed at solving project tasks in conceptual design. The proposed approach is based on specifying the behavior units as precedents and pseudo-code programming of experiments' plans. Reasoning used by designers in the experiments is registered in a question-answer form. Experimenting is supported by a specialized toolkit.