Based on intensive cooperation with four large companies, a comparative analysis of the recent developments in industry, university organizations, computer science and software technology is presented.Within this context, also the Industry 4.0 phenomena is discussed.This paper further identifies the necessary organizational structures of universities to assist companies in their transition processes, defines the relevant sub-disciplines in computer science and finally describes the software engineering and technology challenges in designing and implementing economical and robust industrial systems.

Emergent behavior is generally defined as the appearance of complex behavior out of multiplicity of relatively simple interactions. Nowadays, there are various kinds of software systems that deal with detecting the emergence of certain behavior in environment, representing it in the software and providing means to manipulate the behavior. Where significant amount of research has been dedicated to develop algorithms for detecting emergent behavior, there is no dedicated attempt to provide suitable linguistic abstractions to modularize emergent behavior and its related concerns. This results in implementations that are complex and hard to maintain. In this paper, we identify three characteristic features of emergent behavior, and outline the shortcomings of current languages to properly program and modularize emergent behavior. We introduce emergent gummy modules as dedicated linguistic abstractions, which facilitate defining the appearance and disappearance conditions of emergent behavior as well as its utilization operations as one holistic module. We explain the implementation of emergent gummy modules in the GummyJ language, and illustrate that they improve the modularity of implementations. We represent the event processing semantics of GummyJ programs in UPPAAL model checker and verify their correctness.

Historically, programming languages have been—benevolent—dictators: reducing all possible semantics to specific ones offered by a few built-in language constructs. Over the years, some programming languages have freed the programmers from the restrictions to use only built-in libraries, built-in data types, and builtin type-checking rules. Even though—arguably—such freedom could lead to anarchy, or people shooting themselves in the foot, the contrary tends to be the case: a language that does not allow for extensibility is depriving software engineers of the ability to construct proper abstractions and to structure software in the most optimal way. Therefore the software becomes less structured and maintainable than would be possible if the software engineer could express the behavior of the program with the most appropriate abstractions. The idea proposed by this paper is to move composition from built-in language constructs to programmable, first-class abstractions in a language. We discuss several prototypes of the Co-op language, which show that it is possible, with a relatively simple model, to express a wide range of compositions as first-class concepts.

Each software architecture design is the result of a broad set of design decisions and their justifications, that is, the design rationale. Capturing the design rationale is important for a variety of reasons such as enhancing communication, reuse and maintenance. Unfortunately, it appears that there is still a lack of appropriate methods and tools for effectively capturing and managing the architecture design rationale. In this paper we present a feature-based rationale management approach and the corresponding tool environment ArchiRationale for supporting software architecture adaptation. The approach takes as input an existing architecture and captures the design rationale for adapting the architecture for a given quality concern. For this we define a feature model that includes the possible set of architectural tactics to realize the quality concern. The presented approach captures the rationale for deciding on feature selections and for selecting the corresponding architecture design alternatives. ArchiRationale customizes and integrates the Eclipse plugin tools XFeature, ArchStudio and XQuery to provide tool support for capturing, storing and accessing the design rationale. We illustrate the approach for adapting a software architecture for fault tolerance.

Complex software, especially the embedded one, is composed of multiple collaborating subsystems that are possibly developed in multiple languages. To verify the behavior of such software, a run-time verification system must deal with multiple-language environments both in its specifications and in its generated runtime verification modules. In this paper, we present the E-Chaser runtime verification system, whose front-end provides language-independent specifications, and whose backend provides an extendable toolset with new implementation languages. E-Chaser is built based on the Composition Filter Model and extends it with the notion of synchronization messages and synchronization filters to verify the synchronization properties of multiple subsystems. The first prototype of EChaser was successfully used to verify various properties.

In event-driven systems, separating the reactive part of software (i.e., event-driven control) from the non-reactive part is a common design practice. The reactive part is typically structured according to the states and transitions of a system, whereas the non-reactive part is typically structured according to the concepts of the application domain (e.g., the services provided by the system). In such systems, the non-reactive part of software stimulates the reactive part with event calls . Whenever the non-reactive part is modified (e.g., during evolution), the existing event calls may become invalid, new event calls may become necessary, and the two parts of software may become incompatible . Manually finding and repairing these types of defects is a time-consuming and error-prone maintenance task. In this article, we present a solution that combines source code model checking and aspect-oriented programming techniques, to reduce the time spent by developers and to automatically find defects, while performing the maintenance task mentioned above. In addition, we present controlled experiments showing that the solution can reduce the time by 75%, and enable the prevention of one defect per 140 lines of source code.

Abstract The decomposition of software architecture into modular units is usually driven by the required quality concerns. In this paper we focus on the impact of local recovery concern on the decomposition of the software system. For achieving local recovery, the system needs to be decomposed into separate units that can be recovered in isolation. However, it appears that this required decomposition for recovery is usually not aligned with the decomposition based on functional concerns. Moreover, introducing local recovery to a software system, while preserving the existing decomposition, is not trivial and requires substantial development and maintenance effort. To reduce this effort we propose a framework that supports the decomposition and implementation of software architecture for local recovery. The framework provides reusable abstractions for defining recoverable units and the necessary coordination and communication protocols for recovery. We discuss our experiences in the application and evaluation of the framework for introducing local recovery to the open‐source media player called MPlayer. Copyright © 2009 John Wiley & Sons, Ltd.

In this paper, we describe a framework for the computer-aided evolution of the designs of object-oriented software systems. Evolution mechanisms are software structures that prepare software for certain type of evolutions. The framework uses a database which holds the evolution mechanisms, modeled as template graph transformations, with the supported evolution types. To evolve the software, the designer enters the type of evolution and provides the names of the software entities that are going to be evolved. The framework fetches the evolution mechanisms, converts the design to a graph model and applies the transformations. As an application of the framework, we implemented a tool for computer-aided evolution that uses object-oriented evolution mechanisms.

Abstract. Domain specific aspect languages (DSALs) are becoming more pop-ular because they can be designed to represent recurring concerns in a way that is optimized for a specific domain. However, the design and implementation of even a limited domain-specific aspect language can be a tedious job. To address this, we propose a framework that offers a fast way to prototype implementations of domain specific aspect languages. A particular goal of the framework is to be general enough to support a wide range of aspect language concepts, such that existing language concepts can be easily used, and new language concepts can be quickly created. We briefly introduce the framework and its underlying model, as well as the work-flow used when implementing DSALs. Subsequently, we show mappings of sev-eral domain specific aspect languages to demonstrate the framework. Since in our approach the DSALs are mapped to a common model, the framework provides an integrating platform allowing us to compose programs that use aspects written in multiple DSALs. The framework also provides explicit mechanisms to specify composition of advices written in multiple DSALs. 1

Delivering software systems that fulfill all requirements of the stakeholders is very difficult, if not at all impossible. We consider the problem of coping with imperfect information, like interpreting incomplete requirement specifications or vagueness in decisions, one of the main reasons that makes software design difficult. We define a method for tracing design decisions under imperfect information. To model and compare requirements with estimations, we present fuzzy and stochastic techniques. This approach offers adequate decision support that can deal with imperfect information during software design. The approach is illustrated by a real-world example, based on a storm surge barrier system.

Experiences with Auto-adaptive and Reconfigurable Systems (Application Level Adaptation)This is the second part of the special issue on auto-adaptive and reconfigurable systems.The first part of this special issue was dedicated to experience at the system level while this part will focus on the application level.Emerging new technologies enable applications that require autoadaptive software.The new characteristics of these emerging technologies demand innovative approaches.Since the configurations needed in a particular context can hardly be anticipated, the software must support dynamic non-invasive approaches to behavioral adaptation in specific applications.Different applications exhibit different requirements regarding adaptivity and reconfigurability.The development of these applications requires new approaches to designing each specific application architecture in order to enable the application at hand to exhibit dynamic adaptability.In addition, linguistic expressions that can enable the implementation of dynamic adaptability are needed.The papers in this volume present both abstractions and techniques for designing general purpose adaptive and reconfigurable applications and also domain-specific abstractions and techniques for specific applications.'ISAMadapt: abstractions and tools for designing general-purpose pervasive applications', by I. Augustin et al., introduces the ISAMadapt project, which approaches the challenge of supporting 'follow-me' semantics for building generic applications that run in the pervasive environment.The programming abstractions used for building pervasive applications are based on four concepts: context, adapter, adaptation command and policy.Collaborative integration of the application with the middleware that manages the whole pervasive environment is necessary.The ISAM architecture combines the management of pervasive applications at runtime and the design/coding of an application's context aware behaviors into a comprehensive computational model.The paper proposes programming tools to express mobility and context-aware adaptability in a natural way that simplifies the implementation.Practical application of the suggested technology and integration with current technologies are reported as future plans in order to better evaluate the proposal.In 'The FRACTAL component model and its support in Java', by Eric Bruneton et al., a reflective component model is presented to support application level adaptation.The FRACTAL framework allows programmers to enhance components with a user-defined extensible set of reflective capabilities.This feature allows fine-grained manipulation of components' internal structures.JULIA is a Java implementation of the model that provides a small runtime library together with byte code generation using aspect weaving to allow the creation and combination of controller and interceptor classes.FRACTAL and JULIA are currently being used for evaluation and extensions.Some future applications planned by the authors are the development of a dynamic Architecture Description Language (ADL)

We propose a Software Architecture Reliability Analysis (SARA) approach that benefits from both reliability engineering and scenario-based software architecture analysis to provide an early reliability analysis of the software architecture. SARA makes use of failure scenarios that are prioritized with respect to the user-perception in order to provide a severity analysis for the software architecture and the individual components.

Abstract While developing systems, software engineers generally have to deal with a large number of design alternatives. Current object‐oriented methods aim to eliminate design alternatives whenever they are generated. Alternatives, however, should be eliminated only when sufficient information to take such a decision is available. Otherwise, alternatives have to be preserved to allow further refinements along the development process. Too early elimination of alternatives results in loss of information and excessive restriction of the design space. This paper aims to enhance the current object‐oriented methods by modeling and controlling the design alternatives through the application of fuzzy‐logic‐based techniques. By using an example method, it is shown that the proposed approach increases the adaptability and reusability of design models. The method has been implemented and tested in our experimental CASE environment. Copyright © 2001 John Wiley & Sons, Ltd.

Software is rarely designed for ultimate adaptability, performance or reusability but rather it is a compromise of multiple considerations. Even for a simple architecture specification, one may identify many alternative implementations. The paper makes an attempt to depict the space of implementation alternatives of architectures, and to define rules for selecting them. The applicability of this approach is illustrated by means of a simple design problem.

Object-oriented methods aim at providing natural ways for decomposing (or composing) a system into (from) objects that correspond to concepts in the customer's problem domain. The identified objects are the basic building blocks of the object-oriented system to be constructed. In order not to disregard relevant objects, most methods advise software engineers to take dedicated steps such as reading books about the problem domain, interviewing customers, etc. We consider two important concerns in understanding the problem domain. First, it is very important to identify all the objects that are required for defining a consistent system, at least in its minimum configuration. Second, identified objects must serve as composable building blocks to construct robust, adaptable and reusable architectures.

No abstract available.

Abstract SINA is an object‐oriented language for distributed and concurrent programming. The primary focus of this paper is on the object‐oriented concurrent programming mechanisms of SINA and their implementation. This paper presents the SINA constructs for concurrent programming and inter‐object communication, some illustrative examples and a message‐based implementation model for SINA that we have used in our current implementation.

This paper describes a new data abstraction mechanism in an object-oriented model of computing. The data abstraction mechanism described here has been devised in the context of the design of Sina/st language. In Sina/st no language constructs have been adopted for specifying inheritance or delegation, but rather, we introduce simpler mechanisms that can support a wide range of code sharing strategies without selecting one among them as a language feature. Sina/st also provides a stronger data encapsulation than most of the existing object-oriented languages. This language has been implemented on the SUN 3 workstation using Smalltalk.