This essay has been submitted by a student. This is not an example of the work written by our professional essay writers.
This research paper starts defining the terms Component and Component Based Software Engineering and then talks a little bit about the evolution of the programming languages and then it mainly deals how components are dealt by Microsoft .Net Framework, Java, CORBA and finally web services.
“A software component is a unit of composition with contractually specified interface and explicit context dependencies only. A software component can be deployed independently and is subject to composition by third parts.” (Szyperski, Gruntz & Murer, 2002)
Component Based Software Engineering
“Component Based Software Engineering is a sub discipline of software engineering, primarily concerned with three functions: Developing software from reproducing parts, the ability to reuse those parts in other applications and easily maintaining and consuming those parts to produce new functions and features.” (Heineman, 2001)
Evolution of programming:
The first programming languages are the structured programming languages which can further be classified into two types, first one using the goto statements in the language and the other not using them. In early 1980s we started developing Computer Aided Software Engineering (CASE) tools, and since then we developed hundreds of them. Because of the CASE tools the software productivity was increased dramatically. Then we came across another programming paradigm called Object Oriented Programming (OOP) in which every thing is treated as objects and it introduced lots of new techniques like polymorphism, inheritance and so on. OOP also concentrates on reuse of the programming and hiding the data. Though OOP and CASE tools are available the original style of writing the program is the same, author has to write code line by line. Then came a new technique which eliminates this backdrop called the Component Based Software Engineering (CBSE). Then they started writing codes for components instead of writing line by line code. In CBSE we build small components which we can combine to form the original large software systems. And we can reuse these components. Then came the standards for the components. From then the CBSE gained a lot of popularity because of which many industries came forward to implement this CBSE. (Wang, 2000) Now we will see how each of them deals with the components.
Components in Microsoft .Net Framework
Component Object Model (COM)
COM was introduced by Microsoft in the year 1993. It is an architecture which allows users to combine different components made using different technologies that support COM to produce a wide verity of applications. (Williams, 1994). COM includes several technologies like OLE, COM+, Distributed COM (DCOM) and ActiveX controls. Microsoft provides COM interfaces for several Windows based applications like Microsoft Message Queuing (MSMQ), Microsoft Active Directory (AD) and Windows Management and Instrumentation (WMI). (COM: Component)
COM is a binary standard, which does not specify anything about how a programming language may be bound to it or what a component is. It is not associated with any application it just wants what a component can do. The primary entity that COM defines is an interface. (Szyperski, Gruntz & Murer, 2002). COM defines Application Program Interface (API) for different programs to interact but all programs must follow the binary structure defined by the Microsoft. (Component Object Model). The recent trend is shifting from COM to .Net technologies, even Microsoft is encouraging the developers to use .Net instead of COM. (COM: Component)
“Microsoft Transaction Server (MTS) is a component-based transaction processing system for developing, deploying, and managing high-performance, scalable, and robust enterprise, Internet, and intranet server applications.” (Getting Started). Next to the COM and MTS Microsoft introduced COM+ (combining both technologies) which is used to increment the applications developed by the COM and MTS and any other technology using COM. The main aim of the COM+ is to reduce the burden on the developers by handling many tasks such as security which previously was supposed to be handled by the programmers. It is not only used in developing the enterprise-wide, mission critical, distributed applications which runs on the windows platform but also to manage and deploy those applications. (COM+)
Distributed Component Object Model (DCOM)
As the name itself indicates that in DCOM several components are distributed among different computers which can be connected either through LAN, WAN or internet which have DCOM on their systems and can use different languages. DCOM is the next version of the COM so we can use the existing COM applications in several locations and can convert it into distributed applications while DCOM taking care of all the underlying networking concepts and the developer can concentrate on the actual application that has to be given to the user and can get the best product. DCOM also provides garbage collection. We can increase the scalability of the application by using the concept of the distribution. As several components will be residing in several places it is very important to maintain the location independence. And we must follow certain techniques like keeping the servers which interact more near to each other, and also care must be taken in the size of the components as small components are easy to deploy and may increase the network traffic while the large components make it exactly the opposite way. (DCOM)
“The .Net platform is a development framework that provides a new Application Programming Interface (API) to the services and APIs of classic Windows operating system while bringing together a number of disparate technologies that emerged from Microsoft during late 1990s” (Liberty, 2005) .Net supports language independence and language integration by forcing all its components to follow a Common Type System (CTS). It also includes Common Language Specifications (CLS) to maintain language integrity. In .Net programs are not directly converted into machine codes they are first converted into assemblies that consist of Microsoft Intermediate Language (MSIL) after which they are converted into machine executables using CLR. When we want to compile the MSIL file it is compiled again using the Just In Time (JIT) Compiler. So MSIL files of all the .Net languages are almost identical which makes them language independent. (Liberty, 2005)
Components in JAVA
Java 2 platform Enterprise Edition (J2EE)
“The idea behind the J2EE platform is to provide a simple, unified standard for distributed applications through a component-based application model.” (Allamaraju & Buest,2004)
Normally J2EE platform contains one or more containers, access to Java Application Programming interfaces (API).
There are several technologies which can be classified into 3 are supported by the Java
The component technologies: These are used to hold the buisiness logic and have 3 types of components, JSP pages, servlets, and Enterprise Java Beans. They include web components, EJB components and XML.
The service technologies: these provide components with supported services to function efficiently. These include JDBC, JNDI, JMS, Java Mail and JAAS
The communication technologies: these are used to communicate among different parts of the application. These include Internet protocols like HTTP,TCP/IP,SSL and Remote Object Protocols like RMI, JavaIDL.
There are several advantages of J2EE which include Platform Independence, Modularity, Reusability and so on. (Allamaraju & Buest,2004)
“A Java Bean is a reusable software component that can be visually manipulated in builder tools.” (Voss, 1996)
The concept of introspection is what that differs the java beans from the other java classes. Introspection means that the classes and method signatures can know the behavior of the bean by looking inside the bean. We can manipulate the behavior of the bean while it is being assembled as a part of another larger application. Apart from the introspection the java beans should also have certain common features like customization which allows the users to change the behavior and the appearance of the bean. The customization is achieved by supporting the properties through which beans can be manipulated programmatically. After the customization is done the state of the beans must be saved and it is known as persistence. Users must me able to trigger certain type of events and they must be capable of handling some of them. (Voss, 1996)
The main use of the beans is to enable the visual construction of the applications. Using beans for all the software modules is not a good technique. Beans are good to some software components in which we want to change them visually within the builder tools. (Voss, 1996)
Enterprise JavaBeans (EJB)
This architecture is for the server side component model for the java platform which allows the developers to completely concentrate on the product while it taking care of the remaining things like security, threading etc. There are two models to build an enterprise application. In first model the user creates a session using an object which acts like the application where as in second model the user uses an object that represents an entity in the database. EJB can be used in both the models. EJB uses Session Beans to cover the first model and Entity Beans to cover the second one. (Roth, 1998). There are two types of Session Beans they are Stateless Session Beans which does not store any information between invocations, Stateful Session Beans which stores the information between the beans and the particular client that is using the bean. Excluding from the Session and Entity Beans EJB also supports Message Beans which eliminates the bottle neck of waiting for the result from the bean by using Java Messaging Service (JMS). (Kmiec, 2002).
Benefits of EJB
1) Productivity increases as they have to only concentrate on the business logic
2) Architectural independence can be achieved as user only knows about the java platform and the underlying technologies are hidden from the user.
3) EJB guarantees Server-Side Write Once, Run Anywhere until that server provides the EJB Application Program Interface (API).
4) EJB can protect the investments as it runs on the top of the present enterprise system. (Roth, 1998).
Components in CORBA
“Common Object Request Broker Architecture (CORBA) is an architecture and specification for creating, distributing, and managing distributed program objects in a network. It allows programs at different locations and developed by different vendors to communicate in a network through an interface broker” (Hewitt, 2006). The main concept behind the CORBA is Object Request Broker (ORB). Client can request any object or function from the server with out actually knowing where the server is in the distributed environment if the network supports the ORB. For the communication between ORBs it uses the General Inter ORB Protocol (GIOB) and Internet Inter ORB Protocol (IIOB) for the communication with the internet. (Hewitt, Roets &Walker 2006).
The CORBA is comprised of mainly five components of which we already discussed about the ORB. The remaining components are
- Interface Definition Language (IDL): Even after identifying the object, object reference cannot use it until it knows what services are provided by the object. CORBA uses IDL to describe object interfaces which almost resembles C++ in syntax.
- Interface Repository (IR): It stores all the IDL interface declarations. It also provides descriptions of all operations that an object supports.
- Dynamic Invocation Interface (DII): It is a client side stub which is capable of forwarding any request to the object. Though DII provides lots of flexibility it is costly. It is suggestible to use static IDL to make requests rather than using DII especially when using the compilation programming languages.
- Object Adopter (OA): It provides several ways in which various types of object implementations use ORB services like security, object method invocation and so on. Based on the underlying ORB either itself handles the services or forwards it to the ORB. (Vinoski, 1993).
CORBA and Microsoft had come to an agreement and designed the CORBA and DCOM or COM in such a way that object created in one can interact with the other server and vice versa. (Hewitt, Roets &Walker 2006). CORBA has several advantages. It supports several existing languages. It supports both object orientation and distribution, it provides very high degree of interoperability, because of which it is backed by over 600 companies. (Why Use, 1997).
Components in Web Services
Web Service: “A software system designed to support interoperable machine-to-machine interaction over a network. It has an interface described in a format that machines can process (specifically WSDL). Other systems interact with the Web service in a manner prescribed by its description using SOAP messages, typically conveyed using HTTP with XML serialization in conjunction with other Web-related standards (W3C).” (Sprott & Wilkes, 2004)
Service Oriented Architecture (SOA): “The policies, practices, frameworks that enable application functionality to be provided and consumed as sets of services published at a granularity relevant to the service consumer. Services can be invoked, published and discovered, and are abstracted away from the implementation using a single, standards-based form of interface.” (Sprott & Wilkes, 2004)
Service Oriented Architecture has certain key characteristics
- They have self describing interfaces in XML documents which are platform independent and the standard used to describe them is WSDL.
- The messages they use to communicate are defined in XML schema which is also called as XSD
- SOA services are maintained in the enterprise by a registry that acts as the directory listing. When the applications want any services they look up in the registry and will invoke them.
- Every SOA have a Quality Of Service (QOS) associated with it. Some of the QOS elements are security, authentication and authorization, reliable messaging. (Kodali, 2005)
Web services have the above mentioned architectural characteristics through which it provides platform independence, self description, loose coupling and so on. They can also provide a formal separation between the producer and the consumer. (Sprott & Wilkes, 2004).
Challenges for Component Based Software Engineering
Though we are much advanced in the CBSE still we have some drawbacks some of them include
Trusted Components: As we give the components in the binary form it means that we have no chance to look inside them and we have to completely trust the component.
Component Certifications: We believe that the certification is the best way to trust some one even which may fail for some reasons.
Development models: Though we have powerful models still we have some ambiguity between them which makes them difficult to use.
Component Configurations: As we start building large components after some time we start treating composition of component as a single component which will raise the configuration problems.
Long term management of component-based systems : As the single system contains several components with different life cycles the evolution of the system becomes more and more difficult. (Crnkovic, 2006)
Szyperski, Clemens,Gruntz, Dominik, Murer,Stephen. (2002). Component Software- Beyond Object Oriented Programming. New York: ACM Press.
Heineman, G, Councill, W. ( 2001, june 8) . Component Based Software Engineering - Putting The Pieces Together. Retrieved March 28, 2007, from http://www.mrtc.mdh.se/publications/0325.pdf.
Willliams, Sara, Kindel, Charlie. (1994, October). The Component Object Model: A Technical Overview. Retrieved March 28, 2007, from http://msdn2.microsoft.com/en-us/library/ms809980.aspx
COM: Component Object Model Technologies. Retrieved March 28, 2007, from http://www.microsoft.com/com/default.mspx
Component Object Model (COM), DCOM, and Related Capabilities. Retrieved March 28, 2007, from http://www.sei.cmu.edu/str/descriptions/com.html
Getting Started with MS Transaction Server. Retrieved March 28, 2007, from http://www.microsoft.com/technet/archive/transsrv/mtxpg03.mspx?mfr=true
COM+ (Component Services). Retrieved March 28, 2007, from http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cossdk/html/dd4a9943-070b-4f84-8c0e-6c6e070d8e5b.asp
DCOM Technical Overview. ( 1996, November). Retrieved March 28, 2007, from http://msdn2.microsoft.com/en-us/library/ms809340.aspx#dcomtec_why
Voss, Greg. (1996, November). Java Beans: Introducing Java Beans. Retrieved March 29, 2007, from http://java.sun.com/developer/onlineTraining/Beans/Beans1/index.html
Roth, Bill. (1998, October). An Introduction to Enterprise JavaBeans Technology. Retrieved March 29, 2007, from http://java.sun.com/developer/technicalArticles/ebeans/IntroEJB/index.html
Kmiec, Michael. (2002, June 19). Getting Started with Enterprise JavaBeans. Retrieved March 29, 2007, from http://builder.com.com/5100-6370-1045748.html
Hewitt, Jan, Roets, Cecil, & Walker, Andy. (2006, July 10). CORBA. Retrieved March 30, 2007, from http://searchsqlserver.techtarget.com/sDefinition/0,,sid87_gci213865,00.html
Vinoski, Steve. (1993, August). Distributed Object Programming with CORBA. Retrieved March 30, 2007, from http://www.cs.wustl.edu/~schmidt/PDF/docwc.pdf
Why Use CORBA.(1997, September 8). Retrieved March 30, 2007, from http://www.packetstormsecurity.org/programming-tutorials/CORBA/why-corba.html
Sport, David, Wilkes, Lawrence. (2004, January). Understanding Service- Oriented Architecture. Retrieved April 2, 2007, from http://msdn2.microsoft.com/en-us/library/aa480021.aspx
Kodali, Raghu R. (2005, June 13). What is Service-Oriented Architecture. Retrieved April 2, 2007, from http://www.javaworld.com/javaworld/jw-06-2005/jw-0613-soa.html?page=1
Liberty, Jesse. (2005). Programming C#. Sebastopol: O'Reilly
Wang, Ju An. (2000, October). Towards Component-Based Software Engineering. Retrieved April 2, 2007, from ACM Portal database.
Allamaraju, Subrahmanyam & Buest, Cedric. (2005, October). Professional Java Server Programming. Mumbai : APress
Crnvokic, Ivica (2006). Component Based Software Engineering - New Challenges in software development. Retrieved April 2, 2007, from http://www.mrtc.mdh.se/publications/0328.pdf