Component-based software engineering

Component-based software engineering (CBSE), also called component-based development (CBD), is a style of software engineering that aims to build software out of loosely-coupled, modular components. It emphasizes the separation of concerns among different parts of a software system.
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.
Components communicate with each other via interfaces. Each component provides an interface (called a provided interface) through which other components can use it. When a component uses another component's interface, that interface is called a used interface.
In the UML illustrations in this article, provided interfaces are represented by lollipop-symbols, while used interfaces are represented by open socket symbols.
Components must be substitutable, meaning that a component must be replaceable by another one having the same interfaces without breaking the rest of the system.
Components should be reusable.
Component-based usability testing should be considered when software components directly interact with users.
Components should be:
fully documented
thoroughly tested
robust - with comprehensive input-validity checking
able to pass back appropriate error messages or return codes
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. 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. 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 Object linking and embedding (OLE) and Component Object Model (COM). many successful software component models exist.
In 2021 open-source toolchain Bit provided a free infrastructure for the development and composition of components into software applications, products, services and systems.
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 specification of components' properties.
A classification of the existing component models is given in and. Examples of component models are: Enterprise JavaBeans (EJB) model, Component Object Model (COM) model, .NET model, X-MAN component 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
KOALA component model developed for software in consumer electronics
React (JavaScript library)
Software Communications Architecture (JTRS SCA)
Component-oriented programming
Bundles as defined by the OSGi Service Platform
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 from SICS
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
COHORTE the cross-platform runtime for executing and managing robust and reliable distributed Service-oriented Component-based applications, by isandlaTech
DX-MAN Service Model
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
Further reading
Brad J. Cox, Andrew J. Novobilski (1991). Object-Oriented Programming: An Evolutionary Approach. 2nd ed. Addison-Wesley, Reading
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
Richard Veryard (2001). Component-based business : plug and play. London : Springer.
Clemens Szyperski, Dominik Gruntz, Stephan Murer (2002). Component Software: Beyond Object-Oriented Programming. 2nd ed. ACM Press - Pearson Educational, London 2002
External links
Why Software Reuse has Failed and How to Make It Work for You by Douglas C. Schmidt
What is the True essence and reality of CBD? (Evidence to show existing CBD paradigm is flawed)
comprehensive list of Component Systems on SourceForge
Brief Introduction to Real COP (Component Oriented Programming) by Using a small GUI application as an example
Object-oriented programming
Software architecture
Software engineering