Explain Component Based Software Engineering ?

ANSWER: Software components are units of software designed to interact with other independently developed components, and to be assembled by third parties into applications. Software component engineering focuses on the packaging of software into independent units to allow maximum reusability.

Component-based software development (CBD) is an evolution of object oriented software development (OOD). While both share the goal of software reusability, OOD is an implementation methodology, while CBD is an interface methodology. In CBD the emphasis is on standardizing the interfaces between components, with no restrictions on how the implementation is accomplished. CBD therefore is closely related to module design in separating interface and implementation..

In OOD, code reuse is accomplished through inheritance of implementation code. While OO languages also generally allow separation of implementation and interface, in practice the desire for code reuse often complicates data typing, and inheritance breaks data encapsulation (Snyder86). Partly for these reasons and partly due to the extra level of effort to prevent unnecessary dependencies, class hierarchies tend to be reused only within an application. Of course, class libraries as well as procedural libraries designed to be incorporated into larger applications are successful examples of software reuse.

Components require a deployment environment that Szyperski calls a component world or component environment. The services that a component needs from its environment are called its context dependencies. The mechanisms by which components interact are sometimes called wiring standards, and are one of the most important specifications of a component environment. There are currently three major component environments: The Object Management Group’s (OMG) CORBA, Microsoft’s COM, and Sun’s JavaBeans.

CORBA is an interface standard for distributed objects which may be implemented in different languages and running on different platforms. An object is defined with an Interface Description Language (IDL), and language and platform specific bindings must be created by CORBA vendors.

COM is a binary standard that defines interfaces between components. It grew out of Microsoft’s highly successful Visual Basic controls. A COM component can be implemented in any language, although is most often created in Visual Basic or C++, since Microsoft provides tools for those languages. COM is supported for MS Windows. MacOS, and by third parties for other platforms. COM supports interface inheritance but not implementation inheritance, and allows components to be nested inside of one another. DCOM is an extension of COM to distributed components. COM+ is an object-oriented version of COM for components within a single process.

JavaBeans is a set of conventions for Java to support component-based software development. The support for these conventions is embedded in the Java language and supporting class libraries, so JavaBeans is a Java-only component framework. However, using the Java Native Interface API, Java classes can wrap components built in other languages, can become COM components, and can be CORBA components as well.

A component describes itself through its interface, which can be thought of as a contract with whoever uses it. The contract has two parts: the syntax specifies the data types of the interface method’s arguments, which can be enforced automatically at compile or run time. The contract semantics describe the behaviour of the component, and can only be understood by humans, and so typically is represented by the documentation that the component developer provides. Because semantics are always context specific, the standardization of component behaviour is necessarily specific to an application domain, and are called domain standards. The OMG has created several "domain task forces" to create domain standards for business, manufacturing, electronic commerce, telecommunications, finance, and medicine. Both the Java and OLE communities also have domain specific efforts.

The combination of domain standards and supporting implementation classes and components that facilitate independent component development is called a component application framework, the most familiar example being GUI application builders.

 A component framework must specify both wiring and domain standards for the components it provides, that is, both syntactic and semantic descriptions of its interfaces. In practice, a component framework is an implementation of a domain standard and so both simultaneously evolve out of each other.