- Component-based software engineering
- Concurrent computing
- Relativistic programming
- Declarative (contrast: Imperative)
- Function-level (contrast: Value-level)
- Imperative (contrast: Declarative)
- Non-structured (contrast: Structured)
- Parallel computing
- Programming in the large / small
- Structured (contrast: Non-structured)
- Value-level (contrast: Function-level)
Component-based software engineering (CBSE) (also known as component-based development (CBD)) is a branch of software engineering that emphasizes the separation of concerns in respect of the wide-ranging functionality available throughout a given software system. 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 engineers 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, 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 general 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.
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 Assembler, COBOL, PL/1 and other second- and third-generation languages using both system and user application libraries.
As of 2010[update], modern reusable components encapsulate both data structures and the algorithms that are applied to the data structures. It[clarification needed] 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).
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.)
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. As of 2010[update] many successful software component models exist.
Differences from object-oriented programming
Proponents of object-oriented programming (OOP) maintain that software should be written according to a mental model of the actual or imagined objects it represents. OOP and the related disciplines of object-oriented analysis and object-oriented design focus on modeling real-world interactions and attempting to create "nouns" and "verbs" that can be used in more human-readable ways, ideally by end users as well as by programmers coding for those end users.
Component-based software engineering, by contrast, makes no such assumptions, and instead states that developers should construct software by gluing together prefabricated components - much like in the fields of electronics or mechanics. Some peers[who?] will even talk of modularizing systems as software components as a new programming paradigm.
Some[who?] argue that earlier computer scientists made this distinction, with Donald Knuth's theory of "literate programming" optimistically assuming there was convergence between intuitive and formal models, and Edsger Dijkstra's theory in the article The Cruelty of Really Teaching Computer Science, which stated that programming was simply, and only, a branch of mathematics.
In both forms, this notion has led to many academic debates[weasel words] about the pros and cons of the two approaches and possible strategies for uniting the two. Some[who?] consider the different strategies not as competitors, but as descriptions of the same problem from different points of view.
A computer running several software components is often called an application server. Using this combination of application servers and software components is usually called distributed computing. The usual real-world application of this is in e.g. financial applications or business software.
- Business object technologies
- Component-based software frameworks for specific domains
- Earth System Modeling Framework (ESMF)
- Component-oriented programming
- Bundles as defined by the OSGi Service Platform
- Common Component Architecture (CCA) - Common Component Architecture Forum, Scientific/HPC Component Software
- 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
System.ComponentModelnamespace in Microsoft .NET
- Unity3D developed by Unity Technologies
- UNO from the OpenOffice.org office suite
- VCL and CLX from Borland and similar free LCL library.
- Visual Basic Extensions, OCX/ActiveX/COM and DCOM from Microsoft
- XPCOM from Mozilla Foundation
- Compound document technologies
- 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
- DCOP from KDE (deprecated)
- DCOM and later versions of COM (and COM+) from Microsoft
- DSOM and SOM from IBM (now scrapped)
- ICE from ZeroC
- Java EE from Sun
- Universal Network Objects (UNO) from OpenOffice.org
- Web services
- Zope from Zope Corporation
- 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
- SOAP IDL from World Wide Web Consortium (W3C)
- XML-RPC, the predecessor of SOAP
- Inversion of Control (IoC) and Plain Old C++/Java Object (POCO/POJO) component frameworks
- Pipes and Filters
- 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 1852333618
- Clemens Szyperski (2002). Component Software: Beyond Object-Oriented Programming. 2nd ed. Addison-Wesley Professional, Boston ISBN 0-201-74572-0
- David Polberger (2009). Component technology in an embedded system. Master's thesis in computer science, available online. ISSN 1651-6389
- ^ Wallace, Bruce (May 19, 2010). "A hole for every component, and every component in its hole". Existential Programming. http://existentialprogramming.blogspot.com/2010/05/hole-for-every-component-and-every.html. "There is no such thing as a Component"
- ^ 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.
- ^ 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. Retrieved 2011-07-29. "The modern concept of a software component largely defined by Brad Cox of Stepstone, => Objective-C programming language"
- ^ 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. Retrieved 2011-07-29. "1990, IBM invents their System Object Model. 1990, as a reaction, Microsoft released OLE 1.0 OLE custom controls (OCX)"
- ^ "Dijkstra, Wybe Edsger". Encyclopedia.com. http://www.encyclopedia.com/doc/1G2-2830905624.html. Retrieved 2011-07-29. "In his view, the key to a good computing science program was to consider it as a branch of mathematics."
- ^ Donald E. Knuth (September 1983). "Literate Programming". Literate Programming/The Computer Journal. p. 15. http://www.literateprogramming.com/knuthweb.pdf. Retrieved 2011-07-29. "Thus, WEB may be only for the subset of computer scientists who like to write and to explain what they are doing. My hope is that the ability to make explanations more natural will cause more programmers to discover the joys of literate programming, because I believe it’s quite a pleasure to combine verbal and mathematical skills; but perhaps I’m hoping for too much. The fact that at least one paper has been written that is a syntactically correct ALGOL 68 program22 encourages me to persevere in my hopes for the future. Perhaps we will even one day find Pulitzer prizes awarded to computer programs."
- Planning the Software Industrial Revolution The history of manufacturing vs software compared.
- The independence of notion of component-orientation.
- Cox's feasibility demonstration of a usage-based mechanism for incentivizing component producers.
- Why Software Reuse has Failed and How to Make It Work for You by Douglas C. Schmidt
- New proposals to explore the Component properties: (i) Reuse and (ii) Replaceable
- Dynamically Self Configuring Automotive System
- New proposal for exploring a kind of CBSE comparable to the CBE
- comprehensive list of Component Systems on SourceForge
Wikimedia Foundation. 2010.
Look at other dictionaries:
Component Based Software Engineering — In der angewandten Informatik ist die Komponentenbasierte Entwicklung (engl.: Component Based Development CBD oder auch Component Based Software Engineering CBSE) ein aus früheren Ansätzen entwickeltes und um deren Schwachstellen bereinigtes… … Deutsch Wikipedia
Component-based usability testing — (CBUT) is a testing approach which aims at empirically testing the usability of an interaction component. The latter is defined as an elementary unit of an interactive system, on which behaviour based evaluation is possible. For this, a component … Wikipedia
Component-based Scalable Logical Architecture — (CSLA) is a software framework created by Rockford Lhotka that provides a standard way to create robust object oriented programs using business objects. Business objects are objects that abstract business entities in an object oriented program.… … Wikipedia
Software engineering — (SE) is the application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software, and the study of these approaches; that is, the application of engineering to software. It is the… … Wikipedia
Frame Technology (software engineering) — Frame Technology is a language neutral, models to code system that manufactures custom software [Software is emphasized here; but given the appropriate frames, FT can assemble any kind of documents: technical and end user manuals, UML models,… … Wikipedia
Computer-aided software engineering — Example of a CASE tool. Computer aided software engineering (CASE) is the scientific application of a set of tools and methods to a software system which is meant to result in high quality, defect free, and maintainable software products. It… … Wikipedia
Component — may refer to: Usage Component may refer to: System components, the constituents of a system Electronic components, the constituents of electronic circuits Component ingredient, the main ingredient in a dish Component video, a type of analog video … Wikipedia
Component Library for Cross Platform — (CLX) (pronounced clicks), is a cross platform visual component based framework for developing Microsoft Windows and Linux applications. It is developed by Borland for use in its Kylix, Delphi, and C++ Builder software development environment.… … Wikipedia
Component repository management — is a field of configuration management that seeks to ensure the safe storage of different components of a software product and all its versions. This topic includes product model, revision control, and software configuration management. Contents… … Wikipedia
Component diagram — of an Insurance Policy Administration System UML diagrams Structural UML diagra … Wikipedia