What is a CBSE process? What are the steps in CBSE?

The component based software engineering or CBSE process is nowadays gaining a new high in the field of software engineering. But still many of us are not aware of this development process. 

This article focuses up on the component based software engineering process as well as the steps involved in it. More commonly the component based software engineering process is known as “CBD” or component based development. 

About Component Based Software Engineering (CBSE) Process

- The CBSE process is treated as an individual branch of the software engineering that primarily emphasis up on the separation of concerns with respect to the wide ranging functionality that are present throughout a software system or application.

- This approach to software development can be thought of as a reuse based approach and is used for defining, implementing and composing the independent components that are loosely coupled in to the given software system or application. 

- With such a practice, an equally wide ranging degree of benefits is brought about in the software system both for the short term and the long term and also for the organizations that are involved with the production of that software system or application. 

- The components of the software system are considered to be a part of the platform where the development process begins by many of the software engineers. 

- The components are often converted in to services and are granted further characteristics that make it different from an ordinary component. 

- For example, this happens in SOA or service oriented architectures. 

- In other cases, the components are used to consume or produce events that cab be later used for EDA or events driven architecture. 

- An individual software component can be considered to be one of the following things:

1. Software package
2. Web service
3. Module encapsulating a set of related functions.

Principle behind CBSE Process

- All the processes of the software system or application are placed in to separate components so that the data remains safe and intact and separated from other dissimilar kinds of data. 

- There is a semantic relation between the data and the functions placed inside the components.

- It is this principle that grants the components the property of modular cohesiveness. 

- The co- ordination among components is facilitated via the interfaces of the components or modules.

- Whenever it is the turn of a software system or component to offer a service to the whole of the other system or application, it makes use of the provided interface specifying the service that can be utilized by the other components and how it is to be utilized is also instructed by that interface only. 

- This interface can be called as the signature of that particular component to which it belongs.

- One of the best things about the CBSE process is that the client need not have the knowledge about the inner working of the components in order to make use of it.

Steps involved in CBSE process

1. The first step is all about the creation of an interface specification using an IDL (interface definition language).

2. The second step deals with the creation of a component specification which consists of member functions and interfaces.

3. At this step the complete control of the development process is in the hands of the developers and the traceability metrics are based up on the CBSE principles.

4. Unit testing of the components using a test harness for making the entire process automated.

5. Component integration testing

With the CBSE process, the developers can make changes to a specific component easily as long as they adhere to their interfaces. 

Component Based Software Engineering (CBSE)

Component based software engineering (CBSE) offers inherent benefits in software quality, developer productivity, and overall system cost. And yet, many roadblocks remain to be overcome before the CBSE process model is widely used throughout the industry. The benefits of object-oriented design and component-based development seem obvious:
- Reusing software saves money in the development phase of software projects, i.e., the more components you reuse, the less software you have to build.
- The more applications in which you use a given component, the more valuable that component becomes.
- Reusable components enable application developers to customize applications without high costs and long development cycles.
- Reused software components have fewer bugs because they are used more often, and errors are uncovered and corrected along the way.

Why CBSE?
The goal of component-based software engineering is to increase the productivity, quality, and time-to-market in software development thanks to the deployment of both standard components and production automation. One important paradigm shift implied here is to build software systems from standard components rather than "reinventing the wheel" each time. This requires thinking in terms of system families rather than single systems. CBSE uses Software Engineering principles to apply the same idea as OOPs to the whole process of designing and constructing software systems. It focuses on reusing and adapting existing components, as opposed to just coding in a particular style. CBSE encourages the composition of software systems, as opposed to programming them.
CBSE should, in theory, allow software systems to be more easily assembled, and less costly to build. Although this cannot be guaranteed, the limited experience of adopting this strategy has shown it to be true. The software systems built using CBSE are not only simpler to bold and cheaper – but usually turn out to be more robust, adaptable and updateable.
CBSE allows use of predictable architectural patterns and standard software architecture leading to a higher quality end result.

The CBSE Process :
CBSE is in many ways similar to conventional or object-oriented software engineering. A software team establishes requirements for the system to be built using conventional requirements elicitation techniques. An architectural design is established. Here though, the process differs. Rather than a more detailed design task, the team now examines the requirements to determine what subset is directly amenable to composition, rather than construction. For each requirement, the team will ask:
- Are commercial off-the-shelf (COTS) components available to implement the requirement?
- Are internally developed reusable components available to implement the requirement?
- Are the interfaces for available components compatible within the architecture of the system to be built?
The team will attempt to modify or remove those system requirements that cannot be implemented with COTS or in-house components. The CBSE process identifies not only candidate components but also qualifies each components’ interface, adapts components to remove architectural mismatches, assembles components into selected architectural style, and updates components as requirements for the system change.
There are two processes that occur in parallel during the CBSE process. These are:
* Domain Engineering
* Component Based Development