A language for software subsystem composition

Reverse engineering aims at obtaining high-level representations of software systems from existing low-level artifacts, such as binaries, source code, execution traces or historical information. Reverse engineering methods and technologies play an important role in many software engineering tasks and quite often are the only way to get an understanding of large and complex software systems. Given for example the task to understand certain aspects of the test code in large software systems, such as Eclipse. How would you figure out the answers to the following questions:

Certain software defects require corrective changes repeatedly in a few components of the system. One type of such defects spans multiple components of the system, and we call such defects pervasive multiple-component defects (PMCDs). In this paper, we describe an empirical study of six releases of a large legacy software system (of approx. size 20 million physical lines of code) to analyze PMCDs with respect to: (1) the complexity of fixing such defects and (2) the persistence of defect-prone components across phases and releases. The overall hypothesis in this study is that PMCDs inflict a greater negative impact than do other defects on defect-correction efficacy. Our findings show that the average number of changes required for fixing PMCDs is 20-30 times as much as the average for all defects. Also, over 80% of PMCD-contained defect-prone components still remain defect-prone in successive phases or releases. These findings support the overall hypothesis strongly. We compare our results, where possible, to those of other researchers and discuss the implications on maintenance processes and tools.

The detection of function clones in software systems is valuable for the code adaptation and error checking maintenance activities. This paper presents an efficient metrics-based data mining clone detection approach. First, metrics are collected for all functions in the software system. A data mining algorithm, fractal clustering, is then utilized to partition the software system into a relatively small number of clusters. Each of the resulting clusters encapsulates functions that are within a specific proximity of each other in the metrics space. Finally, clone classes, rather than pairs, are easily extracted from the resulting clusters. For large software systems, the approach is very space efficient and linear in the size of the data set. Evaluation is performed using medium and large open source software systems. In this evaluation, the effect of the chosen metrics on the detection precision is investigated.

Lab 8 - Getting Familiar with Code Composer Studio

For large software systems, refactoring activities can be a challenging task, since for keeping component complexity under control the overall architecture as well as many details of each component have to be considered. Product metrics are therefore often used to quantify several parameters related to the modularity of a software system. This paper devises an approach for automatically suggesting refactoring opportunities on large software systems. We show that by assessing metrics for all components, move methods refactoring an be suggested in such a way to improve modularity of several components at once, without hindering any other. However, computing metrics for large software systems, comprising thousands of classes or more, can be a time consuming task when performed on a single CPU. For this, we propose a solution that computes metrics by resorting to GPU, hence greatly shortening computation time. Thanks to our approach precise knowledge on several properties of the system can be continuously gathered while the system evolves, hence assisting developers to quickly assess several solutions for reducing modularity issues.

Translating each of a UNIX software system's source files into an object file, and linking the object files into an executable file, can be a time-consuming process. Object file generation accounts for most of this time. Tools that recognize and avoid unnecessary object file regeneration are very popular. Many such tools are named MAKE. A software system often contains a parameter file. A parameter file is a source file, textually included by every other source file, which defines macros shared by multiple source files. Each object file depends on the parameter file, according to file dependencies. MAKE-like tools only understand file dependencies. So, when a software developer changes a macro in a parameter file, every object file is regenerated, regardless of whether its corresponding source file actually refers to the changed macro. Unnecessary object file regeneration can be avoided by replacing some file dependencies with macro dependencies, which express that an object file depends on a macro. DEP is a tool implementing a method for automatically detecting and maintaining a software system's file and macro dependencies. DEP works with any flavour of MAKE to minimize the cost of rebuilding an executable file.

Large software systems are often deployed putting together many Commercial-Off-The-Shelf software components (COTS). The selection of the COTS to be integrated is driven by the software system requirements. In this paper, we propose the RECSS method aimed at supporting requirements elicitation and analysis in the context of COTS-based software systems. RECSS builds a goal model of the system environment which identifies the external elements that interact with it. Next, the system is decomposed into actors for which ISO/IEC-based quality models are built. As part of the process, environmental and platform characteristics that influence the behaviour of the system are identified. Last, the resulting artefacts are used to analyse and refine the system requirements.

Software systems continue to play an increasingly important role in our daily lives, making the quality of software systems an extremely important issue. Therefore, a significant amount of recent research focused on the prioritization of software quality assurance efforts. One line of work that has been receiving an increasing amount of attention is Software Defect Prediction (SDP), where predictions are made to determine where future defects might appear. Our survey showed that in the past decade, more than 100 papers were published on SDP. Nevertheless, the practical adoption of SDP to date is limited. In this paper, we highlight the findings of our thesis, which identifies the challenges that hinder the adoption of SDP in practice. These challenges include the fact that the majority of SDP research rarely considers the impact of defects when performing their predictions, seldom provides guidance on how to use the SDP results, and is too reactive and defect-centric in nature. Therefore, we propose approaches that tackle these challenges. First, we present approaches that predict high-impact defects. Our approaches illustrate how SDP research can be tailored to consider the impact of defects when making their predictions. Second, we present approaches that simplify SDP models so they can be easily understood and illustrates how these simple models can be used to assist practitioners in prioritizing the creation of unit tests in large software systems. These approaches illustrate how SDP research can provide guidance to practitioners using SDP. Then, we argue that organizations are interested in proactive risk management, which covers more than just defects. For example, risky changes may not introduce defects but they could delay the release of projects. Therefore, we present an approach that predicts risky changes, illustrating how SDP can be more encompassing (i.e., by predicting risk, not only defects) and proactive (i.e., by predicting changes before they are incorporated into the code base).

Highly-configurable software systems can be easily adapted to address user's needs. Modelling parameter configurations and their relationships can facilitate software reuse. Combinatorial Interaction Testing (CIT) methods are already often used to drive systematic testing of software system configurations. However, a model of the system's configurations not conforming with respect to its software implementation, must be repaired in order to restore conformance. In this paper we extend CIT by devising a new search-based technique able to repair a model composed of a set of constraints among the various software system's parameters. Our technique can be used to detect and fix faults both in the model and in the real software system. Experiments for five real-world systems show that our approach can repair on average 37% of conformance faults. Moreover, we also show it can infer parameter constraints in a large real-world software system, hence it can be used for automated creation of CIT models.

Insights and assessments about the quality, reliability, or trustworthiness of software systems is important for many software applications. Especially for large or mission-critical software systems, reliable measures and assertions are crucial. Since software repositories contain information about source code, software development processes, and team interactions, we extract the provenance of software artifacts from those repositories and store the provenance according to a provenance model defined using W3C PROV data model. We use the recorded provenance to discover insights about the software and its development process, which we apply and evaluate for a large aerospace software system.

Trends and aspects of the development of large finite element software systems

Program slicing is a useful reduction technique in many areas such as debugging and testing, and thus, there has also been some research to try and apply slicing techniques to flat state-based models at the design level, for their maintenance and quality improvement. However, such state-based models have difficulties in specifying large and complex software systems, and so the benefit obtained from slicing such models, is very limited. In contrast, UML state machine diagrams can properly describe the behavior of large software systems; but it is difficult to apply a slicing algorithm to automatically reduce the diagram with respect to a point of interest, because of the unique properties (such as hierarchy and orthogonality) of these diagrams. In this paper, we identify important issues relevant to the slicing of UML state machine diagrams with regards to data and control dependence. We also show why the unique properties of these diagrams are important to consider when retrieving data and control dependence information, by virtue of an illustrative example.

Effort for development and maintenance of complex large software is believed to have dependency on the amount of duplicated code fragments (code clones) present in code-bases. For example, clones need to be carefully and consistently maintained and/or refactored for preventing accidental error propagation. Thus it is important to understand the proportion and evolution of clones in evolving software systems for cost estimation or the like. This paper presents a study on the evolution of near-miss clones at release level in medium to large open source software systems of different types (operating systems, database systems, editors, etc.) written in three different programming languages namely C, C#, and Java. Using a hybrid clone detector, NiCad, we detected both exact and near-miss clones at different levels of similarity. Applying statistical methods we investigated, from different dimensions, the evolution of both exact and near-miss clones, and also forecasted the amount of clones in future releases of the software systems. Our study offers significant insights into the existence and evolution of code clones and their relationships with programming language or paradigm and program size.

While management of today's software systems is usually performed by humans using some user interface (UI), autonomic systems would be self-managed. They would typically consist of a managed element, which provides actual system functionality, and an autonomic manager performing system management. However, truly self-managed systems are hard to achieve and not (yet) in wide-spread use. During the transition towards autonomic software systems it is more realistic to manage a large and complex software system partly by humans and partly by an autonomic manager. For facilitating this approach, the communication between the managed element and human administrators on the one hand and the communication between the managed element and the autonomic manager on the other, should be unified and specified on the same semantic level. However, there is no scientific basis for such a unified communication approach.We present a unified specification of this communication in a high-level discourse model based on insights from theories of human communication. This approach would make this communication natural for humans to define and to understand. In addition, we propose to use the same specification for the automated generation of user interfaces for management by human administrators. As a consequence, a smooth and gradual transition towards self-managed software systems will be facilitated, where the portion managed by human administrators becomes smaller and smaller.

Process- and data-centric software systems require a tight integration of processes, functions, data, and users. Thereby, the behavioral perspective is described by process models, while the information perspective is captured in a data model. Eliciting and capturing requirements of such software systems in a consistent way is a challenging task, demanding that both process and data model are well aligned and consistent with each other. While traditional software modeling languages do not allow for an explicit integration of data and process models, activity-centric process modeling languages tend to neglect the role of data as a driver of process execution; i.e., business objects are usually outside the control of the process, normally stored in external databases. To overcome this drawback, PHILharmonicFlows provides a comprehensive framework for enabling object-aware process support. In addition, a sound specification of process- and object-centric software systems becomes possible. In this paper, we present a requirements modeling approach that provides methodological guidance for modeling large process-and data-centric software systems based on PHILharmonicFlows. Such guidance will foster the introduction of respective software systems in the large scale.