Assignment on Component-based software engineering (CBSE)
|Paper Type||Assignment Writing|
Component-based software engineering (CBSE)
engineering (CBSE) is advanced level engineering regarding build systems of
civil and electrical engineering. Components make component-based software
engineering (CBSE) different and advanced from traditional software-based
engineering. According to Hieneman and council, a software component is
basically a kind of software element. However, it mainly works and conforms to
a component model in system engineering. Software components can be deployed
and composed independently without requiring any kind of modification regarding
Software Component Models of Component-based software engineering (CBSE)
Software component models define standards for the implementation, composition, deployment, interoperability, evolution, and customization of components. By the use of these standard software component models ensure software development life-cycle. Some common software component models used in the system engineering are Acme-Like ADLs, Fractal, EJB, JavaBeans, Koala, KobrA, UML 2.0 and SOFA.
1. UML 2.0 of Component-based software engineering (CBSE)
UML 2.0 software component model is used in the system engineering with defined interfaces. In this model, the modular unit is a system component having a properly defined interface that can be replaced in the environment with changes in requirement.
2. Acme-Like ADLs of Component-based software engineering (CBSE)
Acme is a software component model
which is mainly based on the architecture description language. Therefore, this
model is also known as Acme-Like ADLs. In this model, a component works as an
architectural unit and projects primary elements for computation and store data
regarding specific systems
3. PECOS of Component-based software engineering (CBSE)
PECOS is also a component-based software model. In this model, the unit of design is used as a system component. Design unit has some specification regarding implementation that need to be considered while developing a plan for this component-based software engineering.
4. EJB of Component-based software engineering (CBSE)
EJB model is a java interface based software component model. In this model, the component is the enterprise Java bean. In the EJB container, we can classify this component as the java class. EJB model provides information regarding bean methods while including entity beans, session beans, beans business model, and message-driven beans.
5. Java Beans Model of Component-based software engineering (CBSE)
Java Beans model also falls in the category of software component model. Bean is considered as the key component in this model on which the overall software model is based. Bean is generally a java class that has various kind of specific properties, events, and methods. In the NetBeans and other visual bean builder tools manipulated and constructed are intended as beans. In this model, beans compose with each other by sending messages through events delegations. Bean builder tools are used to automatically generate, load, and compile classes of event adaptor for events logistics.
6. OSGI Model of Component-based software engineering (CBSE)
This model is related to the activator objects. Model is mainly focused on the bundles of components which includes import, export, and bundles of symbolic names. OSGI model brings modularity to the platform specified for java languages and programming in software development.
These Software component models are further classified and categorized
in accordance to differences in basic characteristics and functions such as
assembly, packaging, implementation, and interface
1. The interface of Software component models
While in the case of Acme-Like ADLs, ports are used to define its interface. Although, each of these interface-related ports has a specific quality to identify an interaction point between environment and component. In this Acme-Like ADLs model, multiple interfaces can be defined by the use of various kind of system ports. In the UML 2.0 software component model, services of modular units are encapsulated through their provided and required interfaces. While on the other hand, PECOS is based on the unit of design component that is not covered by other software component model. Thus, ports are used as interfaces of the design units.
In the software component model, interface ports are connected and composed via connectors in devices. PECOS construct and design systems in specific programming environment (Eclipse) as well as programming languages (Component Composition). Comparative to other software component models, JavaBeans models are the only one to relate deployment with repository category. Somehow, similar to other software component models (e.g. UML 2.0 and Acme-like ADLs) PECOS model also falls in the category of design without a repository. OSGI model is based on the java interface that is similar to EJB and COM model interfaces.
However, on the other hand, component models that fall in the categories of design with deposit-only repository and design with repository are EJB, SOFA, and CCM. EJB model is having the remote interface and invoking enterprise beans in the systems. Moreover, in this software component model interfaces has the capability to expose qualities and key functionality of major component beans. However, another software component model Fractal interface is quite different from previously discussed all software component model. The fractal interface supports the process of introspecting and reconfiguration assisting internal features of the software and connecting it with component content.
2. Assembly of Software component models
The component assembly of UML 2.0 includes elevator control, door, indicators, database, emergency control services and interfaces. The software components play a significant role in producing a transformation of generated code with the correctness of machines. The additional component wrappers use mapping data representation.
Acme Architectural Description Language (ADL) architecture deal with different sets of components. It uses implementation with ArchJava and it is compiled with the instances of the ATM, Bank 1, Bank 2, and Bank Consortium within the assembler of two same composition manner in the design phase. The assembly is based on the vis-à-vis to the object-based approaches. The assembly is dependent on different components of the model including ADL Wright, AADL, Rapid, and SOFA with joint use of UML 2.0.
Enrollment, Chain and Ownership System (PECOS) model is assembled by systematically developed software elements. The other architectural components are elements of design, assemblies, and switches. The system is configured for the dynamic interconnections of the components with sub-system components. The run time and configuration support use components of the system with an evaluation of alternative configuration and run time monitoring.
The assembly of the EJB module is dependent on the enterprise beans and artefact codes. The components of the model are resource adapter code, group web components, and client code. Mostly, EJB is deployed in the JAR files with the creation of directory for the class files and sub-directory of description files.
The assembling environment of Java Beans Model use a number of instances in the programming model and develop new bean, application, and Applet. In this way, the assembly of components uses layout related services in the design. In the assembling process, the visual development tool is used into the application with the user interface for the customization of attributes of the beans.
Excluding all these OSGI as software component model pays attention to the dynamic discovery of services in the assembly process. However, COM and ADLs assemblies and configurations relate to designs mainly rather than discovering services in a dynamic environment.
3. Implementation of Software component models
In the process of implantation,
OSCI model considers executable sets of components rather than working flat
like other models. OSCI model has a higher level of structuring that works
better than programming languages in deployment and implementation process. The
implementation process of UML 2.0 is based on the Java-based code generation
patterns that aid the production of UML models. The implementation involves the
specification of the number of meta-models. Currently, UML is an oriented tool
that provides code generation facilities with complex aspects
Acme Architectural Description Language (ADL) works as a tool with the synchronize Acme architectural model. This model is implemented with Arch Java with the extension of the Java programming language and includes explicit architectural modelling construction process. The model use component-oriented Java programming language with CBSE keywords.
CMS implemented the system of online services for Medicare enrollment through Enrollment, Chain and Ownership System (PECOS). PECOS implementation uses current scope related to the editing for referring and ordering protocols with EMEPOS suppliers. The stages of implementation are change request 6421, phase 1 (enrollment), and Phase 2 (services).
Enterprise Java Bean (EJB) implementation use WebLogic service with the value-added EJB features. The design pattern is selected on the basis of requirement and feature patterns. The other steps and stages of implementation include the creation of source directory, creation of EJB classes with interfaces, a compilation of java source, generation of deployment descriptors, edit deployment description, generation of EJB wrapper, classes, skeleton files, and stub files.
Java Beans Model consists of different classes with java data type features. There are two methods in the JavaBeans implementation classes on the basis of features. The two implementation classes include getPropertyName() and setPropertyName(). The first process is known as accessor and the later one is called Mutator. The visual components in Java use class that hide implementation, encapsulate data and conforms to interfaces.
4. Packaging of Software component models
JavaBean model packages cover various requirements of system engineers regarding implementation in the projects. These packages usually contain information regarding interfaces and classes relevant to the API of JavaBeans. JavaBeans model provides packaging of components for archives and load tools of the builder to enable directory of available and in-hand components of the software. While OSGI, on the other hand, comes up with component packages regarding expert system and import system. In the software development process, these packages are used as components that enable users to import a file or export files to collect information and store key data files. Although, PECOS component software model is having various packages such as a set of ports (for designing), set of functional behaviours, and bundles of property for software development and implementation.
UML 2.0 is mainly followed by the project management team, therefore, such software model packaging includes key functions and components that enable the project management team to visualize paradigm. UML 2.0 packaging contains elements regarding organization and arrangements of elements in the large scale projects that work as a technique to ensure proper management of all project activities. UML 2.0 also offer package diagrams consist of its elements. These packages can have the capability for users to visualize namespaces and build connection in the key components of this model. Apart from this, all these component based software development models come with different packages that are essential to meet the requirements of the project team and project activities.
Particularly, in civil engineering and software development related project numerous components of these software model packages can be used by the project management team. These packages can support to overcome challenges and meet the requirements of users as a single product for specific tasks. However, some of these software component models are essentially require packaging to ensure proper functionality as these models depend upon some specific elements, classes, and components in software. Take the example of JavaBeans Model.
Comparatively, the JavaBeans model is more focused on packaging and deployment. The major reason is its required resources such as configuration files and icons. Excluding this, another reason to have a key focus on packaging for JavaBeans model is its prevention of repetition. Sometimes duplication and repetition can cause a problem for users. Therefore, making a package for all required components and resources is beneficial for the users and model following project managers. A fine example of a JavaBean software component model package is designed the only package. JavaBeans packaging not only reduces the chances of beans duplications but also saves time to find relevant beans and components each time while working on software.
Conclusion of Component-based software engineering (CBSE)
The whole discussion concludes that software component models are some specific component-based. In these models, interface, implementation, assembly, and packaging has some similarities and differences. JavaBeans and OSGI focus on the packaging to ensure availability of all required components at the same place. However, interfaces of Acme-Like ADLs model and UML 2.0 are modular unit-based and designed based that creates the difference.
References of Component-based software engineering (CBSE)
Crnkovic, I., & Larsson, M. P. (2002). Building
Reliable Component-based Software Systems. Artech House.
Lau, K.-K., & Wang, Z. (2007). Software Component Models. IEEE Transactions on software engineering, 33(10), 1081- 1082.
Lau, Kung-Kiu. (2014). Software component models: past, present and future. CBSE, 14(185), 185-186.
Lau, Kung-Kiu; Wang, Zheng. (2005). A Taxonomy of Software Component Models. 31st EUROMICRO Conference on Software Engineering and Advanced Applications, 88-95.
Get Rewriting & Paraphrasing Help!
We have more than 1500 academic writers and we promise 0% plagiarism in your paper.