Intention For Component Based System Engineering Computer Science

Essay add: 28-10-2015, 13:53   /   Views: 214

In component-based system development, the number of parts used to implement a specific software is an significant design parameter. The balance between many small parts and a few large parts must be considered in component and software design.

2. Basis for Components

The basic concept of object-oriented development is that a software system consists of a set of interacting objects [2]. A class is defined as the structure and functions of objects. Objects hides information (encapsulation). This ability is extremely related for component-based software design: user components are not focused in the specific implementation of server components, only the functions that are given in their interfaces are necessary for utilizing those parts. Therefore, objects are qualified for components, guaranteed that their granularity is sufficient.

The goal of Object-Oriented analysis is to understand the software domain and identifying needs. The goal of Object-Oriented design and implementation to meet the needs in a specific environment. When objects are created, a 'template' is needed for their instantiation. The template is the corresponding class. The instantiation mechanism can be seen as a workshop that create individual objects with own property and state. Different to that, components are deployed at some places. Several objects could be controlled by deployed components. Component size is a significant problem within this context.

Table 1. The basic similarities and differences between objects and components



An object is a unit of instantiation;

it has a huge identity.

A component is a unit of independent deployment.

An object has state;

This state can be persistent state.

A component has no persistent state.

An object encapsulates its

state and behavior

A component is a unit if third-party composition.

Object-oriented programming design often do not support explicit 'uses' relationships as they are available with module definition languages [3] and module interconnection languages [4, 5]. This constraint has good reasons: 'uses' describes implementation rather than abstraction in object-oriented programming. However, for implementing components, 'uses' relationships are related. Alike to using a class in object-oriented programming, with component-based system engineering it is relevant what a component provides, not how it realizes offered services. It is still possible to implement components without using object design features. An efficient library of features in a procedural environment is also a feasible solution for component-based development, too.

It is important to note that inheritance is difficult for component implementation, because it compromises information hiding. Inheritance is an 'open' relation between classes: the inheriting class often has full visibility and access to the content of the base class, which allows for extensibility and incremental construction of classes. In opposition, 'uses' relationships between classes are 'closed' relations: the detailed structure is hided to decouple the classes, and only the public interfaces are accessible. This difference is also called the open/closed principle [2]. With inheritance, the weak base class problem may appear: the question whether a base class can be changed without compromising independently developed subclasses. This problem may cause improper dependencies (coupling) between components. As stressed earlier, in component-based application engineering, low coupling and high cohesion are wanted.

3. Reuse of Components and Software Architectures

Reuse plays an significant role in component-based system development, especially on the design level. On the programming level, reuse is often achieved by processes of high-level programming language structures, function libraries, or object-oriented class frameworks. For well-understood domains, generators [6] may be used for combining applications by automatically composing pre-written components. On the design level, design patterns and established software architectures are essential. However, the borderline between design and programming cannot always be located exactly.

3.1. Domain Engineering

The difficulty for application developers to achieve low costs, high productivity and quality has often been attributed to a lack of software reuse. Re-making similar software without saving components for future development cost unwanted resources. While a general software reuse method may not provide efficient improvements. Architectures support domain-specific reuse by serving as frameworks for understanding families of systems, which may be called product lines

Domain engineering [7] is a way for building reusable components. It is designed to improve the quality of developed software products through reuse of software artifacts. In domain engineering, the systematic creation of domain models and architectures are focused. In systematic component reuse, a software area that contains common application features are called the application domain, which is a key concept. Majority of software involves in only a few domains. They constantly improve similar systems to meet varies of user requirements. Rather than building every new software from scratch, great savings can be achieved by reusing parts of previous software.

Phases of domain engineeringDomain analysis

Domain analysis is the procedure of identifying domains and discovering common features among

Article name: Intention For Component Based System Engineering Computer Science essay, research paper, dissertation