Component-based software engineering

Short description: Branch of software engineering

An example of two components expressed in UML 2.0. The checkout component, responsible for facilitating the customer's order, requires the card processing component to charge the customer's credit/debit card (functionality that the latter provides). Programming paradigms

* Action
* Agent-oriented
* Array-oriented
* Automata-based
* Concurrent computing
* Relativistic programming
* Data-driven
* Declarative (contrast: Imperative)
* Functional
* Functional logic
* Purely functional
* Logic
* Abductive logic
* Answer set
* Concurrent logic
* Functional logic
* Inductive logic
* Constraint
* Constraint logic
* Concurrent constraint logic
* Dataflow
* Flow-based
* Reactive
* Ontology
* Differentiable
* Dynamic/scripting
* Event-driven
* Function-level (contrast: Value-level)
* Point-free style
* Concatenative
* Generic
* Imperative (contrast: Declarative)
* Procedural
* Object-oriented
* Polymorphic
* Intentional
* Language-oriented
* Domain-specific
* Literate
* Natural-language programming
* Metaprogramming
* Automatic
* Inductive programming
* Reflective
* Attribute-oriented
* Macro
* Template
* Non-structured (contrast: Structured)
* Array
* Nondeterministic
* Parallel computing
* Process-oriented
* Probabilistic
* Quantum
* Set-theoretic
* Stack-based
* Structured (contrast: Non-structured)
* Block-structured
* Structured concurrency
* Object-oriented
* Actor-based
* Class-based
* Concurrent
* Prototype-based
* By separation of concerns:
* Aspect-oriented
* Role-oriented
* Subject-oriented
* Recursive
* Symbolic
* Value-level (contrast: Function-level)

* v
* t
* e

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.

## Contents

* 1 Definition and characteristics of components
* 2 History
* 3 Architecture
* 4 Component models
* 5 Technologies
* 6 See also
* 7 References
* 8 Further reading
* 9 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.

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.

A simple example of several software components - pictured within a hypothetical holiday-reservation system represented in UML 2.0.

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.[1] 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.[2] 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).[3] As of 2010[update] 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 specification of components' properties.[4]

A classification of the existing component models is given in [4] and.[5] Examples of component models are: Enterprise JavaBeans (EJB) model, Component Object Model (COM) model, .NET model, X-MAN component model,[6] and Common Object Request Broker Architecture (CORBA) component model.

## Technologies

This section is in list format, but may read better as prose. You can help by converting this section, if appropriate. Editing help is available. (January 2020)

|

* 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]
* Web: React,[10]: 4–6 Vue.js
* 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[11] 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[12]
* 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. ↑ McIlroy, Malcolm Douglas (January 1969). "Mass produced software components". Software Engineering: Report of a conference sponsored by the NATO Science Committee, Garmisch, Germany, 7-11 Oct. 1968. Scientific Affairs Division, NATO. p. 79. http://homepages.cs.ncl.ac.uk/brian.randell/NATO/nato1968.PDF.
2. ↑ Rainer Niekamp. "Software Component Architecture". Gestión de Congresos - CIMNE/Institute for Scientific Computing, TU Braunschweig. p. 4. http://congress.cimne.upc.es/cfsi/frontal/doc/ppt/11.pdf. "The modern concept of a software component largely defined by Brad Cox of Stepstone, => Objective-C programming language"
3. ↑ Raphael Gfeller (December 9, 2008). "Upgrading of component-based application". HSR - Hochschule für Technik Rapperswill. p. 4. http://wiki.ita.hsr.ch/SemProgAnTr/files/Automated_upgrading_of_component.Präsentation.pptx. "1990, IBM invents their System Object Model. 1990, as a reaction, Microsoft released OLE 1.0 OLE custom controls (OCX)"
4. ↑ 4.0 4.1 Crnkovic, I.; Sentilles, S.; Vulgarakis, A.; Chaudron, M. R. V. (2011). "A Classification Framework for Software Component Models". IEEE Transactions on Software Engineering 37 (5): 593–615. doi:10.1109/TSE.2010.83.
5. ↑ Lau, Kung-Kiu; Wang, Zheng (2007). "Software Component Models". IEEE Transactions on Software Engineering 33 (10): 709–724. doi:10.1109/TSE.2007.70726. ISSN 0098-5589.
6. ↑ Lau, Kung-Kiu; Velasco Elizondo, Perla; Wang, Zheng (2005). "Exogenous Connectors for Software Components". in Heineman, George T.; Crnkovic, Ivica; Schmidt, Heinz W. et al. (in en). Component-Based Software Engineering. Lecture Notes in Computer Science. 3489. Springer Berlin Heidelberg. pp. 90–106. doi:10.1007/11424529_7. ISBN 9783540320494.
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"
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]
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]
10. ↑ Larsen, John (2021). React Hooks in Action With Suspense and Concurrent Mode. Manning. ISBN 978-1720043997.
11. ↑ Arad, Cosmin (April 2013). Programming Model and Protocols for Reconfigurable Distributed Systems. Stockholm, Sweden: KTH Royal Institute of Technology. ISBN 978-91-7501-694-8. https://www.kth.se/social/upload/51adbc98f2765409d66844b7/CosminArad-Thesis.pdf.
12. ↑ Arellanes, Damian; Lau, Kung-Kiu (2017). "Exogenous Connectors for Hierarchical Service Composition". 2017 IEEE 10th Conference on Service-Oriented Computing and Applications (SOCA). Kanazawa: IEEE. pp. 125–132. doi:10.1109/SOCA.2017.25. ISBN 9781538613269. https://eprints.lancs.ac.uk/id/eprint/145571/1/Exogenous_Connectors_For_Hierarchical_Service_Composition.pdf.

## 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
* Clemens Szyperski, Dominik Gruntz, Stephan Murer (2002). Component Software: Beyond Object-Oriented Programming. 2nd ed. ACM Press - Pearson Educational, London 2002 ISBN 0-201-74572-0

## 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

* v
* t
* e

Types of programming languages

* Actor-based
* Array
* Aspect-oriented
* Class-based
* Concatenative
* Concurrent
* Dataflow
* Declarative
* Domain-specific
* Dynamic
* Esoteric
* Event-driven
* Extensible
* Functional
* Imperative
* Logic
* Macro
* Metaprogramming
* Multi-paradigm
* Object-based
* Object-oriented
* Pipeline
* Procedural
* Prototype-based
* Reflective
* Rule-based
* Scripting
* Stack based
* Synchronous
* Tactile
* Templating

* Assembly
* Compiled
* Interpreted
* Machine

* Low-level
* High-level
* Very high-level

* First generation
* Second generation
* Third generation
* Fourth generation
* Fifth generation

* Non-English-based
* Visual

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Component-based software engineering. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Component-based_software_engineering&oldid=41387"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template