Improper management of software evolution, compounded by imprecise, and changing requirements, along with the “short time to market ” requirement, commonly leads to a lack of up-to-date specifications. This can result in software that is characterized by bugs, anomalies and even security threats. Software specification mining is a new technique to address this concern by inferring specifications automatically. In this paper, we propose a novel API specification mining architecture called SMArTIC (Specification Mining Architecture with Trace fIltering and Clustering) to improve the accuracy, robustness and scalability of specification miners. This architecture is constructed based on two hypotheses: (1) Erroneous traces should be pruned from the input traces to a miner, and (2) Clustering related traces will localize inaccuracies and reduce over-generalizationin learning. Correspondingly, SMArTIC comprises four components: an erroneous-trace filtering block, a related-trace clustering block, a learner, and a merger. We show through experiments that the quality of specification mining can be significantly improved using SMArTIC.

Software is often built without specification. Tools to automatically extract specification from software are needed and many techniques have been proposed. One type of these specifications – temporal API specification – is often specified in the form of automaton. There has been much work on reverse engineering or mining software temporal specification, using dynamic analysis techniques; i.e., analysis of software program traces. Unfortunately, the issues of scalability, robustness and accuracy of these techniques have not been comprehensively addressed. In this paper, we describe QUARK(QUality Assurance framewoRK) that enables assessments of the performance of a specification miner in generating temporal specification of software through traces recorded from its API interaction. QUARK requires the temporal specification produced by the miner to be expressed as an automaton. It accepts a user-defined simulator automaton and a specification miner. It produces quality assurance measures on the specification generated by the miner. Extensive experiments on 3 specification miners have been performed to demonstrate the usefulness of our proposed framework. 1

Studies have shown that program comprehension takes up to 45 % of software development costs. Such high costs are caused by the lack-of documented specification and further aggravated by the phenomenon of software evolution. There is a need for automated tools to extract specifications to aid program comprehension. In this paper, a novel technique to efficiently mine common software temporal patterns from traces is proposed. These patterns shed light on program behaviors, and are termed iterative patterns. They capture unique characteristic of software traces, typically not found in arbitrary sequences. Specifically, due to loops, interesting iterative patterns can occur multiple times within a trace. Furthermore, an occurrence of an iterative pattern in a trace can extend across a sequence of indefinite length.Since a program behavior can be manifested in numerous ways, analyzing a single trace will not be sufficient. Iterative pattern mining extends sequential pattern and episode minings to discover frequent iterative patterns which occur repetitively both within a program trace and across multiple traces. In this paper, we present CLIPER (CLosed Iterative Pattern minER) to efficiently mine a closed set of iterative patterns. A performance study on several simulated and real datasets shows the efficiency of our mining algorithm and effectiveness of our pruning strategy. Our case study on JBoss Application Server confirms the usefulness of mined patterns in discovering interesting software behavioral specification.

Abstract. Feature models are widely used in domain engineering to capture common and variant concepts among systems in a particular domain. However, the lack of a formal semantics of feature models has hindered the development of this area. This paper presents a Semantic Web environment for modeling and verifying feature diagrams using ontologies. We use OWL DL (a decidable dialect of OWL) to precisely capture the relationships among features in feature diagrams and configurations. OWL reasoning engines such as RACER are deployed to check for the inconsistencies of feature configurations fully automatically. As part of the environment, we also develop a CASE tool to facilitate the visual development, interchange and reasoning of feature diagrams represented as ontologies. 1

Many variability modeling approaches consider only formalized dependencies, i.e. in- or exclude relations between variants. However, in real industrial product families, dependencies are often much more complicated. In this paper, we discuss the product derivation problems associated with dependencies, and show how our variability modeling framework COVAMOF addresses these issues. Throughout the paper, we use examples of Intrada, an intelligent traffic systems family of Dacolian B.V. 1.

Abstract. From our experience with several organizations that employ software product families, we have learned that deriving individual products from shared software artifacts is a time-consuming and expensive activity. In the research community, product derivation methodologies are rather scarce, however. By studying product derivation, we believe we will be better able to provide and validate industrially practicable solutions for application engineering. In this paper, we present a framework of terminology and concepts regarding product derivation that serves as basis for further discussion. We exemplify this framework with two industrial case studies, i.e. Thales Nederland B.V. and Robert Bosch GmbH. 1

This paper presents a Context-Aware Dynamic Software Product Line (DSPL) for building service oriented applications and adapting them at runtime in accordance with their using context. This DSPL, named CAPucine for Context-Aware Service-Oriented Product Line is based on two different processes for product derivation. The first process uses assets that represent features of the product family. The assets, represented as models, get composed and transformed in order to generate the product. The second process relates to dynamic adaptation. This process introduces context-aware assets that operate at runtime. These context-aware assets contain three kinds of data: the context when the assets can be modified, the place where the assets must be applied and the change that must be performed. The realization of these context-aware assets combines two runtime platforms. On the one hand, COSMOS is a context-aware framework connected to the environment by the use of sensors. On the other hand FraSCAti is a Service Component Architecture (SCA) platform with dynamic properties that enables to bind and unbind components at runtime. 1

We study a novel problem of mining significant recurrent rules from a sequence database. Recurrent rules have the form “whenever a series of precedent events occurs, eventually a series of consequent events occurs”. Recurrent rules are intuitive and characterize behaviors in many domains. An example is in the domain of software specifications, in which the rules capture a family of program properties beneficial to program verification and bug detection. Recurrent rules generalize existing work on sequential and episode rules by considering repeated occurrences of premise and consequent events within a sequence and across multiple sequences, and by removing the “window ” barrier. Bridging the gap between mined rules and program specifications, we formalize our rules in linear temporal logic. We introduce and apply a novel notion of rule redundancy to ensure efficient mining of a compact representative set of rules. Performance studies on benchmark datasets and a case study on an industrial system have been performed to show the scalability and utility of our approach.

Software has been an ubiquitous component in our daily life. It ranges from large software systems like operating systems to small embedded systems like vending machines, both of which we frequently interact with. Software changes often during its lifespan; these cause difficulty in understanding existing systems. Program comprehension is estimated to take up to 45 % of software costs which goes up to billions of dollars. One of the root causes of this problem is the fact that documented software specification is often missing, incomplete or outdated. This causes difficulties in software maintenance efforts especially when a software project involves many people or the project continues over a long period of time. Lack of documented software specification also causes difficulty in testing or verifying the correctness of a software system. Incorrect software has caused the loss of billions of dollars and even the loss of life. One solution to address the above problems is specification discovery, namely, automated extraction of software specification from program artifacts. In this paper, we describe our past and current work in the domains of data mining, software engineering and programming language in addressing the discovery of software specifications with the goal of reducing software costs and improving software dependability. 1

tutorial article, which has been submitted for publication in a journal or for consideration by the commissioning organization. The report represents the ideas of its author, and should not be taken as the official views of the School or the University. Any discussion of the content of the report should be sent to the author, at the address shown on the cover.