Ch.15 - Software Reuse

Software Reuse

The process of designing software systems by composing existing, previously used components to improve quality, reduce development time, and lower costs. In recent years, software engineering has shifted significantly toward reuse-based development.

Reuse-Based Software Engineering

An approach to software development where different levels of reusable assets are used, including: complete systems (system reuse), entire applications (application reuse), sub-systems or objects (component reuse), and small-scale components like functions or objects (object and function reuse).

Benefits of Software Reuse

Software reuse offers advantages such as accelerated development (faster production and validation), effective use of specialists (experts create reusable components), and increased dependability (reused components are often more reliable due to prior testing and use).

More Benefits of Software Reuse

Reusing software leads to lower development costs (less code to write), reduced process risk (more accurate cost estimations using known components), and standards compliance (reusable UI components ensure consistency and reduce user error).

Problems with Software Reuse

Reuse can be challenging due to the high cost of creating and maintaining component libraries, the difficulty of finding, understanding, and adapting components, and increased maintenance costs when source code is unavailable or incompatible with system updates.

Additional Problems with Software Reuse

Reuse may be hindered by lack of tool support, especially in embedded systems, and the Not-Invented-Here syndrome, where developers prefer writing original code due to trust issues or the belief that reuse is less intellectually satisfying.

The Reuse Landscape

Reuse in software engineering spans a wide range of approaches and levels—from simple functions to entire application systems. It includes various techniques, not just component reuse, and reflects the diversity of how software reuse can be implemented.

Diagram: The reuse landscape

Approaches to Software Reuse

Techniques used to develop software systems by reusing existing assets at various abstraction levels. These include application frameworks (collections of classes for building applications), application system integration (combining existing applications), architectural patterns (standard software architectures), aspect-oriented development (weaving shared components into code), component-based engineering (integrating standards-compliant components), configurable application systems (tailorable systems for specific users), design patterns (reusable design structures), ERP systems (configurable large-scale business solutions), legacy system wrapping (encapsulating old systems with new interfaces), model-driven engineering (generating code from models), program generators (generating systems from models), program libraries (collections of reusable code), service-oriented systems (systems built from shared/external services), software product lines (generalized applications for various customers), and systems of systems (integration of multiple distributed systems).

Reuse Planning Factors

Key considerations that influence how and to what extent software reuse can be effectively applied in a project. These include the development schedule, expected software lifetime, the team's background and expertise, the criticality of the software along with its non-functional requirements, the application domain, and the execution platform on which the software will run.

Framework

An integrated set of software artifacts—such as classes, objects, and components—that work together to provide a reusable architecture for a family of related applications.

Application Framework

A moderately large, reusable sub-system design that lies between system and component reuse. It consists of abstract and concrete classes with defined interfaces, and is implemented by filling in design parts and instantiating the abstract classes.

Web Application Framework (WAF)

A framework that supports building dynamic websites as frontends for web applications. Available for common web programming languages (e.g., Java, Python, Ruby), WAFs typically follow the Model-View-Controller (MVC) design pattern for structuring interaction.

Model-View-Controller (MVC)

A system infrastructure framework used for GUI design that separates concerns by dividing an application into three interconnected components: the Model (data and logic), View (user interface), and Controller (input handling). It supports multiple presentations of the same data and independent interactions with these views, and is based on the instantiation of various design patterns.

Diagram: The Model-View-Controller pattern

Web Application Framework (WAF) Features

Web Application Frameworks (WAFs) offer built-in support for security (e.g., user authentication and access control), dynamic web page generation using templates and database content, database abstraction for interacting with different databases, session management to handle multiple user interactions, and user interaction enhancements such as AJAX for creating more responsive and interactive web pages.

Extending Frameworks

Extending a framework involves customizing a generic, reusable skeleton architecture by adding concrete classes that inherit from its abstract classes and implementing event-driven methods. While this enables the development of specific applications or subsystems, the complexity of frameworks often leads to a steep learning curve and longer setup times.

Diagram: Inversion of control in frameworks

Framework Classes

Framework classes are categorized into three types based on their purpose: system infrastructure frameworks that aid in building core systems like GUIs and compilers, middleware integration frameworks that facilitate communication and data exchange between components, and enterprise application frameworks that support domain-specific applications such as in finance or telecommunications.

Software Product Lines

Software product lines are sets of related applications that share a common architecture and components, designed with generic functionality that can be adapted, configured, or extended for specific use cases. Adaptation may include configuring systems and components, adding or selecting components from a library, or modifying existing components to meet new requirements.

Diagram: Base systems for a software product line

Base Applications

Base applications are the foundational elements of a software product line, consisting of core components that provide essential infrastructure and are typically left unchanged. They also include configurable components that can be adapted to new applications—often through built-in configuration tools without altering code—and specialized, domain-specific components that may be replaced or modified to suit the requirements of different instances in the product line.

Application Frameworks and Software Product Lines

Application frameworks are reusable, object-oriented software architectures that provide technical support through a collection of abstract and concrete classes, using features like polymorphism to allow developers to extend functionality for related applications. In contrast, software product lines consist of a family of related applications that share a common architecture and core components but are adapted to meet specific domain or platform needs. While frameworks emphasize technical reuse, product lines focus on domain-specific customization and are often used in controlling systems such as embedded or industrial software.

Product Line Architectures

Product line architectures are software architectures designed to support a family of related applications by structuring the system into modular sub-systems that can be independently modified. They separate different sub-systems for flexibility and maintainability, and also separate entities from their descriptions so that higher-level components interact with descriptions rather than accessing entities directly. This promotes reuse and easier adaptation across multiple product variants.