1. Lecture 21: Component-Based Software Engineering

2. Today’s Topics Issues and Challenges for CBSE The CBSE Process
Guidelines for Reuse
The Reuse Environment
Economics of CBSE
Metrics for CBSE

3. Characteristics of CBSE
Analysis & Design includes checking for reusable solutions
A “more organized approach” to software reuse
Helps reduce development time & cost (with streamlined infrastructure & process)
Less emphasis on implementation, more on integration

4. Challenges for CBSE
Does the domain allow reusability? Systems have common requirements
Can the extra cost be justified? High degree of reusability
Can support for reuse be created? Indexing, common access, process
Can incentives be created for engineers? Appropriate culture, metrics, etc.

5. Composition Follows architectural design & precedes detailed design
Can requirements be implemented:
By COTS components?
By internally-developed components?
Are component interfaces with the architecture compatible?
Can the requirements be adjusted to accommodate reuse?

6. CBSE Activities
Component Qualification Does the component fit the need?
Component Adaptation Resolve design mismatches
Component Composition Adopt framework for integration
Component Update Manage third-party updates

7. Types of Components Run-Time Components Business Components
Dynamic binding
Interface discovered at run-time
E.g.: distributed objects (CORBA)
Business Components
Encapsulate an autonomous business concept or process
E.g.: enterprise Java beans (EJB)

8. CBSE Development Process
Identify, qualify, adapt, assemble, and update reusable components Component engineering
Domain engineering and component engineering are concurrent Requirements are adjusted to accommodate reuse

9. The CBSE Process
[From SEPA 5/e]

10. Domain Analysis Define the domain Categorize the items in the domain
Collect a sample of applications
Analyze each application
Develop and analysis model for the domain objects

11. Identification & Categorization
Select specific functions or objects
Abstract functions or objects
Define a taxonomy
Identify common features
Abstract the relationships
Derive a functional model
Define a domain language

12. Example: Common Objects
Text processing objects share common functions
Process sentence & provide feedback
Process sentence & provide an output (rewrite, translation)
Process sentence & provide markup
Text processing programs share common context (desktop)

13. Example [2] Shared Objects
Client: a program that resides on the desktop, interfaces with a word-processing program, and provides some functionality on the desktop
Server: a program that resides remotely and does the actual work
The KANT system (CMU) provides reusable boundary objects which are used in several applications

14. Other Examples Document class in Java (also its subclasses)
User Interface components (e.g., Java Swing classes)
Database interface components (e.g. reusable JDBC classes)

15. Guidelines for Reuse Is there a future need?
Is the functionality common?
Is the functionality duplicated?
Is there a hardware dependency?
Is the design optimized?
Can we parameterize components?
Can we reuse via modification?
Can we decompose a component to derive reusable components?

16. Domain Characteristics Impact Reusability
[From SEPA 5/e]

17. Structure Points
Capture a repeating pattern in the domain (function, data, behavior) e.g., aircraft avionics system
Three characteristics:
Limited number of instances
Simple rules, interface
Implements information hiding

18. Generic Structure Points
Application Front End (GUI)
Database
Computational Engine
Reporting Facility
Application Editor Can be used for estimation

19. Component Qualification
Does the component:
Perform the function required?
Fit into the architectural style?
Have the right qualities?
Things to consider:
API, tool support, run-time requirements, maintenance requirements, security, design assumptions, exception handling, …

20. Component Adaptation Ultimate Goal: “easy integration”
Consistent resource management
Common data management
Consistent interfaces
Alternative: Component Wrapping
White-box (modify code)
Gray-box (extend code / data)
Black-box (pre-/post-processing)

21. Component Composition
Four architectural ingredients:
Data exchange model e.g., drag/drop, cut/paste
Automation tools, macros, scripts
Structured storage single interface to heterogeneous data
Underlying object model ensure component interoperability

22. Integrated Information Management
Flow-based information processing architecture
Shared object model (Node, Document, etc.)
User-defined nodes & resources
Rapid development of reusable components

23. Emerging Standards OMG/CORBA Common Object Request Broker Architecture
Microsoft COM Component Object Model
Sun Java Beans Enterprise Java Beans – well-suited for eCommerce

24. Classification & Retrieval
3C Model [Tracz 1990]
Concept: What does it do?
Content: How is it built?
Context: What is the domain?
Indexing Schemes
Controlled vocabulary
Uncontrolled vocabulary

25. Classification Hierarchy
[From SEPA 5/e]

26. The Reuse Environment Component Database Library Management System
Component Retrieval System
CBSE Tools for Integration Example of a web-based component library:

27. Economics of CBSE Quality Lower defect rate for reusable code
Productivity Faster delivery of complete systems
Cost Savings = CS – (CR + CD)
Develop from Scratch
Cost of Reuse
Develop w/Reuse

28. Reuse Metrics
Reuse Benefit (cost-based) Rb(S) = [Cnoreuse – Creuse]/Cnoreuse
Reuse Leverage (object-based) Rlev = OBJreused / OBJbuilt

29. Questions?