Modeling Techniques for Software-Intensive Systems

Software has become the driving force in the evolution of many systems, such as embedded systems (especially automotive applications), telecommunication systems, and large scale heterogeneous information systems. These so called software-intensive systems, are characterized by the fact that software influences the design, construction, deployment, and evolution of the whole system. Furthermore, the development of these systems often involves a multitude of disciplines. Besides the traditional engineering disciplines (e.g., control engineering, electrical engineering, and mechanical engineering) that address the hardware and its control, often the system has to be aligned with the organizational structures and workflows as addressed by business process engineering. The development artefacts of all these disciplines have to be combined and integrated in the software. Consequently, software-engineering adopts the central role for the development of these systems. The development of software-intensive systems is further complicated by the fact that future generations of software-intensive systems will become even more complex and, thus, pose a number of challenges for the software and its integration of the other disciplines. It is expected that systems become highly distributed, exhibit adaptive and anticipatory behavior, and act in highly dynamic environments interfacing with the physical world. Consequently, modeling as an essential design activity has to support not only the different disciplines but also the outlined new characteristics. Tool support for the model-driven engineering with this mix of composed models is essential to realize the full potential of software-intensive systems. In addition, modeling activities have to cover different development phases such as requirements analysis, architectural design, and detailed design. They have to support later phases such as implementation and verification and validation, as well as to systematically and efficiently develop systems.

Differentiated Process Support for Large Software Projects

This chapter presents a framework for differentiated process support in large software projects. Process support can be differentiated in different levels based on the size of the development organization and the need for coordination across different levels of the organization. We have defined four main perspectives: individual, group, team, and project level, where the framework consider essential issues when planning and executing the software development processes in organizations with different levels of management. Further, a guideline is provided that suggests what is required of process support in the various organizational levels.

Quality Metrics for Evaluating Data Provenance

With the proliferation of Web, a tremendous amount of data is available to researchers and scientists in computational sciences, business organizations and general public. This has resulted in an increased importance of data intensive domains such as Bioinformatics, which are increasingly using Web-based applications and service-oriented architecture which uses the data available on the Web sources. To trust the data available on Web and the results derived from it, a Data Provenance system must be devised to ensure authenticity and credibility of Web resources. In this paper we have discussed various domains which necessitate such data provenance systems. We propose a set of tangible parameters which affect the quality of data and define quality metrics to evaluate those parameters. The chapter concludes with a section on future directions in which we identify various research problems and possible applications of data provenance.

Evolution in Model-Driven Software Product-Line Architectures

This chapter describes our approach to model-driven engineering (MDE)-based product line architectures (PLAs) and presents a solution to address the domain evolution problem. We use a case study of a representative software-intensive system from the distributed real-time embedded (DRE) systems domain to describe key challenges when facing domain evolution and how we can evolve PLAs systematically and minimize human intervention. The approach uses a mature metamodeling tool to define a modeling language in the representative DRE domain, and applies a model transformation tool to specify modelto- model transformation rules that precisely define metamodel and domain model changes. Our approach automates many tedious, time consuming, and error-prone tasks of model-to-model transformation, thus significantly reducing the complexity of PLA evolution.

Service Orientation and Software-Intensive Systems

Software intensive systems are systems strongly depending on supporting software. The software is typically large, complex, and it as a rule interacts with human users. The failure of the software implies failure of the system usually causing substantial losses. Such systems are critical. The prospective redevelopment all at once of the software is no feasible solution. It is shown that such software should usually be service-oriented. The interfaces of services should be user-oriented (well understood by users and the users can use it easily). The services should be of two basic types: application services and architecture (enabling to develop an architecture) services. We present the most important infrastructure services as basic service-oriented design patterns.

Dynamic Analysis and Profiling of Multithreaded Systems

As software-intensive systems become larger, more parallel, and more unpredictable the ability to analyze their behavior is increasingly important. There are two basic approaches to behavioral analysis: static and dynamic. Although static analysis techniques, such as model checking, provide valuable information to software developers and testers, they cannot capture and predict a complete, precise, image of behavior for large-scale systems due to scalability limitations and the inability to model complex external stimuli. This chapter explores four approaches to analyzing the behavior of software systems via dynamic analysis: compiler-based instrumentation, operating system and middleware profiling, virtual machine profiling, and hardware-based profiling. We highlight the advantages and disadvantages of each approach with respect to measuring the performance of multithreaded systems and demonstrate how these approaches can be applied in practice.

Architecting Virtual Reality Systems

Virtual reality systems are a kind of complex software systems that need a lot of effort and resources during its development phase. Because rigid and monolithic approaches for these systems have been used in the past, maintenance and evolution activities become difficult tasks to carry out. Today, software architectures are used for designing more maintainable and modular systems, but previous experiences in the virtual reality field didn’t pay much attention to the usage of appropriate architecture descriptions. In this chapter we describe how the design of virtual reality systems can be improved with software architectures. Our main goal is to provide guidance in the design of virtual reality systems that can be reused for similar applications. A software architecture-centric approach is proposed and used to tackle certain problems that affect the construction of this kind of software intensive systems.

Traceability in Model-Driven Software Development

This chapter introduces a tracability solution for use in a model-driven software development approach. It argues that a trace model based on a provided traceability metamodel will provide a flexible solution for all types of artifacts to be traced througout the lifetime of a software system. The proposed traceability solution is demonstrated in the BusCatcher example where traces are established and analyzed. The authors hope that the metamodel and solution design can assist researchers and tool vendors in the development of unified trace models and services for model-driven software development approaches. Only then can the full potential of traceability be achieved.

A Framework for Understanding the Open Source Revolution

Traditional software engineering methodologies have mostly evolved from the environment of proprietary, large-scale software systems. Here, software design principles operate within a hierarchical decision- making context. Development of banking, enterprise resource and complex weapons systems all fit this paradigm. However, another paradigm for developing software-intensive systems has emerged, the paradigm of open source software. Although from a traditional perspective open source projects might look like chaos, their real-world results have been spectacular. This chapter presents open source software development as a fundamentally new paradigm driven by economics and facilitated by new processes. The new paradigm’s revolutionary aspects are explored, a framework for describing the massive impact brought about by the new paradigm is proposed, and directions of future research are outlined. The proposed framework’s goals are to help the understanding of the open source paradigm as a new economic revolution and stimulate research in designing open source software.

Reducing the Complexity of Modeling Large Software Systems

Model-driven development is one approach to combating the complexity of designing software intensive systems. A model-driven approach allows designers to use domain notations to specify solutions and domain constraints to ensure that the proposed solutions meet the required objectives. Many domains, however, require models that are either so large or intricately constrained that it is extremely difficult to manually specify a correct solution. This chapter presents an approach to provide that leverages a constraint solver to provide modeling guidance to a domain expert. The chapter presents both a practical framework for transforming models into constraint satisfaction problems and shows how the Command Pattern can be used to integrate a constraint solver into a modeling tool.