Markus Lumpe

The Qualitas Corpus: A Curated Collection of Java Code for Empirical Studies

In order to increase our ability to use measurement to support software development practise we need to do more analysis of code. However, empirical studies of code are expensive and their results are difficult to compare. We describe the Qualitas Corpus, a large curated collection of open source Java systems. The corpus reduces the cost of performing large empirical studies of code and supports comparison of measurements of the same artifacts. We discuss its design, organisation, and issues associated with its development.

Comparative analysis of evolving software systems using the Gini coefficient

Software metrics offer us the promise of distilling useful information from vast amounts of software in order to track development progress, to gain insights into the nature of the software, and to identify potential problems. Unfortunately, however, many software metrics exhibit highly skewed, non-Gaussian distributions. As a consequence, usual ways of interpreting these metrics — for example, in terms of “average” values — can be highly misleading. Many metrics, it turns out, are distributed like wealth — with high concentrations of values in selected locations. We propose to analyze software metrics using the Gini coefficient, a higherorder statistic widely used in economics to study the distribution of wealth. Our approach allows us not only to observe changes in software systems efficiently, but also to assess project risks and monitor the development process itself. We apply the Gini coefficient to numerous metrics over a range of software projects, and we show that many metrics not only display remarkably high Gini values, but that these values are remarkably consistent as a project evolves over time.

Aligning Qualitative, Real-Time, and Probabilistic Property Specification Patterns Using a Structured English Grammar

Formal methods offer an effective means to assert the correctness of software systems through mathematical reasoning. However, the need to formulate system properties in a purely mathematical fashion can create pragmatic barriers to the application of these techniques. For this reason, Dwyer et al. invented property specification patterns which is a system of recurring solutions to deal with the temporal intricacies that would make the construction of reactive systems very hard otherwise. Today, property specification patterns provide general rules that help practitioners to qualify order and occurrence, to quantify time bounds, and to express probabilities of events. Nevertheless, a comprehensive framework combining qualitative, real-time, and probabilistic property specification patterns has remained elusive. The benefits of such a framework are twofold. First, it would remove the distinction between qualitative and quantitative aspects of events; and second, it would provide a structure to systematically discover new property specification patterns. In this paper, we report on such a framework and present a unified catalogue that combines all known plus 40 newly identified or extended patterns. We also offer a natural language front-end to map patterns to a temporal logic of choice. To demonstrate the virtue of this new framework, we applied it to a variety of industrial requirements, and use PSPWizard, a tool specifically developed to work with our unified pattern catalogue, to automatically render concrete instances of property specification patterns to formulae of an underlying temporal logic of choice.

KBRE: a framework for knowledge-based requirements engineering

Detecting inconsistencies is a critical part of requirements engineering (RE) and has been a topic of interest for several decades. Domain knowledge and semantics of requirements not only play important roles in elaborating requirements but are also a crucial way to detect conflicts among them. In this paper, we present a novel knowledge-based RE framework (KBRE) in which domain knowledge and semantics of requirements are central to elaboration, structuring, and management of captured requirements. Moreover, we also show how they facilitate the identification of requirements inconsistencies and other-related problems. In our KBRE model, description logic (DL) is used as the fundamental logical system for requirements analysis and reasoning. In addition, the application of DL in the form of Manchester OWL Syntax brings simplicity to the formalization of requirements while preserving sufficient expressive power. A tool has been developed and applied to an industrial use case to validate our approach.

Formalizing Composable Software Systems — A Research Agenda

Flexibility is achieved in open systems by adopting software architectures that allow software components to be easily plugged in, adapted and exchanged. But open systems are generally concurrent, distributed and heterogeneous in addition to being adaptable. Ad hoc approaches to specifying component frameworks can lead to unexpected semantic conflicts. We propose, instead, to develop a rigorous foundation for composable software systems by a series of experiments in modelling concurrent and object-based software abstractions as composable, communicating processes. Eventually we hope to identify and realize the most useful compositional idioms as a composition language for open systems specification.

Agent coordination via scripting languages

In recent years, so-called scripting languages have become increasingly popular as they provide means to build quickly flexible applications from a set of prefabricated components. These languages typically support a single, specific architectural style of composing components (e.g. the pipes and filters architectural style), and they are designed to address a specific application domain. Although scripting languages and coordination languages have evolved from different roots and have been developed to solve different problems, we argue that both address similar separations of concerns. Scripting languages achieve a separation of components from the scripts that configure and compose them, whilst coordination languages separate computational entities from the coordination code that manages dependencies between them. In this chapter we will define coordination in the context of a conceptual framework for component-based software development. Furthermore, we will discuss main properties and abstractions of scripting languages and will compare selected scripting languages with respect to the identified core concepts. Finally, using a small set of sample applications, we will illustrate the power and the limitations of these concepts in order to define agent coordination.

A form-based meta-model for software composition

In recent years considerable progress has been made in facilitating the specification and implementation of software components. However, it is far less clear what kind of language support is needed to enable a flexible and reliable software composition approach. Object-oriented programming languages seem to already offer some reasonable support for component-based programming (e.g., encapsulation of state and behavior, inheritance, late binding). Unfortunately, these languages typically provide only a fixed and restricted set of mechanisms for constructing and composing compositional abstractions.In this article, we will present a generic meta-level framework for modeling both object-and component-oriented programming abstractions. In this framework, various features, which are typically merged in traditional object-oriented programming languages, are all replaced by a single concept: the composition of forms. Forms are first-class, immutable, extensible records that allow for the specification of compositional abstractions in a language-neutral and robust way. Thus, using the meta-level framework, we can define a compositional model that provides the means both to bridge between different object models and to incorporate existing software artifacts into a unified composition system.

Patterns of component evolution

Contemporary software systems are composed of many components, which, in general, undergo phased and incremental development. In order to facilitate the corresponding construction process, it is important that the development team in charge has a good understanding of how individual software components typically evolve. Furthermore, software engineers need to be able to recognize abnormal patterns of growth with respect to size, structure, and complexity of the components and the resulting composite. Only if a development team understands the processes that underpin the evolution of software systems, will they be able to make better development choices. In this paper, we analyze recurring structural and evolutionary patterns that we have observed in public-domain software systems built using object-oriented programming languages. Based on our analysis, we discuss common growth patterns found in present-day component-based software systems and illustrate simple means to aid developers in achieving a better understanding of those patterns. As a consequence, we hope to raise the awareness level in the community on how component-based software systems tend to naturally evolve.

State Space Reduction Techniques for Component Interfaces

Automata-based interface and protocol specifications provide an elegant framework to capture and automatically verify the interactive behavior of component-based software systems. Unfortunately, the underlying formalisms suffer from combinatorial state explosionwhen constructing new specifications for composite components or systems and may therefore render the application of these techniques impractical for real-world applications. In this paper, we explore the bisimulationtechnique as a means for a mechanical state space reduction of component-based systems. In particular, we apply both strong and weak bisimulation to Component Interaction Automatain order to obtain a minimal automatathat can serve as a behavioral equivalent abstraction for a given component specification and illustrate that the proposed approach can significantly reduce the complexity of an interface specification after composition.

On the Application of Inequality Indices in Comparative Software Analysis

Socio-economic inequality indices, like the Gini coefficient or the Theil index, offer us a viable alternative to central tendency statistics when being used to aggregate software metrics data. The specific value of these inequality indices lies in their ability to capture changes in the distribution of metrics data more effectively than, say, average or median. Knowing whether the distribution of one metrics is more unequal than that of another one or whether its distribution becomes more or less unequal over time is the crucial element here. There are, however, challenges in the application of these indices that can result in ecological fallacies. The first issue relates to occurrences of zeros in metrics data, and not all inequality indices cope well with this event. The second problem arises from applying a macro-level inference to a micro-level analysis of a changing population. The Gini coefficient works for the former, whereas the decomposable Theil index serves the latter. Nevertheless, when used with care, and usually in combination, both indices can provide us with a powerful tool not only to analyze software, but also to assess its organizational health and maintainability over time.