17 Component Based Development
R. Baskaran
COMPONENT BASED DEVELOPMENT
Component based development is a software system development methodology where the system is developed using reusable software components. Component based development aims at improved efficiency, performance and quality of the system by recycling components.
LEARNING OBJECTIVES
• Engineering of Component Based Software Development
• Component Based Development
• Standard Software packages
ELEMENTS OF COMPONENT BASED DEVELOPMENT
Component based development is a software system development methodology where the system is developed using reusable software components. The elements of component based development include the following:
· Reuse of software components
· Buy, don’t develop
. “Commercial off-the-shelf” (COTS)
· Shift of attention.
. From programming to composing
. From design to selection
· Speed of development
· Cost efficient
ORIGIN CBD (OR CBSE)
Component-based software engineering (CBSE) is a general approach to software development that is based on software reuse. It emerged from the failure of object-oriented development to support effective reuse. Single object classes are too detailed and specific. Components are more abstract than object classes and can be considered to be stand-alone service providers.
Definitions
“Component Based Software Engineering (CBSE) is changing the way software systems are developed. CBSE embodies the ‘buy, don’t build’ philosophy…CBSE shifts the emphasis from programming software to composing software systems.
Implementation has given way to integration as the focus. At its foundation is the assumption that there is sufficient commonality in many large software systems to justify developing reusable components to exploit and satisfy that commonality” – Clements 1995
Component
OMG Unified Modeling Language Specification [OMG01] defines a component as “… a modular, deployable, and replaceable part of a system that encapsulates implementation and exposes a set of interfaces.”
OO view: A component contains a set of collaborating classes
Conventional view: A component contains processing logic, the internal data structures that are required to implement the processing logic, and an interface that enables the component to be invoked and data to be passed to it. The CBSE essentials are comprised of the following:
- Independent components specified by their interfaces.
- Component standards to facilitate component integration.
- Middleware that provides support for component interoperability.
- A development process that is geared to reuse
DESIGN PRINCIPLES
Component-based software engineering (CBSE) design involves the following principles:
· Components are independent, no interference
· Component implementations are hidden
· Communication is through well-defined interfaces
· Container: service provider for locating and getting component interface
The following figure shows the design principles for component based development where each components are independent and the component implementation is hidden. Communication among the components is done through well defined interfaces and there exists a container which provides service for locating component interface.
COMPONENT MODELS
A component model is a definition of standards for component implementation, documentation and deployment. The component model specifies how interfaces should be defined and the elements that should be included in an interface definition. Examples of component models
· EJB model (Enterprise Java Beans)
· COM+ model (.NET model)
· OMG Corba Component Model
OMG/ CORBA
The Object Management Group has published common object request broker architecture (OMG/CORBA). An object request broker (ORB) provides services that enable reusable components (objects) to communicate with other components, regardless of their location within a system. The integration of CORBA components (without modification) within a system is assured if an interface definition language (IDL) interface is created for every component. Objects within the client application request one or more services from the ORB server. Requests are made via an IDL or dynamically at run time. An interface repository contains all necessary information about the service’s request and response formats
SUN JAVABEANS
The JavaBeans component system is a portable, platform independent CBSE infrastructure developed using Java. It encompasses a set of tools, called the Bean Development Kit (BDK), which allows developers to
◦ analyze how existing Beans (components) work
◦ customize their behavior and appearance
◦ establish mechanisms for coordination and communication
◦ develop custom Beans for a specific application
MICROSOFT COM
The component object model (COM) provides a specification for using components produced by various vendors within a single application running under the Windows operating system.
· COM encompasses two elements:
◦ COM interfaces (implemented as COM objects)
◦ A set of mechanisms for registering and passing messages between COM interfaces.
ENGINEERING OF CBS
The engineering of CBS should satisfy the following aspects:
◦ Identifying the components which are candidates for implementation
◦ Qualifying the interfaces of the components
◦ Adapting of the components to the architecture
◦ Updating of the components due to changes in the requirements.
CBSE Process
The CBSE process involves the following to develop a system from reusable software components:
◦ Domain Engineering: Library Function
◦ Component Based Development: Implementation Function CBSE
Domain Engineering
Domain Engineering focuses on identification, construction, catalog and dissemination of a set of software components, which can be applied to existing and future software for a particular domain. The most important functions during domain engineering involve analysis, construction and dissemination.
Domain Engineering Analysis is analysis of the reusable software components within a particular context or domain. Domain engineering analysis process comprises of the following actions;
· Define the domain to be investigated and categorize the elements with respect to the domain
· Representative sample of applications in the domain are provided such as business rules, best practices.
· Develop a model for the domain.
Domain engineering construction is the selection of a function or object for component reuse for the construction of the software system. The objective of this process is to construct a structural model. The objects selected from a particular domain are analyzed for reusability by posing the following questions:
◦ Is the functionality needed for future implementations?
◦ What is the degree of reusability (commonality)?
◦ Is there a duplication of the functions in the domain?
◦ Is the component hardware dependent?
◦ Is the design optimal for future implementations?
◦ Can a non-reusable component be re-parameterized such that it becomes reusable?
◦ Is it useful to decompose or re-parameterize a component for reuse?
Domain Engineering Dissemination involves a library of components, the characterization for possible reuse of components and looking at various aspects for it.
Component Based Development
Component based development focuses on component implementation. The component based development involves the following actions:
· Analysis of the particular application
◦ referring to the domain model
· Architectural design
◦ referring to the structural model
· Component qualification, adaption, composition
◦ possible engineer another component
· Testing
Component Qualification
Domain Engineering provides a library of reusable components and component qualification checks whether the component selected can perform the function required. The following aspects are checked in a component to decide their qualification.
· Can a selected component effectively be reused?
· The effectiveness in the development and integration of tools required.
· Run time requirements : resources, speed, network protocol
· Services requirements like OS interfaces and support of other components
· Security features like access control and authentication protocols Component adaption
Component adaption focuses on assuring that the components are integrated easily in the architecture. The components are easily integrated by implementing consistent methods for resource management for all components, which comprises of common activities such as data management for all components. The interfaces between components and the outside world are developed in a consistent way for the easy integration and adaptation of the components. The components are integrated into the architecture by either using component wrapping or custom component.
Component composition
Component composition is the assembling of qualified, adapted or engineered components. Common architecture environment comprises of the elements:
◦ Data Exchange model: human-to-software, between components, among system resources
◦ Automation, tools macro’s and scripts
◦ Structured Storage, accessing heterogeneous data in a single data structure
◦ Underlying Object Model, assures interoperability
CBSE PROBLEMS
The problem encountered during component based software engineering process involves:
· Component trustworthiness – how can a component with no available source code be trusted?
· Component certification – who will certify the quality of components?
· Emergent property prediction – how can the emergent properties of component compositions be predicted?
· Requirements trade-offs – how do we do trade-off analysis between the features of one component and another?
ARIANE LAUNCHER FAILURE
In 1996, the 1st test flight of the Ariane 5 rocket ended in disaster when the launcher went out of control 37 seconds after takeoff. The problem was due to a reused component from a previous version of the launcher (Inertial Navigation System) that failed because assumptions made when that component was developed did not hold for Ariane 5. But, the functionality that failed in this component was not at all required in Ariane 5.
STANDARD PACKAGES
The standard packages for component based software engineering development include SAP, Oracle, Peoplesoft, etc. developed for specific business processes. These packages have projected strong development in the last years (shift from custom made to standard packages). It incorporates ‘Enabler’ of working in a process way (BPR) and ‘Best practice’ business processes build in. It started in the ERP environment (‘Enterprise Resource Planning’) where primary business processes are extended to many other environments. It has made large changes in methodology for implementation of software systems.
CBSE and standard packages change an implementation from ‘programming to composing’ and from ‘design to select’. The integration of modules in existing architectures became more and more important, as they lay the interfaces in development of the system. Customizations are made around the standard applications e.g. When modules becomes complex and has to be integrated. The aspect with relation to what is leading the ‘requirement’ or the ‘package’ becomes an important issue. The management and ‘human factors’ stay the most important aspects for the success of an implementation.
Web Links
- https://en.wikipedia.org/wiki/Component-based_software_engineering
- highered.mheducation.com/sites/dl/free/0073375977/673802/chapter10.doc
- www.rspa.com/spi/design-component.htm
Supporting & Reference Materials
- Roger S. Pressman, “Software Engineering: A Practitioner’s Approach”, Fifth Edition, McGraw Hill, 2001.
- Pankaj Jalote, “An Integrated Approach to Software Engineering”, Second Edition, Springer Verlag, 1997.
- Ian Sommerville, “Software Engineering”, Sixth Edition, Addison Wesley, 2000.