Computing systems form the backbone of many areas in our society, from manufacturing to traffic control, healthcare, and financial systems. When software plays a vital role in the design, construction, and operation, these systems are referred to as software-intensive systems. Self-adaptation equips a software-intensive system with a feedback loop that either automates tasks that otherwise need to be performed by human operators or deals with uncertain conditions. Such feedback loops have found their way to a variety of practical applications; typical examples are an elastic cloud to adapt computing resources and automated server management to respond quickly to business needs. To gain insight into the motivations for applying self-adaptation in practice, the problems solved using self-adaptation and how these problems are solved, and the difficulties and risks that industry faces in adopting self-adaptation, we performed a large-scale survey. We received 184 valid responses from practitioners spread over 21 countries. Based on the analysis of the survey data, we provide an empirically grounded overview the of state of the practice in the application of self-adaptation. From that, we derive insights for researchers to check their current research with industrial needs, and for practitioners to compare their current practice in applying self-adaptation. These insights also provide opportunities for applying self-adaptation in practice and pave the way for future industry-research collaborations.

Self-adaptation equips a software system with a feedback loop that automates tasks that otherwise need to be performed by operators. Such feedback loops have found their way to a variety of practical applications, one typical example is an elastic cloud. Yet, the state of the practice in self-adaptation is currently not clear. To get insights into the use of self-adaptation in practice, we are running a large-scale survey with industry. This paper reports preliminary results based on survey data that we obtained from 113 practitioners spread over 16 countries, 62 of them work with concrete self-adaptive systems. We highlight the main insights obtained so far: motivations for self-adaptation, concrete use cases, and difficulties encountered when applying self-adaptation in practice. We conclude the paper with outlining our plans for the remainder of the study.

A common need in software project management and process improvement is to detect the occurrence of project mishaps and management mistakes, if possible based on data available from project management and development tools. Process anti-patterns describe such re-occurring problems in textual form intended for human consumption, and the lack of their unambiguous, formalized models hinders their detection in project data. This paper discusses how process anti-patterns can be modeled using Software & System Process Engineering Metamodel (SPEM) and describes an approach to transform such models into queries over data of actual software projects. An implementation of the approach in the form of Eclipse Process Framework Composer plug-in is also presented.

When service-based applications are used in systems where context varies in time or location (mobile, adaptive systems), clients may need to switch service providers for various reasons like temporary outage or geographical relocation. To prevent negative impacts on overall functionality, both the client and the provider need a way of discovering whether the application programming interface (API) of an alternative web service is compatible with client's expected contract. However, the diversity of API specification technologies poses a challenge in such evaluation. Building on previous results, in this paper we present a general model of (web) service APIs, a method for creating corresponding service API representations for several technologies, and a method for comparing these representations to evaluate API compatibility from client's point of view. Both the model and the comparison method have been implemented and verified on real-world services.

Monitoring of environment conditions on a farm using the concepts of Smart Farming is able to bring benefits, by providing analyses backed by data aggregated from previously unavailable breadth of sources. However, it introduces several technical challenges in terms of integrating very heterogeneous data (sensors, vehicles, etc.), validating and fusing these types of data, and turning them into useful information for farmers and agronomists. We describe an open integration architecture designed to address the above challenges and needs, including components we developed and used in validation demonstrators that provide sensor data integration (SensLog) and external systems interoperability (OGC SensorThings API connector).

As the world is getting more connected, the demands of services in automotive industry are increasing with the requirements such as IoT (Internet of Things) in cars, automated driving, etc. Eventually, the automotive industry has evolved to a complex network of services, where each organization depends on the other organizations, to satisfy its service requirements in different phases of the vehicle life cycle. Because of these heterogeneous and complex development environments, most of the vehicle component interface models need to be specified in various manifestations to satisfy the semantic and syntactic requirements, specific to different application development environments or frameworks. This paper describes an approach to semantic analysis of components interfaces description models of heterogeneous frameworks, that are used for vehicle applications. The proposed approach intends to ensure that interface description models of different service-based vehicle frameworks can be compared, correlated and re-used based on semantic synergies, across different vehicle platforms, development environments and organizations. The approach to semantic synergy exploration could further provide the knowledge base for the increase in interoperability, overall efficiency and development of an automotive domain specific general software solutions, by facilitating coexistence of components of heterogeneous frameworks in the same high-performance ECU for future vehicle software.

The use of formal contracts has long been advocated as an approach to develop programs that are provably correct. However, the reality is that adoption of contracts has been slow in practice. Despite this, the adoption of lightweight contracts — typically utilising runtime checking — has progressed. In the case of Java, built-in features of the language (e.g. assertions and exceptions) can be used for this. Furthermore, a number of libraries which facilitate contract checking have arisen. In this paper, we catalogue 25 techniques and tools for lightweight contract checking in Java, and present the results of an empirical study looking at a dataset extracted from the 200 most popular projects found on Maven Central, constituting roughly 351,034 KLOC. We examine (1) the extent to which contracts are used and (2) what kind of contracts are used. We then investigate how contracts are used to safeguard code, and study problems in the context of two types of substitutability that can be guarded by contracts: (3) unsafe evolution of APIs that may break client programs and (4) violations of Liskovs Substitution Principle (LSP) when methods are overridden. We find that: (1) a wide range of techniques and constructs are used to represent contracts, and often the same program uses different techniques at the same time; (2) overall, contracts are used less than expected, with significant differences between programs; (3) projects that use contracts continue to do so, and expand the use of contracts as they grow and evolve; and, (4) there are cases where the use of contracts points to unsafe subtyping (violations of Liskov's Substitution Principle) and unsafe evolution.

The component-based software development enables to construct applications from reusable components providing particular functionalities and simplifies application evolution. To ensure the correct functioning of a given component-based application and its preservation across evolution steps, it is necessary to test not only the functional properties of the individual components but also the correctness of their mutual interactions and cooperation. This is complicated by the fact that third-party components often come without source code and/or documentation of functional and interaction properties. In this paper, we describe an approach for performing rigorous semi-automated testing of software components with unavailable source code. Utilizing an automated analysis of the component interfaces, scenarios invoking methods with generated parameter values are created. When they are performed on a stable application version and their runtime effects (component interactions) are recorded, the resulting scenarios with recorded effects can be used for accurate regression testing of newly installed versions of selected components. Our experiences with a prototype implementation show that the approach has acceptable demands on manual work and computational resources.

This article deals with the issue of how to semi-automatically validate novice programmers' UML class diagrams which document their software assignments. This problem is rather serious given the large numbers of students in the introductory programming courses. The article discusses a self-contained tool which makes it easy to prepare very detailed automated tests (hundreds of them) of UML class diagrams. The tool allows to run these tests and evaluate them both individually and statistically. The described tool, which is freely available, has been used for one year in an elementary course of object oriented programming based on the Java programming language, alongside with three other tools used for automatic validation of students' projects. The article discusses both the tool's principles including a technical solution and the experience gained from its use.

Project Management and Software Process Improvement (SPI) are essential parts of software engineering. A multitude of project management techniques and tools, such as Application Lifecycle Management (ALM) ones, are available, and there is an abundance of software methodologies, process metamodels and best practice descriptions. Despite the role of tools in enacting the processes, the underlying domain models used in these two fields -- ALM tools and software process metamodels -- often significantly differ. This hinders the project execution analysis using the data available from the tools, such as the verification of the project's alignment with a given methodology or the detection of bad practices (anti-patterns). In this paper we describe our work towards enabling such analyses. First we survey the domain models of major process metamodels and tools, and discuss the commonalities and open issues. We then propose a software process metamodel inspired by some of the established metamodels and reflecting the structures of data which can be mined from project management tools. The proposed metamodel is being validated by a prototype process data repository with import interfaces for major ALM tools.

Nowadays, component applications can contain thousands of components whose structure is difficult to understand. As a solution, we proposed a visualization technique that removes large part of connections from component binding diagrams. This technique uses a separated components area to display components with a big amount of connections detached from the main diagram. In this area, component interfaces are shown clustered instead of showing them all. Benefit of this approach is improvement of application understanding by reducing the diagram's visual clutter during its reverse engineering. In this work, we present implementation of the technique in a form of a tool, called CoCA-Ex. CoCA-Ex is a publicly accessible web application and a reverse-engineering solution for various component systems. The tool is built on modern technologies such as HTML5 and JavaScript and has Java EE server backend.

Current software development sees a trend towards modular architectures such as software libraries or components. The main idea is to increase the reusability and decrease the total price and time to ship of a final product. While this trend is slowly meeting its expectation, some issues still need to be solved. One of them is a consistency verification of application components performed before the product is shipped and deployed. Application failures at a target environment caused by the inconsistencies can be more expensive than the overall save of the modular design was. For that reason, we propose a visualisation tool that shows static incompatibilities of components from various component models. We assume this tool helps developers to discover inconsistencies of component applications before they are released.

Nowadays component applications can easily consist of hundreds or thousands of components and it is thus difficult to understand their structure. Diagram visualisation does not help much because of visual clutter caused by big amount of elements and connections, especially in the case of flat component models. This paper describes a novel approach of removing a large part of connections from the diagram while preserving the information about component interconnections. It uses a separated components area to show the components with big amount of connections. For each component in this area, clustered interfaces are shown instead of all interfaces, with the ability to show details on demand. The main idea of this technique can be used in a similar way to reduce the clutter in node-link graphs. To show the effect of this technique we discuss example lines reductions for several component applications.

UML is the state of the art in visualization of software. However, it does not satisfy the needs of modeling in the domain of component applications and complex software architectures. UML has to be extended with profiles so as to be able to model the specifics of a particular component model; its diagrams are not scalable, therefore one has to balance the amount of information and readability; and it presents all the information at once so visual data mining is harder. These were the reasons for developing a completely new approach called AIVA (Advanced Interactive Visualization Approach) that focuses solely on the component domain and addresses the problems of scalability and readability by adopting interactive techniques like information hiding and details on demand. In this paper we analyse how this new approach stands compared with UML by modelling a nontrivial component application.

Nowadays component applications can easily consist of hundreds or thousands of components and it is thus difficult to understand their structure. Earlier, we proposed a novel approach of removing large part of connections from the diagram while preserving the information about component interconnections. It uses a separated components area to remove the components with a big amount of connections from the main diagram. For each component in this area, clustered interfaces are shown instead of all interfaces, with the ability to show details on demand. In this work we present the implementation of this technique as a web application and a reverse-engineering solution for component applications.

The Dependency Injection has been widely implemented in a lot of frameworks to decouple software parts. However, current frameworks use simple matching algorithms to determine candidates to be injected. For instance, Spring does type-based matching, optionally enriched with a qualifier string. This is limiting mainly in dynamic systems where a lot of candidates may exist. As a result, the matching fails and developer's interaction is needed. In this work, we propose to enrich Dependency Injection with extra-functional properties serving as additional parameters of the matching algorithm to reliably select the most suitable candidate.

This work presents an Advanced Interactive Visualization Approach (AIVA) that is able to visualize the structure of many component-based applications. Moreover, AIVA is able to visualize extra-functional properties (EFP) in combination with the traditional visualization of the component structure. To our best knowledge, existing tools cover both areas separately. Hence, the approach of this work fills this gap, in a form of an advanced tool. AIVA is currently being scientifically evaluated, however, the use of extra-functional properties is still in the initial phase. In this paper, we demonstrate our early approach to display a variety of EFPs in a visually convenient manner, integrated in AIVA.

This paper summarizes the experiences gained from the EU project FIT which was aimed at the verification of TTP/C protocol. Several fault injection techniques have been successfully applied during the project, but we focus mainly on the "high level simulation" approach. The key contribution of the paper is a summary of the lessons learned from our experiences with functional verification of embedded systems, using the discrete-time simulation method.

Component platforms play a major role in current distributed information systems. As these systems evolve, components need to be upgraded without breaking the consistency of component interconnections. In this paper we present a method for the support of automated safe upgrades of black-box components. It relates component versioning with indication of changes between revisions of the same component and uses pre-computed information stored in component meta-data. We show how this information is derived from component specifications and used to speed up pre-upgrade checks.

Although software components have become one of the mainstream technologies, they still lack a supportive versioning scheme. This paper describes a system for revision identification of released components with well defined semantics. It is based on the analysis of changes in the component IDL or ADL specification structured into a hierarchy of traits and categories of declarations.