Software component

A software component is a software technology for encapsulating software functionality, often in the form of objects (from Object Oriented Programming), in some binary or textual form, adhering some IDL (interface description language) so that the component may exist autonomously from other components in a computer.

Software componentry is a field of study within software engineering. It builds on prior theories of software objects, software architectures, software frameworks[?] and software design patterns, and the extensive theory of object-oriented programming and object-oriented design[?] of all these. It claims that software components, like the idea of a hardware component used e.g. in telecommunication, can be ultimately made interchangeable and reliable.

Software componentry is a common and convinient means for inter-process communication (IPC).

Table of contents 1 History of Software Components 2 Differences Between Object Oriented Programming and Software Components 3 Architecture 4 Technologies for Software Components 5 See also:

History of Software Components

The idea that software should be componetized, be built from prefabricated components, was first published in Douglas McIlroys address at the NATO conference on software engineering in Garmisch[?], Germany, 1968 entitled Mass Produced Software Components. This conference set out to counter the so-called software crisis.

The modern concept of a software component was however largely defined by Brad Cox, who called them Software ICs and set out to create an infrastructure and market for these components by inventing the programming language Objective C at his company Stepstone[?]. (He summarizes this view in his book Object-Oriented Programming - An Evolutionary Approach 1986.) Cox's attempt didn't succeed.

Microsoft paved the road for actual deployment of component software with OLE and COM, a very successful attempt to encapsulate and simplify object interfaces. Nowadays several different successful software component models exist, see list below.

Differences Between Object Oriented Programming and Software Components

The basic idea in object-oriented programming is that software should be written according to a mental model of the actual or imagined objects it represents. It and the related disciplines of object-oriented design[?] and object-oriented analysis[?] focus on modelling real-world interactions and attempting to create 'verbs' and 'nouns' which can be used in intuitive ways, ideally by end users as well as by programmers coding for those end users.

Software components, by contrast, makes no such assumptions, and instead states that software should be developed by glueing prefabricated components together much like in the field of electronics and mechanics. It accepts that the definitions of useful components, unlike objects, can be counter-intuitive. In general it discourages anthropomorphism and naming, and is far more pessimistic about the potential for end user programming and etc. Some peers will even talk of software components in terms of a new programming paradigm: component-oriented programming.

Some say this distinction was made by earlier computer scientists, 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 was that it was simply, and only, a branch of math.

In both forms, this notion has led to many academic debates about the pro's and con's of the two approaches, and possible strategies for uniting the two. Some think they are not really competitors but only describe the same problem from two different points of view.

Architecture

A computer running several software components is called an application server and the field of computing things (mostly one or another financial application, or business software) with this combination of application servers and software components make up is usually called distributed computing.

Doing distributed computing with software components is regarded as unexplicibly cool in certain mileus, notably at parties arranged by those who sell it. As a common user, a good bit of scepticism about technology of this kind never hurts.

Technologies for Software Components

• Component-oriented programming
  • VBX[?], OCX[?], ActiveX, COM and DCOM from Microsoft
  • Enterprise Java Beans from Sun Microsystems
  • XPCOM from Mozilla
• Compound document[?] technologies
  • Bonobo (a part of GNOME)
  • OLE (Object Linking and Embedding)
  • OpenDoc
  • Fresco
• Business object[?] technologies
  • Newi
• Distributed computing software components
  • CORBA from The Open Group
  • DCOM and later versions of COM (and COM+) from Microsoft
  • SOM from IBM (now scrapped)
  • Web Services frameworks from several vendors
    • J2EE from Sun
    • .NET from Microsoft
• Interface description languages
  • SOAP IDL from W3C
  • Part of both COM and CORBA

See also:

• Business logic
• Web Service