Software Reuse: Methods, Techniques, and Tools

Graphical User Interface (GUI) Driven Applications (GDAs) are ubiquitous. We present a model and techniques that take closed and monolithic GDAs and integrate them into an open, collaborative environment. The central idea is to objectify the GUI of a GDA, thereby creating an object that enables programmatic control of that GDA.We demonstrate a non-trivial application of these ideas by integrating a stand-alone internet application with a stand-alone Win32 application, and explain how PDAs (Personal Digital Assistants) can be used to remotely control their combined execution. Further, we explain how Integrated Development Environment (IDEs) may be extended to integrate and reuse GDAs using our approach. We believe our work is unique: we know of no other technology that could have integrated the GDAs of our example.

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.

Layered software development has demonstrably good reuse properties and offers one of the few promising approaches to addressing the library scalability problem. In this paper, we show how one can develop layered software using common Unix (Linux/Solaris) dynamic libraries. In particular, we show that, from an object-oriented design standpoint, dynamic libraries are analogous to components in a mixin-based object system. This enables us to use libraries in a layered fashion, mixing and matching different libraries, while ensuring that the result remains consistent. As a proof-of-concept application, we present two libraries implementing file versioning (automatically keeping older versions of files for backup) and application-transparent locking in a Unix system. Both libraries can be used with new, aware applications or completely unaware legacy applications. Further, the libraries are useful both in isolation, and as cooperating units.

Generic software components have a reputation for being inefficient. Parallel implementations may improve performance, but can thwart reuse by being architecture-dependent or by exposing concurrency to client-side reasoning about component interactions. To address performance, we present Early-Reply as an alternative to blocking method invocations. Component operations can be partitioned into a material computation required to satisfy the postcondition, and a residual computation required to reëstablish the component invariant, optimize its representation, etc. Early-Reply exploits opportunities for parallelism by forwarding final parameter values to the caller as soon as the material computation completes, thereby offloading the residual computation to execute in parallel with subsequent client activities. Proof obligations for Early-Reply support a synchronous calling model, so clients can still reason sequentially about component behavior. Also, since Early-Reply components do not depend on system-wide support for component synchronization, they can be deployed incrementally. Finally, Early-Reply can improve the response time of idle components by orders of magnitude; when composed hierarchically, performance benefits are magnified by the potential fan-out of concurrently executing components.

Product line software engineering (PLSE) is an emerging software engineering paradigm, which guides organizations toward the development of products from core assets rather than the development of products one by one from scratch. In order to develop highly reusable core assets, PLSE must have the ability to exploit commonality and manage variability among products from a domain perspective. Feature modeling is one of the most popular domain analysis techniques, which analyzes commonality and variability in a domain to develop highly reusable core assets for a product line. Various attempts have been made to extend and apply it to the development of software product lines. However, feature modeling can be difficult and time-consuming without a precise understanding of the goals of feature modeling and the aid of practical guidelines. In this paper, we clarify the concept of features and the goals of feature modeling, and provide practical guidelines for successful product line software engineering. The authors have extensively used feature modeling in several industrial product line projects and the guidelines described in this paper are based on these experiences.

This paper describes a domain modeling approach using the Unified Modeling Language (UML) for modeling software product lines of World Wide Web (WWW) based applications, thereby permitting reuse of domain requirements and analysis models. The paper describes how the various views of the UML, in particular the use case modeling view and the static modeling view, may be used for modeling such product lines and illustrates this with a domain modeling exercise. It also describes how the feature model can be integrated with the UML for modeling product lines.

The idea of building software systems from semi-autonomous components that can be reused in numerous applications is intuitively appealing. However, simply organizing software systems in terms of components does not by itself ensure that the components will be reusable, or that significant levels of reuse will actually occur. In practice, to achieve meaningful levels of reuse the scope and generality of components must be carefully analyzed and optimized. In this paper we make the case that one of the most effective and systematic ways of achieving this is to complement component-based development with product line engineering techniques. Product line engineering not only provides concrete criteria for maximizing the reusability of components, but also provides enhanced mechanisms for reusing them within new applications. After first outlining the pertinent features of component-based development and product line engineering, the paper explains how they can be integrated under the umbrella of a model-driven architecture (MDA) approach to software development.

A major challenge for software reuse is developing components that can be reused in several applications. This paper describes a systematic method for providing components that can be extended through variation points, as initially specified in the software requirements. Allowing the reuser or application engineer to extend components at pre-specified variation points creates a more flexible set of components. The existing variation point methods do not provide enough design detail for the reuser. This paper introduces a method called the Variation Point Model (VPM), which models variation points at the design level, beginning with the common requirements.

One of the most intriguing ways that commercial developers of software can become more efficient is to reuse not only software but also best practices from the open-source movement. The open-source movement encompasses a wide collection of ideas, knowledge, techniques, and solutions. Commercial software vendors have an opportunity to both learn from the open-source community, as well as leverage that knowledge for the benefit of its commercial clients. This paper looks at a number of the characteristics of the open-source movement, offers a categorization of open-source dimensions, and provides an analysis of the opportunities available to commercial software vendors when applying the lessons from the open-source movement.

When developing a product line, the definition of an appropriate reference architecture that supports the required variabilities is of crucial importance to the success of the product line. In this paper we present an approach to the identification of the key variabilities and to determining the economic benefit of packaging these variabilities in terms of reusable components. This approach provides reusability requirements that can then be taken as an input to product line development. The analysis is based on the economics of the product line. Thus, the approach ensures the optimization of the economic benefit of a product line that is based on a reference architecture that takes these reusability requirements into account.In this paper, we will describe our approach for deriving the reusability requirements, discuss its relationship to different possible investment scenarios, and study the results of the application of our approach in some case studies.

Domain specific languages (DSLs) excel at programming productivity because they provide large-grain composite data structures (e.g., a graphics image) and large-grain operators for composition (e.g., image addition or convolution). As a result, extensive computations can be written as APL-like one-liners that are equivalent to tens or hundreds of lines of code (LOC) when written in a conventional language like Java. The problem with DSL specifications is that they de-localize the code components making un-optimized machine translations significantly slower than for the human optimized equivalent. Specifically, operations on DSL composites imply multiple control structures (e.g., loops) that process the individual elements of large-grain composites and those multiple, implicit control structures are distributed (i.e., de-localized) across the expression of operators and operands. Human programmers recognize the relation among these distributed control structures and merge them to minimize the redundancy of control. For example, merged control structures may perform several operations on several large-grain data structures in a single pass. This merging is the process of control localization. This paper discusses strategies for automating localization without large search spaces and outlines a domain specific example of transformation rules for localizing control. The example is based on the localization method in the Anticipatory Optimization Generator (AOG) system [3-8].

Metamodel-based transformations permit descriptions of mappings between models created using different concepts from possibly overlapping domains. This paper describes the basic algorithms used in matching metamodel constructs, and how this match is to be applied. The transformation process facilitates the reuse of models specified in one domain-specific modeling language in another context: another domain-specific modeling language. UML class diagrams are used as the language of the metamodels. The focus of the paper is on the matching and firing of transformation rules, and on finding efficient and generic algorithms. An illustrative case study is provided.

In this paper we present an example of a software infrastructure to support domain engineering activities. An important piece of the infrastructure is the ability to connect the outputs of the domain analysis to the inputs of the domain implementation. The combination of XML and Java provides a very interesting alternative to classical parser generation tools. XML can be used as a specification language to describe programs. In this paper we will describe how to connect the output of a domain analysis tool to a program generator. We will also describe how to use Java and XML tools to write program generators in Oracle9i. We will show how we can specify a search engine application in XML and how the generator can produce code for three different languages: Java Server Pages, PL/SQL, and PL/SQL Server Pages.

Domain Network (DN) is a set of domains interconnected by transformations. A previous implementation of this concept has been done by using the Draco-Puc machine, a software system that provides a very powerful transformation engine. In order to obtain the integration of this DN with approaches that use XML related technologies, we present a new DN implementation that allows an XML application to become a Draco-Puc domain. We believe that in this way we can use the power of Draco-Puc and gain a broadly use of DN by enabling the use of XML applications.

Use cases are a part of common practice for capturing functional requirements for object-oriented software development. But, as with any artifact, there is a cost of producing them. Reusing use cases can reduce this cost. We discuss how use cases can be made reusable, in particular looking at the reusability of essential use cases. We also introduce Ukase, a web-based use case management tool that provides support for the reuse of use cases.

Project management is a knowledge intensive activity. Managers use their skills and experience to make decisions during the execution of a software development process. Better results in terms of attending to schedule, budget, and functionality, are usually achieved due to managers’ accumulated experiences and knowledge. In this paper we address the creation and reuse of software project management knowledge. We present a knowledge representation, namely scenario models, which allows a manager to verify the impact of theories, procedures, actions, and strategies that can be applied or imposed upon a software project. Scenario models compose a reusable knowledge base useful for project managers, who can reuse scenarios to assess the impact of their assumptions upon their projects. We present an application of the proposed approach within a risk management process and the results from a first experimental analysis of the techniques.

In this work we introduce an automatic adaptation approach for Coloured Petri Nets models. For this approach we define a procedure for the synthesis of a new model based on a given model and a set of behavior restrictions. This procedure was defined based on the concepts and techniques of the supervisory control theory and model checking. Moreover, we tackle the adaptation problem in the context of models reuse.

Descriptive arguments are an intrinsic part of the process of determining the dependability of any system, particularly in the case of safety critical systems. For such systems, safety cases are constructed to demonstrate that a system meets dependability requirements. This process includes the application of hazard analysis techniques. However, such techniques are error-prone, time consuming and apply “ad hoc” reuse. Hence, the use of systematic, exhaustive hazard analysis can lead to an illusion of high confidence in the parent dependability argument that is compromised by lack of rigour.We have investigated the application of structure and reuse techniques to improve hazard classification arguments and their associated parent dependability arguments. A structure for hazard arguments has been presented and an example from a software hazard analysis has been exemplified using XML. Using two methods of structural reuse, hazard arguments can be improved for both argument generation and post argument construction analysis.

In recent years, web sites have evolved from simple collections of static content to suppliers of complex services to users. This evolution has allowed users to benefit from various customized services according to his needs. Currently many services are geographically-aware and they have localized features but do not communicate with systems that are complementary from a geographic of functional perspectives. However, the geographic extensity is a natural dimension on which simple services can be integrated into complex ones. This integration requires a container to provide a common and unifying view of the territory. A GIS with topological information is the ideal mapping for services that pertain to a given territory. Integration provides a way to create new services through reusing services that provide only a subset of functionality that could be used in very different integrated services. This paper analyzes the integration issues of localized services using a GIS.

This paper reports an empirical user study of an active reuse repository system. Instead of waiting passively for software developers to initiate the component location process with a well-defined reuse query, active reuse repository systems infer reuse queries from syntactic and semantic cues present in partially constructed programs in development environments, and proactively deliver components that match the inferred reuse queries. The reported empirical user study of an implemented active reuse repository system called CodeBroker shows that active repository systems promote reuse by motivating and enabling software developers to reuse components whose existence is not anticipated, and reducing the cost of reuse through the automation of the component location process.

As industry and academia embrace component and object-based design models, programming languages, technologies, and tools, they are outpacing our ability to formally define models and frameworks supporting organization and domain specific reuse. For software engineers to accurately assess potential and actual reuse of software artifacts, we must transition from ad-hoc reuse to a evaluative paradigm that achieves reuse of an organization’s current and future products. Towards this goal, our previous work has provided a framework for reusability assessment of components and classes via metrics and refactoring guidelines. In this paper, we work towards the formalization of this reusability framework. Our objectives and contributions are: a set of properties for the assumptions of the reusability framework; the formalization of class coupling, class generality, and related class concepts which under-lie reuse assessment and refactoring; a reusability improvement factor to capture refactoring gain (or loss); and a refactoring algorithm for improving reusability.

It is widely agreed that component interactions should be based on the import and export of interface information only, not on knowledge of implementation-specific details. This can be achieved in many cases either by explicit parameterization using templates (in languages that have them) or by using some variant of the abstract factory pattern. We introduce an alternative: the use of service facilities. This technique is similar both to the use of templates and to the use of factories, but it is preferable to both in several important ways. Service facilities can be used to decouple design-time concrete-to-concrete component dependencies in any reasonable programming language and with any component infrastructure that is based on design-by-contract principles.

Don’t try to choose between J2EE and .NET, use them both! Just use a unifying architecture that recognizes the strengths and weaknesses of each platform. We propose a new model for enterprise systems called the Software Fortress Model. The Software Fortress Model treats enterprise systems as a series of self contained, mutually suspicious, marginally cooperating software fortresses (perfect for J2EE and .NET!). Each fortress makes its own choices as to software platform and data storage mechanisms and interacts with other fortresses through carefully crafted treaties. This helps enterprises focus on the critical issues of security and platform interoperability.

Theories and design principles of a general nature will be far too weak to be of much value to the practitioners. We should develop specialized theories that are applicable in specific domains, and we should work on binding these theories and principles much like the way we structure large systems today. Functional programming, for instance, provides impressive facilities for modularization, programming in layers and program integration. However, several important areas are not covered by the functional style of programming: non-determinism, persistent storage management, and matrix-based computations, for instance. There seem to be no easy extensions of functional-based system to include these domains.I suggest that we abandon the idea of a Grand Unification Theory, and design specialized theories that handle a few things well. We should be studying how the capabilities of functional programming and object-based programming, for instance, can be integrated, different theories being applicable in each domain. The challenge lies in seamless integration. This proposal amounts to a strong prescription for empiricism, that we have to do a large number of experiments to understand where theories can play a role, and which kinds of theories would be most appropriate and when. Examples of a few small theories will be given and their effectiveness and limitations will be illustrated.

The workshop aims at providing a platform for young researchers in the software reuse community to present their work. Presentations of all participants will be commented by experienced panelists and briefly discussed. As a result, all participants will get useful guidance and fresh impetus to their ongoing research. The workshop serves as a forum for the participants to get in contact with other researchers in the field and to become familiar with other approaches and future research topics.

Traditionally reuse economics has by and large concentrated on return on investment in formal, systematic reuse based on traditional cost-benefit models. Of prime importance in that context was cost savings, and more recently cost avoidance. Reuse was rationalized as a solution to minimizing wasteful consumption of resources through amortization of an artifact’s development cost over multiple uses. The world has evolved since then. First, increased uncertainty in the software sector and technology in general have gradually shifted the focus from cost savings and cost avoidance to strategic issues of value generation, value management and risk. How does reuse create value in the context of strategic business decision-making? Second, the scope of reuse has evolved from type and class libraries to the entire architectural design process. Reuse economics is thus of prime concern when choosing among competing technologies and paradigms, and when applying them in a given context. How can our understanding of reuse economics leverage technical decision-making? Third, the value of software today is determined to a considerable degree by external market forces. What impact does reuse have on market perception of software value? The goal of this workshop was to bring together interested practitioners and researchers to exchange ideas and experiences, discuss current and emerging practices, and introduce next-generation concepts.

Background. The goal of generative programming is to replace manual search, adaptation, and assembly of components with the automatic generation of needed components on demand. Generative technology has been in practical use for decades (e.g., compiler development, application generation, automatic configuration management, preprocessing, and meta-programming). However, developing new domain-specific languages (DSLs), application generators, and component generators has been extremely hard, as it requires being knowledgeable and experienced both in language design and compiler development. Recent developments such as XML technologies and template meta-programming revived the interest in generative programming by making it more accessible to developers.

Practitioners as well as academics claim that the component-based software development paradigm is of major importance for the field of software engineering, and expect that in the near future most software systems will be developed following from components. Software organisations, applying component-based software-development technologies, are not only better able to handle complexity but also to reduce development times and cost by the systematic reuse of in-house and standard components. Thus, component-based development offers organisations a way to quickly react on market requirements.In practice the component-based development paradigm has only has a significant impact on the implementation phase of the software life cycle. Component technologies such as CORBA, JavaBeans/EJB, DCOM/AxtiveX and lately .NET basically allow the ‘technical’ cooperation of binary software building blocks of different origin. To counter this view there is a significant need to introduce the component-based development paradigm into all phases of the development life-cycle. In other words, the concept of a component should not just be seen as an implementation vehicle, but also as a central part of software design in term of concepts, methods and processes.The goal of this workshop is to examine the process of component-based software development in all phases of the development life-cycle (i.e., specification, design, composition, testing, deployment) and to identify how this process needs to be different from traditional software development. Participation is encouraged both from practitioners to provide their experiences and help in identifying open questions, and from researches to suggest methodological support for addressing these questions. The ultimate goals is thus to enable an exchange of experience between practitioners and researches concerning the relevance and feasibility of using the component paradigm throughout the software life-cycle.

Many organizations realize that building multiple software products one product at a time is no longer viable. To retain market share in the global economy, they are pressured to introduce new products and add functionality to existing ones at a rapid pace. To address these demands, they have adopted an approach that uses software assets in the form of an architecture and components to modify, assemble, instantiate, or generate multiple products. These products, referred to as a software product line, share common features, but also provide variation points for mass customization.

Background. A lot of work has been done in the context of software reuse on heavyweight domain engineering methods. However there are also approaches such as Refactoring, Adaptive Object-Models, eXtreme Programming (XP), lightweight methods, domain specific languages, and evolving frameworks that put emphasize on evolution, flexibility, and responsiveness rather than proactive and preplanned generalization. These other approaches have been useful at either creating reusable components or at least made it so that systems can quickly evolve and adapt to changing user requirements.

The open problem of structural methods is how to take a better advantage of software architectural concepts to analyse software systems for quality attributes in a systematic and repetitive way. Throughout the presentation we try to introduce a way of thinking founded on analysis at the architecture level of the quality attributes with the purpose to initiate and maintain a software product-line considering the quality as the main driver in product line development. This tutorial represents a study that shows the state of the research at this moment, in the quality analysis methods for software architectures, by presenting and discussing the most representative architecture analysis methods. The role of the discussion is to offer guidelines related to the use of the most suitable method for an architecture assessment process.

In order to do software reuse right, it is of key importance to make the right software reusable in the right form. This does not just happen; rather we need to identify where reuse could probably pay and what it is exactly that should be provided in terms of reusable components. This is a key idea of Product Line Engineering [3].

Program Transformation tools use a provided base of “transforms” (a kind of generative reuse of programming knowledge), to automate analysis, modification, and generation of software, enhancing productivity and quality over conventional methods. This tutorial provides a complete overview of Program Transformation, from theory to implementation to application. Real tools and applications are presented.

The software industry is pinning its hopes for future reuse and productivity gains on component-based software development. However, to date the component paradigm has only really penetrated the implementation and deployment phases of the software life-cycle, and does not yet play a major role in the earlier analysis and design activities of large software projects. This is evidenced by the fact that in today’s technology being a “component” usually means being implemented as a JavaBeans, a COM object or a COBRA application. This tutorial will present a new method for component-based software engineering, known as KobrA, which supports a higher-level, model-driven representation of components and thus enables the benefits of components to be realized throughout the software life-cycle. The method thus provides a component-oriented way of developing model driven architectures (MDA).

Testing seeks to determine whether a component operates correctly or whether a system implements all of the required functionality. The artifacts produced during these activities can become assets if they are carefully designed and implemented. The assets provide opportunities to reduce the overall amount of resources needed for the test process much as product line techniques reduce the effort required for development. Careful planning and the application of statistical techniques can be used to further reduce the percentage of overall project effort devoted to testing. This paper provides an overview of a tutorial on building reusable test assets.

Many software organizations are in the transition from project-centric to architecture-centric engineering of software [2]. Two typical reasons for this transition are (1) the architecture allows for a clear break-down in parts whereas a project-centric approach easily leads to a monolithic system and (2) the organization is interested in exploiting the commonalities between its products or systems. This tutorial addresses this development by providing an overview and in depth treatment of the issues around architecture-centric engineering of software. Topics include software architecture design in the presence of existing components and infrastructure (top-down versus bottom-up), architecture evaluation and assessment, software artefact variability management, software product lines and the role of the software architect. These topics are, in addition to the technical perspective, discussed from process and organizational [3] viewpoints. The topics are extensively illustrated by examples and experiences from many industrial cases (e.g. [1]).

This tutorial provides practical insights and guidance on lightweight strategies and techniques for adopting a software product line approach to software reuse. It will benefit practitioners and managers with responsibility for establishing software product lines and will also benefit researchers interested in learning more about the practical issues of adopting software product lines.

Today’s software engineering practices are aimed at developing single systems. There are attempts to achieve reuse through object- and component-based technologies with two specific goals: to cut development costs, and time-to-market and to improve quality. But current research and practical experience suggest that only moving from the single system engineering to the system-family engineering approach can bring significant progress with respect to these goals [4, 8, 10].