Component Based Software Engineering & Computing

 Component Based Software Engineering : 

Definition :
Component-based software engineering (CBSE) is a process that emphasizes the design and construction of computer-based systems using reusable software “components.”

       CBSE is changing the way large software systems are developed. CBSE embodies the “buy, don’t build” philosophy. So in simple words, CBSE is a process of developing software application using reusable small programs knows as components.

Engineering/Computing of Component-Based Systems:

CBSE is quiet similiar to conventional or object-oriented software engineering. The process begins when a software team establishes requirements for the system to be built using conventional requirements elicitation techniques. An architectural design is established, but rather than moving immediately into more detailed design tasks, the team examines requirements to developing the software we look for composing it by predefined software components.
 
So the team asks the following questions for each system requirement :

1.  Are commercial off-the-shelf (COTS) components available to implement the requirement?
2. Are internally developed reusable components available to implement the requirement?
3. Are the interfaces for available components compatible within the architecture of the system to be built?

  After these question answered the team attempts to modify or remove those system requirements that cannot be implemented with COTS or in-house components. If the requirement(s) cannot be changed or deleted, conventional or object-oriented software engineering methods are applied to develop those new components that must be engineered to meet the requirement(s). But for those requirements that are addressed with available components, a different set of software engineering activities commences which are analysed under Component-Based Computing.



Different framework Activities :

 1. Component qualification : It is a process of discovery and analysis to qualify each component’s fit.

 2. Component Adaptaion :  Makes sure that the Component adapted to meet the needs of the architecture or discarded and replaced by other, more suitable components.

 3. Component Composition : In which way software components are integrated to form a working system

 4. Component Update : Timely Updation.

These process yields :-
1. Qualified components—assessed by software engineers to ensure that not only functionality, but performance, reliability, usability, and other quality factors conform to the requirements of the system or product to be built.

2. Adapted components—adapted to modify (also called mask or wrap) unwanted or undesirable characteristics.

3. Assembled components—integrated into an architectural style and interconnected with an appropriate infrastructure that allows the components to be coordinated and managed effectively.

4. Updated components—replacing existing software as new versions of components become available.

Benefits  Of Components :

If a software application is assembled from components, then it should be easy to reconfigure the components to support desired changes in the business process. Business processes may be improved in three ways:

1. Simplification : Removing one or more steps from an unnecessarily complicated process, or reducing unnecessary variety in the process.This can often by done by replacing components to produce stepwise improvements.

2. Integration: Joining two or more previously unconnected or uncoordinated processes into a larger coordinated process. This can often by done by inserting additional components to create new links.

3. Transformation: Creating a radically new process. Disassembling the components, and putting them back together in a new way, can often achieve this.


On the Basis of Six Software Quality definitions... benefits are: 

1. Functionality : Use of pre-existing components allows faster delivery of greater functionality.

2. Maintainability: The modular structure of a component-based solution allows individual components to be replaced easily.

3. Usability: Use of standard components supports commonality of GUI. CBD also supports desk-top integration, which gives the user a single view of heterogeneous data.

4. Efficiency: Performance bottlenecks can be identified, and the need for performance tuning can then usually be localized in a small number of performance-critical components. Components can be internally optimized to improve performance, without affecting their specification; components can be moved between platforms to improve performance, without affecting the functionality or usability of the application.

5. Reliability: Given a formal and complete specification of a component, the reliability of a component comes down to the simple question: does the component provide a correct and complete implementation of its specification. The reliability of the application as a whole is a separate issue, but is clearly enhanced when the application is constructed from reliable components.

6.  Portability : The specification of a component is platform-independent. So a component can be quickly rebuilt for a new platform, without affecting any other component. (With some tools, this will often require no alteration to the internal design, merely a regeneration of the executable portion.)