Source tree composition

Dividing software systems in components improves software reusability as well as software maintainability. Components live at several levels, we concentrate on the implementation level where components are formed by source files, divided over directory structures. Such source code components are usually strongly coupled in the directory structure of a software system. Their compilation is usually controlled by a single global build process. This entangling of source trees and build processes often makes reuse of source code components in different software systems difficult. It also makes software systems inflexible because integration of additional source code components in source trees and build processes is difficult. This paper's subject is to increase software reuse by decreasing coupling of source code components. It is achieved by automized assembly of software systems from reusable source code components and involves integration of source trees, build processes, and configuration processes. Application domains include generative programming, product-line architectures, and commercial off-the-shelf (COTS) software engineering

Purely top-down software rebuilding

Software rebuilding is the process of deriving a deployable software system from its primitive source objects. A build tool helps maintain consistency between the derived objects and source objects by ensuring that all necessary build steps are re-executed in the correct order after a set of changes is made to the source objects. It is imperative that derived objects accurately represent the source objects from which they were supposedly constructed; otherwise, subsequent testing and quality assurance is invalidated. This thesis aims to advance the state-of-the-art in tool support for automated software rebuilding. It surveys the body of background work, lays out a set of design considerations for build tools, and examines areas where current tools are limited. It examines the properties of a next-generation tool concept, redo, conceived by D. J. Bernstein; redo is novel because it employs a purely top-down approach to software rebuilding that promises to be simpler, more flexible, and more reliable than current approaches. The details of a redo prototype written by the author of this thesis are explained including the central algorithms and data structures. Lastly, the redo prototype is evaluated on some sample software systems with respect to migration effort between build tools as well as size, complexity, and performances aspects of the resulting build systems

Estimation of the Scope of Change Propagation in Object- Oriented Programs

When minor modifications need to be made in an object-oriented computer program, they often incur further more changes due to presence of dependency in the codes and the program structure. Yet, to accommodate the required change, there can also be more than one option to carry out the initial modifications. To select the modification option in this context, this thesis proposes a systematic approach to estimate the scope of change propagation of an object-oriented program given some initial modifications. The present Master’s thesis seeks to develop an approach to predict the scope of propagated change through the entities of object-oriented software due to a modification in the software. Despite the previous works that just studied the change propagation in object oriented programs from the aspect of high level entities like classes or from the aspect of UML diagrams, we have studied the finer entities of the object oriented program and the relationships among them. In this regard, this thesis has focused on the calculation of probability of change propagation between each two specific types of entities through the analysis of dependency types among the fundamental entities of object-oriented program and categorization of existing dependencies between each couple of entities. Then, we have defined the priority number concept as a representative scale for the scope of change propagation in software based on the probability rules. The strategy is to first capture the dependency relationships of the entities, pertaining to an object-oriented program via the matrix representation. In this work, we have used Design Structure Matrix to capture and trace dependency among software’s entities. Based on this matrix-based model, the priority number method is proposed and applied to estimate the scope of change propagation by assuming some initial modifications. The core of this method is to estimate the chance of affecting other program entities due to some modified entities and the matrix structure. Finally, the obtained results from a case study have been tested to validate the effectiveness of the change propagation probability numbers and priority number concept

Abstracting Dependencies between Software Configuration Items

ing Dependencies between Software Configuration Items Carl A. Gunter University of Pennsylvania http://www.cis.upenn.edu/~gunter Abstract This paper studies an abstract model of dependencies between software configuration items based on a theory of concurrent computation over a class of Petri nets called production nets. A general theory of build optimizations and their correctness is developed based on a form of abstract interpretation called a build abstraction; these are created during a build and used to optimise subsequent builds. Various examples of such optimizations are discussed. The theory is used to show how correctness properties can be characterized and proved, and how optimizations can be composed and compared. 1 Introduction Even a modest software project entails the creation of a collection of what are sometimes called software configuration items. Such items may be held in files, one item per file, or they may be more abstractly described and stored. A ..