AN IMPROVED MODEL FOR COMPONENT BASED

SOFTWARE DEVELOPMENT (LITERATURE

REVIEW0

Lecture 4
 ABSTRACT
 The main objective of CBSD is to writes once and reuse any number of time with no or minor
modification that Increase productivity and Quality Product.
 CBSD also, support reusability. The aim of this paper is to describe the characteristics of some
selected state of art.
 CBSD models that are widely practiced in software industries. Based on the literature study we
proposed a complete model for Component Based Software Development for reuse. This Model
will cover both component based software development as well as Component development phases
 INTRODUCTION

Software companies are adopting Component-based Development (CBD) methodologies to meet the demands
of customers to deliver the product with changing requirement and at lower cost. Component-based software
engineering (CBSE) is used to develop/assemble software from existing components.
Advantages of CBD for the SW development
 Reduce development time as less or no coding is involved
 Achieve tight deadlines as development time reduced
 Software productivity is also improved as software are built by integrating already developed components
instead of writing them from scratch by using state of art tools.
 Risk in creating new software is reduced since the use of a component in several other similar domains
increases the chance of errors being identified & fixed
COMPONENT BASED SOFTWARE DEVELOPMENT
LIFE-CYCLE PHASES
Component-based software development is a collection of process that deals with the systematic reuse of
existing components often know as commercial off-the-shelf (COTS) and assembling them together to
develop an application rather than building and coding overall application from scratch, thus the life cycle of
component-based software systems is different from that of the traditional software systems The life cycle of
component based software systems can be summarized as follows:
Requirements Analysis and Specification
 System boundaries should be defined and clearly specified in this activity to analyze
whether requirements can be fulfilled with available components.
 Availability of existing components is also considered in requirements specification.
 If the appropriate requirements does not fulfils the requirement then in such cases
one possibility is to negotiate the requirements and modify them to be able to use
the existing components.
Analysis and Designing of the System Architecture
 Starts with an architectural design of the system followed by more detailed design of
the system.
 A decision has to be made about the possible use of the component model as this
decision plays a crucial role in the architecture design of the system..
Implementation
 Finding candidate component as per requirement.
 No coding is required during this phase.
 Practically coding is usually required as all functionality is rarely found in a component

Integration
 Most important and critical phase of CBSE.
 At this point components integration (mismatch) most likely occurs because of lack of
communication, capability issue, if the component is not made for the architecture.
 System quality and functionality need to be validated and verified in this phase.

Testing
Since components is developed by third party the need for component verification is apparent since the system
developers typically have no control over component quality or component functions
Release and Maintenance
 Release phase is similar to traditional software development methodology.
 Suitable for delivery and installation.
 Maintenance phase is usually involved replacement of old / obsolete component with the
new component to the system.
 Testing and verification have to be done to check the proper integration of component
into the system
 V MODEL
 The V model adopted the traditional software development approach for building a system
from reusable software components. It consists of several steps and provides the details
information at the design phases. The main emphasis of V-Development is component
development lifecycle.
 Component development lifecycle was considered as different process. The selection phase
gets input from the separate system that usually finds and evaluates the suitable components to
be composed into the system.
V DEVELOPMENT PROCESS FOR CBD
 W MODEL
 Two V models have conjoined, one for component life cycle and one for system lifecycle in the W
lifecycle model.In Component based development process the component life cycle is slightly different
from others because it is a more complete one, namely the idealized one as it fulfills all the
requirements of component based development.
 Component lifecycle comprises of two major phases component design and component deployment,
and is set in the context of a problem domain. In the design phase, software components are
identified, designed and constructed according to the domain requirements or knowledge,and put into a
software components repository.
W MODEL
 X MODEL
 X Model in which the processes started in the usual way by requirement engineering and requirement
specification.
 This software life cycle model mainly focuses on the reusability where software is built by building reusable
components for software development.
 In software development, there are two major approaches, build generic software components or develop
software component for reuse and software development with or without modification in reusable component
 The X model lifecycle consists of four sub cycles for component based software development.
 It basically considers three different cases and one component based software development that normally
occurs in component based software development:
a. Development for reuse
b. Development after modification
c. Development without modification and component based software development.
X MODEL
 ELCM(ELITE LIFE CYCLE MODEL)

 The Elite model focuses on reusability of components during development and parallel
development of components in software. It uses the Rapid Application Development model
of component development. The Elite model consists of nine phases: requirement, scope
elaboration, reusing existing components (without modifications reusing existing
components (with modifications), developing new components, integration of components,
component testing, release and customer evaluation
 Y LIFE-CYCLE MODEL
 The Y model is iterative and features forward and backward
loops for feedbacks and increments.
 This model includes all the basic features of component-
based software development, including reusability after
development and component composition on the basis of
reusability.
 The major phases involved in the Y model are: domain
engineering, frame working, assembly, archiving, system
analysis, design, implementation, testing, deployment and
maintenance.
Phase 1: Domain Engineering—The first phase of the Y model, which starts with
the commencement of the software, is domain engineering, conducted not only
to configure essential requirements and constraints, but also to analyze the
domain of the application. In this phase basic entities and their functions are
identified and defined, reusability and other component features are sought, and
an abstract model reflecting a real-world solution is depicted.
Phase 2: Frame working—In this phase the attempt is to define a generic
architecture for the proposed software. Authors try to define the structure of the
application and also the generic structure for components so that they can be
reused in more than one application. The frame working phase attempts to:
a. Identify reusable components fit for the application.
b. Select candidate components.
c. Establish the semantic relationship among components.
d. Tailor components to fit into the framework of the software.
Phase 3: Assembly—In this phase component selection or framework selection
is made based on the requirements of the specific application’s domain.
Components are selected, based on their reusability, from archived components
stored in the repository for reuse.
 Phase 4: Archiving—This is the process of submitting components to a repository
for future use. This model supports the philosophy of reusability in two ways:
exploring reusability during development and preserving reusability after
development. Archiving involves the following activities:
a. Promoting reusability during development by using reusable components.
b. Depositing reusable components in the repository for future use.
c. Preserving components of a varied nature, as some components are generalized so
that they can be placed easily, while others are specific.
d. Components should be properly documented and extensively cross-referenced so
that they can be easily reused.
Phase 5: System Analysis—This phase of development is used to identify and specify
fundamental requirements as well as to define an abstract model of the application.In
addition, this phase is used to:
a. Create an abstract (physical or conceptual) representation of the system in the form
of a model.
b. Identify major components and modules of the application.
c. Identify constraints of the application.
d. Identify and configure basic features of the application.
Phase 6: Design—This is the process of configuring solutions from the available resources.
Application designers try to provide solutions easily and efficiently. The most suitable
components are selected from the libraries, used and reused. Design is an iterative and
repetitive process which takes time. This process should provide enough details for the next
phase, implementation, to commence.
Phase 7: Implementation—This is the phase when the developer has to decide whether the
code for a particular feature or functionality is available to be reused or must be developed. In
this phase, best-fit components are implemented and unavailable components are developed.
If necessary, available components are modified and reused.
Phase 8: Testing—Testing is done at two levels: component level and application level. Unit
testing is applied to test individual components. When components are assembled, integration
testing is applied. Interfaces are also tested, as they are used as a mechanism for the
interaction of two components. After components are integrated and tested, various types of
testing are applied and performed, including checks on the functioning of the proposed system.
Phase 9: Deployment—On conclusion of the testing phase, the application is ready to install.
Users are provided with proper documentation and training. The objective of this phase is not
only to deploy the application at the user site but to make the user comfortable with the
software. Ongoing help is provided to the user.
Phase 10: Maintenance—This model argues that after deployment, software should be
continuously maintained in order to keep pace with the changing environment. Components
and component-based software are regularly updated according to the user’s requirement.
Updates compatible with older versions should be incorporated.
Key Findings
• This is one of the component-based development models that includes the reusability
feature during as well as after development.
• It supports both features of development, that is, it defines activities in iterative as well
as in incremental manner.
• This model is suitable for small-scale as well as large-scale applications, and supports
both bottom-up and top-down approaches.
• Testing is done at two fundamental levels: at individual component level; and at the
system as a unit level.
Critiques
• Although phases are defined and sub-activities are clearly mentioned, implementation
details are not discussed and there is no mention of how these activities will take place.
• Overlapping of activities in different phases is quite common.
• Component selection criteria are not defined.
KNOT MODEL
The model includes four phases: reusable component pool, new component development,
modification of existing components and development of component based software. When
components are developed, they are submitted to the component pool for future reuse.
Components can be reused with or without modifications as per the requirements of the
software
Reusable component pool phase: All the components are stored and managed in the
component repository. When components are developed, they are submitted to the pool for
reuse in other applications. This pool contains all types of components, including modified
and newly developed.
New component development phase: When requirements are not fulfilled by existing or
modified components, new developments is carried out. We can use any traditional model
to develop these components. New component development starts with cost estimation
and risk analysis, and is followed by design and coding activities and software analysis.
Component testing and feedback commences the development of new components.
Modification of existing components phase: Existing components can be modified
when they fail to provide the desired features. Components are selected from the
repository, their adaptability is checked and risk analysis is carried out. Coding is then
performed according to the requirements, and finally the component is tested. After
modification the new version of the component is submitted to the pool so that it can be
reused.
Development of component-based software: This phase includes cost estimation, risk
analysis, assembly of components, system testing, implementation, feedback and finally
maintenance of the software.
Key Findings
 This model can be applied to variable scales of software as well as component development.

 The Knot model includes risk assessment in every phase of development, which reduces the
risk of unforeseen events in later phases of development.
 This model helps to enhance the reusability of components as well as reusability of
component-based software.
Critiques
 The component pool may become too large to manage if components and developed
software products are stored after development.
 The Knot model does not suggest any method for storing or pooling of components or
software products in the repository.
 No criteria for component selection are included in the model.
 PROPOSED CBSD MODEL
all CBSD lifecycle have some drawbacks and there is a need of a new lifecycle for component
based software development. Reusing of existing artifacts is the most important concern of the
Component Based Software Development. These reusable artifacts can be previously done
system requirement, architecture, components and case study.
COMPONENT BASED SOFTWARE DEVELOPMENT LIFECYCLE

1. System Requirement, Specification and Decomposition

 CBSD this is done by reviewing old System Requirement documents if any available, interviewing
with the stakeholders. Once the requirements are thoroughly collected, requirement analysis process
starts to identify common requirements of the system and subsystems, to identify and find possible
reusable software components. The major outcomes of this phase are : detail system requirements,
identification of the components that can be reuse on the common requirements
 Main Function and non-functional requirements of the System is also identified in this phase, a system
architecture model is drawn as per stakeholder’s requirements and needs which have to be validated
and verified with the stakeholders for any ambiguity or contradiction while requirements are collected
and documented.
2.Component Requirement and Selection
 Once the system requirements are collected a system architecture model is designed based on the matching
requirement. The software team determines from the system requirements which of the software requirements can
be considered to composition rather than building them from the scratch.
 A complete cost benefit analysis is required to know various cost involved is adopting the component like (full life
cycle costs, maintenance costs, update requirement cost, licensing and warranty costs). These cost benefits analysis
helps in making a decision to reuse a component or to acquire COTS
 First search candidate component in repository ,If the candidate component is not available in repository,
Commercial off the shelf (COTS) component is being searched in the market, if component is not available either
in the internally maintained repository or in the market, develop the Component from the scratch as per the
requirement
3.Component Adaptation and Verification
 Once candidate component is selected its capability and fitness in the architecture
issues need to be addressed, the selected component need to be fit in the system
architecture design, a study usually being done to know how far the selected
component is compatible with the system architecture.
 Verification of the component is being made through the software metrics and cost
benefit analysis techniques.The software architecture must be scalable, so that,
components can be easily integrated into the system
4.Component Assembly, Wrapping and Gluing
• Developing an application by integrating components needs communication among the components
through an interface or “glue”.
• Gluing components helps in controlling information flow among the components by interchange of data
as well as adding functionality layer. Component wrappers help in isolating a component from other
components of the system.
5.System Implementation
Theoretically no coding is required during this phase but practically coding is usually required as all
functionality is rarely found in a component and some functionality need to be coded which is not provided by
component.
6.System Testing and Verification
Testing an application investigate is the software going to deliver to a customer is a quality product and it
really works as per the given requirement and specification. In CBSD it lack of detail about component source
code and design make it very difficult to track the faults specially occurs while using COTS components,
addressing these issues are studied while integrating components in the architecture model of the system.
7.System Deployment
System Deployment phase evolved releasing product to a customer in other word software is made available to
the customer for use. System deployment must be delivered using some specialized tool to make the
deployment easy for the customer.
8.System Maintenance
Up-gradation and substitution of components are the main job of the system maintenance. System Up
gradation usually occurs when a COTS supplier releases a new version of a component or when a new COTS
component is obsolete. Modifications to the code wrappers and glue code are required in system maintenance
COMPONENT DEVELOPMENT LIFECYCLE
 If the candidate component is not available either in the internally maintained repository or in the
market, a decision is being made to develop the Component from the scratch, following are the stages
of the component development for the reuse
1. Domain Engineering, Specification and Architecture

 Domain Engineering is the activity of collecting, organizing, and storing past experience
in building systems or parts of systems in a particular domain in the form of reusable
assets (i.e. reusable work products), as well as providing an adequate means for reusing
these assets when building new systems.
 The component specification describes different properties that are important to
realize by the corresponding component implementation.
Some of the important properties are….
 Functionality: what the main functionality of the component and how a component
does.
 Behavior: What are the actions of a component and how it does perform those
behaviors?
 Interaction potential: What are the possible ways in which a component interacts with
other software?
 Quality properties: what are the Characteristics of a component such as performance,
portability and stability?
2.Implementation
In This phase Implementation tools and techniques are understood. The main concern of this phase is to develop
a generic component which can be easily reusable and adaptable in similar other domain
3.Packing
Before pacing all the reusable components are given a rank based on the percentage of reuse and on the basic of
cost benefit analysis. Ranking helps the concerned person to identify and select the components. In packing
stages components are reshaped in such a way that it can be easily understood in the hierarchy. A bundled of
single unit is prepared in this stage which contains files that form the component. Implementation manuals are
also prepared in this stage.
4.Verification and Testing
This is a very important phase of component development for reuse, in this phase verification and testing of the
component is being done to know the capability and accuracy of the component. The new components are
designed, developed and tested on unit basis. Integration and system tests of the newly developed and of the
reused components are performed. A customer is requested to evaluate and verify software, whether it meets
his/her requirements or not during the testing phase. The software is ready to deploy at customer site
5.Deployment and Release
Unpackaged in a form that can be installed on the target machine
COMPARISON OF
DIFFERENT MODELS