Ch15 Software reuse

Definition: In engineering, systems are designed by composing existing components used previously.
Shift in Focus: Traditionally focused on original development; there's now a recognition that systematic software reuse can accelerate development and reduce costs.
Trend: Shift towards reuse-based development has increased significantly in the last decade.

System Reuse: Complete systems are reused, encompassing multiple application programs.
Application Reuse: Applications can be reused as-is or through the development of application families.
Component Reuse: Individual components, ranging from sub-systems to single objects, can be reused.
Object and Function Reuse: Small-scale components that implement a single well-defined object or function can be reused.

Accelerated Development: Speeds up production by reducing development and validation time.
Effective Use of Specialists: Application specialists can focus on developing reusable software instead of repetitive tasks.
Increased Dependability: Reused software is typically more reliable as it has been tested in previous systems.
Lower Development Costs: Less code written means lower costs.
Reduced Process Risk: Existing software costs are known, reducing risk in project budgeting.
Standards Compliance: Reusable components can uphold UI standards, aiding user familiarity and decreasing mistakes.

Component Library Management: Building and maintaining a reusable component library can be costly.
Finding and Adapting Components: Locating suitable components in the library and adapting them to new environments is a challenge.
Higher Maintenance Costs: If reused components' source code is unavailable, maintaining them can lead to compatibility issues over time.
Lack of Tool Support: Some tools may not facilitate reuse effectively, particularly in embedded systems engineering.
Not-invented-here Syndrome: Developers may hesitate to reuse components due to a preference for original work.

Scope of Reuse: Reuse can occur at various levels from simple functions to complete application systems, incorporating a wide array of techniques.
Approaches: Categories include architectural patterns, application frameworks, product lines, service-oriented systems, etc.

Application Frameworks: Collections of classes used to create application systems.
Application System Integration: Merging multiple systems to provide extended functionality.
Architectural Patterns: Standard software architectures used for common application types.
Aspect-oriented Development: Integrating shared components within an application at different points at compile time.
Component-based Software Engineering: Developing systems by integrating standardized components.

Definition: Groups of applications sharing a common architecture are adaptable for specific contexts.
Customization Methods: Involves configuring components, adding new components, selecting from libraries, or modifying existing components.

Critical Factors in Planning: Includes the development schedule, experience of the team, software lifetime, and execution platform specifics.

Definition: An integrated set of software artifacts collaborating to provide a reusable architecture for related applications.
Characteristics: Frameworks present a skeletal architecture, extended through concrete classes and methods.

Purpose: Facilitate dynamic website construction, adhering to MVC (Model-View-Controller) architecture.
Core Features: Include user authentication, dynamic page creation, database interaction, session management, and AJAX support.

Customization: Involves adding classes and methods to adapt general frameworks for specific applications; complexity can hinder effective usage.

Base Systems: Composed of core components and configurable application components to deliver specialized applications.
Product Line Architecture: Must distinctively structure subsystems to facilitate modifications.

Combination of Systems: Pulls together multiple systems to meet diverse functionality requirements.
Challenges: Selecting appropriate system functionalities and ensuring compatibility between different systems.

There are various ways to reuse software, enhancing development speed and reducing costs.
Software product lines are adaptive systems sharing common architectures.
Application system reuse offers substantial functionality, improving the speed of development.
Potential drawbacks include dependency on external vendors and challenges with system integration.