8/7/2018 Component-based software engineering - Wikipedia

Component­based software engineering
Component­based  software  engineering (CBSE), also called as
component­based  development (CBD), is a branch of software
engineering that emphasizes the separation of concerns with respect to
the wide-ranging functionality available throughout a given software
system. It is a reuse-based approach to defining, implementing and
composing loosely coupled independent components into systems. This
practice aims to bring about an equally wide-ranging degree of benefits in
both the short-term and the long-term for the software itself and for
organizations that sponsor such software.

Software engineering practitioners regard components as part of the

starting platform for service-orientation. Components play this role, for
example, in web services, and more recently, in service-oriented
architectures (SOA), whereby a component is converted by the web service
into a service and subsequently inherits further characteristics beyond
that of an ordinary component.

Components can produce or consume events and can be used for event-
An example of two components
driven architectures (EDA). expressed in UML 2.0. The checkout
component, responsible for facilitating the
customer's order, requires the card
processing component to charge the
Contents customer's credit/debit card (functionality
that the latter provides).
Definition and characteristics of components
History
Architecture
Component Models
Technologies
See also
References
Further reading
External links

Definition and characteristics of components
An individual software component is a software package, a web service, a web resource, or a module that encapsulates
a set of related functions (or data).

All system processes are placed into separate components so that all of the data and functions inside each component are
semantically related (just as with the contents of classes). Because of this principle, it is often said that components are
modular and cohesive.

https://en.wikipedia.org/wiki/Component-based_software_engineering#Software_component 1/6
8/7/2018 Component-based software engineering - Wikipedia

With regard to system-wide co-ordination, components communicate with each other via interfaces. When a component
offers services to the rest of the system, it adopts a provided interface that specifies the services that other components can
utilize, and how they can do so. This interface can be seen as a signature of the component - the client does not need to
know about the inner workings of the component (implementation) in order to make use of it. This principle results in
components referred to as encapsulated. The UML illustrations within this article represent provided interfaces by a
lollipop-symbol attached to the outer edge of the component.

However, when a component needs to use another component in order to function, it adopts a used interface that specifies
the services that it needs. In the UML illustrations in this article, used interfaces are represented by an open socket symbol
attached to the outer edge of the component.

Another important attribute of

components is that they are
substitutable, so that a
component can replace another
(at design time or run-time), if
the successor component meets
the requirements of the initial
component (expressed via the
interfaces). Consequently,
components can be replaced
with either an updated version
or an alternative without
breaking the system in which
A simple example of several software components - pictured within a hypothetical
the component operates.
holiday-reservation system represented in UML 2.0.
As a rule of thumb for
engineers substituting
components, component B can immediately replace component A, if component B provides at least what component A
provided and uses no more than what component A used.

Software components often take the form of objects (not classes) or collections of objects (from object-oriented
programming), in some binary or textual form, adhering to some interface description language (IDL) so that the
component may exist autonomously from other components in a computer. In other words, a component acts without
changing its source code. Although, the behavior of the component's source code may change based on the application's
extensibility, provided by its writer.

When a component is to be accessed or shared across execution contexts or network links, techniques such as serialization
or marshalling are often employed to deliver the component to its destination.

Reusability is an important characteristic of a high-quality software component. Programmers should design and
implement software components in such a way that many different programs can reuse them. Furthermore, component-
based usability testing should be considered when software components directly interact with users.

It takes significant effort and awareness to write a software component that is effectively reusable. The component needs
to be:

fully documented
thoroughly tested

https://en.wikipedia.org/wiki/Component-based_software_engineering#Software_component 2/6
8/7/2018 Component-based software engineering - Wikipedia

robust - with comprehensive input-validity checking

able to pass back appropriate error messages or return codes
designed with an awareness that it will be put to unforeseen uses
In the 1960s, programmers built scientific subroutine libraries that were reusable in a broad array of engineering and
scientific applications. Though these subroutine libraries reused well-defined algorithms in an effective manner, they had a
limited domain of application. Commercial sites routinely created application programs from reusable modules written in
assembly language, COBOL, PL/1 and other second- and third-generation languages using both system and user
application libraries.

As of 2010, modern reusable components encapsulate both data structures and the algorithms that are applied to the data
structures. Component-based software engineering builds on prior theories of software objects, software architectures,
software frameworks and software design patterns, and the extensive theory of object-oriented programming and the
object-oriented design of all these. It claims that software components, like the idea of hardware components, used for
example in telecommunications,[1] can ultimately be made interchangeable and reliable. On the other hand, it is argued
that it is a mistake to focus on independent components rather than the framework (without which they would not exist).[2]

History
The idea that software should be componentized - built from prefabricated components - first became prominent with
Douglas McIlroy's address at the NATO conference on software engineering in Garmisch, Germany, 1968, titled Mass
Produced Software Components.[3] The conference set out to counter the so-called software crisis. McIlroy's subsequent
inclusion of pipes and filters into the Unix operating system was the first implementation of an infrastructure for this idea.

Brad Cox of Stepstone largely defined the modern concept of a software component.[4] He called them Software ICs and
set out to create an infrastructure and market for these components by inventing the Objective-C programming language.
(He summarizes this view in his book Object­Oriented Programming ­ An Evolutionary Approach 1986.)

The software components are used in two different contexts and two kinds: (i) using components as parts to build a single
executable, or (ii) each executable is treated as a component in a distributed environment, where components collaborate
with each other using internet or intranet communication protocols for IPC (Inter Process Communications). The above
belongs to former kind, while the below belongs to later kind.

IBM led the path with their System Object Model (SOM) in the early 1990s. As a reaction, Microsoft paved the way for
actual deployment of component software with OLE and COM.[5] As of 2010 many successful software component models
exist.

Architecture
A computer running several software components is often called an application server. This combination of application
servers and software components is usually called distributed computing. Typical real-world application of this is in, e.g.,
financial applications or business software.

Component Models
A component model is a definition of properties that components must satisfy, methods and mechanisms for the
composition of components.[6] During the last decades, researchers and practitioners have proposed several component
models with different characteristics. A classification of the existing component models is given in.[6] Examples of

https://en.wikipedia.org/wiki/Component-based_software_engineering#Software_component 3/6
8/7/2018 Component-based software engineering - Wikipedia

component models are: Enterprise JavaBeans (EJB) model, Component Object Model (COM) model, .NET model, and
Common Object Request Broker Architecture (CORBA) component Model.

Technologies
Business object technologies

Newi
Component-based software frameworks for specific domains

Advanced Component Framework

Earth System Modeling Framework (ESMF)
MASH IoT Platform for Asset Management[7]
KOALA component model developed for software in consumer electronics[8][9]
React (JavaScript library)
Software Communications Architecture (JTRS SCA)
Component-oriented programming

Bundles as defined by the OSGi Service Platform

Component (https://github.com/component/component) web platform for modular js, css, and other assets
Component Object Model (OCX/ActiveX/COM) and DCOM from Microsoft
TASCS - SciDAC Center for Technology for Advanced Scientific Component Software
Eiffel programming language
Enterprise JavaBeans from Sun Microsystems (now Oracle)
Flow-based programming
Fractal component model from ObjectWeb
MidCOM component framework for Midgard and PHP
Oberon, Component Pascal, and BlackBox Component Builder
rCOS method of component-based model driven design from UNU-IIST
SOFA component system from ObjectWeb
The System.ComponentModel namespace in Microsoft .NET
Unity developed by Unity Technologies
Unreal Engine developed by Epic Games
UNO from the OpenOffice.org office suite
VCL and CLX from Borland and similar free LCL library.
XPCOM from Mozilla Foundation
Compound document technologies

Active Documents in Oberon System and BlackBox Component Builder

KParts, the KDE compound document technology
Object linking and embedding (OLE)
OpenDoc
Distributed computing software components

.NET Remoting from Microsoft

9P distributed protocol developed for Plan 9, and used by Inferno and other systems.
CORBA and the CORBA Component Model from the Object Management Group
D-Bus from the freedesktop.org organization
DCOM and later versions of COM (and COM+) from Microsoft
DSOM and SOM from IBM (now scrapped)
Ice from ZeroC
Java EE from Sun
Kompics[10] from SICS
https://en.wikipedia.org/wiki/Component-based_software_engineering#Software_component 4/6
8/7/2018 Component-based software engineering - Wikipedia

Universal Network Objects (UNO) from OpenOffice.org

Web services

REST
Zope from Zope Corporation
AXCIOMA (the component framework for distributed, real-time, and embedded systems) by Remedy IT [3] (http://
www.axcioma.com)
COHORTE (https://cohorte.github.io) the cross-platform runtime for executing and managing robust and reliable
distributed Service-oriented Component-based applications, by isandlaTech (http://isandlatech.com)
Generic programming emphasizes separation of algorithms from data representation
Interface description languages (IDLs)

Open Service Interface Definitions (OSIDs)

Part of both COM and CORBA
Platform-Independent Component Modeling Language
SIDL - Scientific Interface Definition Language

Part of the Babel Scientific Programming Language Interoperability System (SIDL and Babel are core
technologies of the CCA and the SciDAC TASCS Center - see above.)
SOAP IDL from World Wide Web Consortium (W3C)
WDDX
XML-RPC, the predecessor of SOAP
Inversion of Control (IoC) and Plain Old C++/Java Object (POCO/POJO) component frameworks
Pipes and filters

Unix operating system

See also
Business logic
Modular programming
Service Component Architecture (SCA)
Software Communications Architecture (JTRS SCA)
Third-party software component
Web service
Web components

References
1. Foukalas et al "Protocol Reconfiguration Using Component-Based Design" (http://www.springerlink.com/content/nc7w
y8x1bevgj5w9/)
2. Wallace, Bruce (May 19, 2010). "A hole for every component, and every component in its hole" (http://existentialprogr
amming.blogspot.com/2010/05/hole-for-every-component-and-every.html). Existential Programming. "There is no
such thing as a Component"
3. McIlroy, Malcolm Douglas (January 1969). "Mass produced software components" (http://homepages.cs.ncl.ac.uk/bria
n.randell/NATO/nato1968.PDF) (PDF). Software Engineering: Report of a conference sponsored by the NATO
Science Committee, Garmisch, Germany, 7-11 Oct. 1968. Scientific Affairs Division, NATO. p. 79.
4. Rainer Niekamp. "Software Component Architecture" (http://congress.cimne.upc.es/cfsi/frontal/doc/ppt/11.pdf) (PDF).
Gestión de Congresos - CIMNE/Institute for Scientific Computing, TU Braunschweig. p. 4. Retrieved 2011-07-29. "The
modern concept of a software component largely defined by Brad Cox of Stepstone, => Objective-C programming
language"

https://en.wikipedia.org/wiki/Component-based_software_engineering#Software_component 5/6
8/7/2018 Component-based software engineering - Wikipedia

5. Raphael Gfeller (December 9, 2008). "Upgrading of component-based application" (http://wiki.ita.hsr.ch/SemProgAnT

r/files/Automated_upgrading_of_component.Präsentation.pptx). HSR - Hochschule für Technik Rapperswill. p. 4.
Retrieved 2011-07-29. "1990, IBM invents their System Object Model. 1990, as a reaction, Microsoft released OLE
1.0 OLE custom controls (OCX)"
6. I. Crnkovic, S. Sentilles, A. Vulgarakis and M. R. V. Chaudron, "A Classification Framework for Software Component
Models" (http://ieeexplore.ieee.org/document/5587419/) in IEEE Transactions on Software Engineering, vol. 37, no. 5,
pp. 593-615, Sept.-Oct. 2011, doi: 10.1109/TSE.2010.83.
7. MASH defines assets as people, property and information and management as monitoring, control and configuration.
Presented at the 2013 IEEE IoT conference in Mountain View MASH includes a full IDE, Android client and runtime.
"MASH YouTube channel" (https://www.youtube.com/user/MASHPlatform)
8. A component-oriented approach is an ideal way to handle the diversity of software in consumer electronics. The Koala
model, used for embedded software in TV sets, allows late binding of reusable components with no additional
overhead. [1] (https://spiral.imperial.ac.uk/bitstream/10044/1/464/1/The%20Koala%20component%20model.pdf)
9. Component model for embedded devices like TV developed by Philips based on paper by van Ommering, R.: Koala,
a Component Model for Consumer Electronics Product Software [2] (http://d3s.mff.cuni.cz/research/seminar/downloa
d/2006-12-21-Hnetynka-Koala)
10. Arad, Cosmin (April 2013). Programming Model and Protocols for Reconfigurable Distributed Systems (https://www.kt
h.se/social/upload/51adbc98f2765409d66844b7/CosminArad-Thesis.pdf) (PDF). Doctoral Dissertation. Stockholm,
Sweden: KTH Royal Institute of Technology. ISBN 978-91-7501-694-8.

Further reading
Brad J. Cox, Andrew J. Novobilski (1991). Object-Oriented Programming: An Evolutionary Approach. 2nd ed.
Addison-Wesley, Reading ISBN 0-201-54834-8
Bertrand Meyer (1997). Object-Oriented Software Construction. 2nd ed. Prentice Hall.
George T. Heineman, William T. Councill (2001). Component-Based Software Engineering: Putting the Pieces
Together. Addison-Wesley Professional, Reading 2001 ISBN 0-201-70485-4
Richard Veryard (2001). Component-based business : plug and play. London : Springer. ISBN 1-85233-361-8

External links
Why Software Reuse has Failed and How to Make It Work for You (http://www.dre.vanderbilt.edu/~schmidt/reuse-less
ons.html) by Douglas C. Schmidt
What is the True essence and reality of CBD? (https://www.researchgate.net/publication/284167768_What_is_true_es
sence_of_Component_Based_Design) (Evidence to show existing CBD paradigm is flawed)
comprehensive list of Component Systems (http://xplc.sourceforge.net/doc/others.php) on SourceForge
Brief Introduction to Real COP (Component Oriented Programming) (https://www.researchgate.net/publication/292378
253_Brief_Introduction_to_COP_Component_Oriented_Programming) by Using a small GUI application as an
example

Retrieved from "https://en.wikipedia.org/w/index.php?title=Component-

based_software_engineering&oldid=850084312#Software_component"

This page was last edited on 13 July 2018, at 13:55 (UTC).

Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. By using this
site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia Foundation,
Inc., a non-profit organization.

https://en.wikipedia.org/wiki/Component-based_software_engineering#Software_component 6/6