Analysis of Feature Models using Generalised Feature Trees

This paper introduces the concept of generalised feature trees, which are feature trees where features can have multiple occurrences. It is shown how an important class of feature models can be transformed into generalised feature trees. We present algorithms which, after transforming a feature model to a generalised feature tree, compute properties of the corresponding software product line. We discuss the computational complexity of these algorithms and provide executable specifications in the functional programming language Miranda

Modelling Software Evolution using Algebraic Graph Rewriting

We show how evolution requests can be formalized using algebraic graph rewriting. In particular, we present a way to convert the UML class diagrams to colored graphs. Since changes in software may effect the relation between the methods of classes, our colored graph representation also employs the relations in UML interaction diagrams. Then, we provide a set of algebraic graph rewrite rules that formalizes the changes that may be caused by an evolution request, using the pushout construction in the category of marked colored graphs

Fuzzy Weighted Average: Analytical Solution

An algorithm is presented for the computation of analytical expressions for the extremal values of the α-cuts of the fuzzy weighted average, for triangular or trapeizoidal weights and attributes. Also, an algorithm for the computation of the inverses of these expressions is given, providing exact membership functions of the fuzzy weighted average. Up to now, only algorithms exist for the computation of the extremal values of the α-cuts for a fixed value of α. To illustrate the power of our algorithms, they are applied to several examples from the literature, providing exact membership functions in each case

Modeling the object-oriented software process: OPEN and the unified process

A short introduction to software process modeling is presented, particularly object-oriented modeling. Two major industrial process models are discussed: the OPEN model and the Unified Process model. In more detail, the quality assurance in the Unified Process tool (formally called Objectory) is reviewed

Dealing with Fuzzy Information in Software Design Methods

Software design methods incorporate a large set of heuristic rules that should result in stable software architecture of high quality. In general, clearly defined inputs are required to deliver the desired results. Unfortunately, especially in the early phases of software development, it is very difficult or even impossible to provide precisely defined information. Since methods cannot deal with imprecision, the designers need to make approximations which are generally not justifiable. In this paper, we will advocate an approach where the inputs for software design methods are modeled by using fuzzy sets. This approach renders the need for introduction of extra information for removal of inexactness obsolete

A Model for Quality Optimization in Software Design Processes

The main objective of software engineers is to design and implement systems that implement all functional and non-functional requirements. Unfortunately, it is very difficult or even generally impossible to deliver a software system that satisfies all the requirements. Even more seriously, failures in fulfilling requirements are generally detected after the realization of software systems. This is because design decisions are mostly taken based on estimations, which can turn out to be wrong at a later stage in the design process. Switching to different design alternatives at a later stage can be very difficult since this may demand drastic changes in design and also may increase project time and costs. In this paper a model is proposed for modeling and tracing design processes with respect to the selected design alternatives. Based on the model, two algorithmic definitions of design strategies are given, which enable software engineers to optimize design decisions with respect to quality and resource constraints

A Taxonomy for a Constructive Approach to Software Evolution

In many software design and evaluation techniques, either the software evolution problem is not systematically elaborated, or only the impact of evolution is considered. Thus, most of the time software is changed by editing the components of the software system, i.e. breaking down the software system. The software engineering discipline provides many mechanisms that allow evolution without breaking down the system; however, the contexts where these mechanisms are applicable are not taken into account. Furthermore, the software design and evaluation techniques do not support identifying these contexts. In this paper, we provide a taxonomy of software evolution that can be used to identify the context of the evolution problem. The identified contexts are used to retrieve, from the software engineering discipline, the mechanisms, which can evolve the software software without breaking it down. To build such a taxonomy, we build a model for software evolution and use this model to identify the factors that effect the selection of software evolution\ud mechanisms. Our approach is based on solution sets, however; the contents of these sets may vary at different stages of the software life-cycle. To address this problem, we introduce perspectives; that are filters to select relevant elements from a solution set. We apply our taxonomy to a parser tool to show how it coped with problematic evolution problems

Evolvability as a Quality Attribute of Software Architectures

We review the definition of evolvability as it appears on the literature. In particular, the concept of software evolvability is compared with other system quality attributes, such as adaptability, maintainability and modifiability