Current model-based approaches to software debugging use static program analysis to derive model of the program. In contrast, in the software engineering domain diagnosis approaches are based on analyzing dynamic execution behavior. We present a model-based approach where the program model is derived from dynamic execution behavior, and evaluate its diagnostic performance for both synthetic programs and the Siemens software benchmark, extended by us to accommodate multiple faults. We show that our approach outperforms other model-based software debugging techniques, which is partly due to the use of De Kleer’s intermittency model to account for the variability of software component behavior.

Fault screeners are simple software (or hardware) constructs that detect variable value errors based on unary invariant checking. In this paper we evaluate and compare the performance of two low-cost screeners (Bloom filter, and range screener) that can be automatically integrated within a program, while being automatically trained during the testing phase. While the Bloom filter has the capacity of retaining virtually all variable values associated with proper program execution, this property comes with a much higher false positive rateper unit training effort, compared to the more simple range screener, that compresses all value information in terms of a single lower and upper bound. We present a novel analytic model that predicts the false positive and false negative rate for both type of screeners. We show that the model agrees with our empirical findings. Furthermore, we describe the application of both screeners, where the screener output is used as input to a fault localization process that provides automatic feedback on the location of residual program defects during deployment in the field.

Automated diagnosis of errors detected during software testing can improve the efficiency of the debugging process, and can thus help to make software more reliable. In this paper we discuss the application of a specific automated debugging technique, namely software fault localization through the analysis of program spectra. An important aspect of this technique is the similarity coefficient used to rank potential fault locations. We evaluate the effectiveness of spectrum-based fault localization in a set of benchmark programs. In this context, our experiments indicate that a particular coefficient consistently outperforms the coefficients currently used by other tools. Furthermore, we also applied this technique to an industrial TV software product. We discuss why it is particularly well suited for this application domain, and through experiments on an industrial test case we demonstrate that it can lead to highly accurate diagnoses of realistic errors.

Airborne Self-Separation is a new concept of dynamic management of air traffic flow, where pilots are allowed to select their flight paths in real-time. In this new operational concept, each aircraft is guided by an automated decision procedure and, based on the available information, enters into negotiations with surrounding aircraft in order to coordinate actions and avoid collisions. In this work, we explore the possibility of combining an approach based on Satisficing Game Theory together with fault-tolerant protocols to obtain a robust approach for conflict resolution and air traffic optimization in the context of Airborne Self-Separation.

Algebraic theories for modeling components and their interactions offer abstraction over the specifics of component states and interfaces. For example, such theories deal with forms of sequential composition of two components in a manner independent of the type of data stored in the states of the components, and independent of the number and types of methods offered by the interfaces of the combinators. General purpose programming languages do not offer this level of abstraction, which implies that a gap must be bridged when turning component models into implementations. In this paper, we present an approach to prototyping of component-based systems that employs so-called type-level programming (or compile-time computation) to bridge the gap between abstract component models and their type-safe implementation in a functional programming language. We demonstrate our approach using Barbosa’s model of components as generalized Mealy machines. For this model, we develop a combinator library in Haskell, which uses typelevel programming with two effects. Firstly, wiring between components is computed during compilation. Secondly, the well-formedness of the component compositions is guarded byHaskell’s strong type system.

DHT systems are structured overlay networks capable of using
P2P resources as a scalable platform for very large data storage
applications. However, their efficiency expects a level of uni-
formity in the association of data to index keys that is often
not present in inverted indexes. Index data tends to follow non-
uniform distributions, often power law distributions, creating in-
tense local storage hotspots and network bottlenecks on specific
hosts. Current techniques like caching cannot, alone, cope with
this issue.
We propose a new distributed data structure based on a decen-
tralized balanced tree to balance storage data and network load
more uniformly across all hosts. The approach is stackable with
standard DHTs and ensures that the DHT storage subsystem re-
ceives an uniform load by assigning fixed sized, or low variance,
blocks.