Component-based Software Engineering

Component-based software engineering (CBSE), also called 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-driven architectures (EDA).

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''.

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 the component operates.

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
** 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.

, 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, 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).

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 toolchai
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 definition of properties that components must satisfy, methods and mechanisms for the composition of components.

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. 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) b
Remedy IT
*
COHORTE
the cross-platform runtime for executing and managing robust and reliable distributed Service-oriented Component-based applications, b
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 o
Component Systems
on SourceForge

''Brief Introduction to Real COP (Component Oriented Programming)''
by Using a small GUI application as an example

{{DEFAULTSORT:Component-Based Software Engineering

Object-oriented programming
Software architecture
Software engineering