Showing papers on "Common Component Architecture published in 2009"

Integration of Extra-Functional Properties in Component Models

Abstract: Management of extra-functional properties in component models is one of the main challenges in the component-based software engineering community. Still, the starting point in their management, namely their specification in a context of component models is not addressed in a systematic way. Extra-functional properties can be expressed as attributes (or combinations of them) of components, or of a system, but also as attributes of other elements, such as interfaces and connectors. Attributes can be defined as estimations, or can be measured, or modelled; this means that an attribute can be expressed through multiple values valid under different conditions. This paper addresses how this diversity in attribute specifications and their relations to component model can be expressed, by proposing a model for attribute specifications and their integrations in component models. A format for attribute specification is proposed, discussed and analyzed, and the approach is exemplified through its integration both in the ProCom component model and its integrated development environment.

Facilitated introspection of virtualized environments

Abstract: Some embodiments provide a system that manages the execution of a software component in a virtualized environment. During operation, the system monitors the execution of the software component from an external location to the virtualized environment. Next, the system assesses an integrity of the software component by comparing the monitored execution to an expected operation of the software component, wherein the expected operation is determined based on source code for the software component. Finally, the system uses the assessed integrity of the software component to facilitate the execution of the software component.

An automation agent architecture with a reflective world model in manufacturing systems

Abstract: Manufacturing systems have become very complex, and the traditional hierarchical and centralized approaches are not adequate any more. Decentralized approaches are considered promising, but they are not yet sufficiently understood for widespread industrial application. In particular, agent-based control has not yet achieved its potential, so that more research is still required. Therefore, we propose a new architecture of automation agents. Such an agent is composed of a hardware component and a software component, where the hardware component can be viewed as an embodiment of this software component in its manufacturing environment. An important part of the software component is a world model repository of the automation agent. As a special innovation, the world model is reflective in the sense, that it contains a symbolic representation of the automation agent and of its relations to its environment as well. The world model repository is made up of representations of situations and activities. In summary, we propose an automation agent architecture with a reflective world model for use in manufacturing systems.

Network security module for Ethernet-receiving industrial control devices

Abstract: A high-speed security device for network connected industrial controls provides hybrid processing in tandem hardware and software security components. The software security component establishes state-less data identifying each packet that requires high-speed processing and loads a data table in the hardware component. The hardware component may then allow packets matching data of the data table to bypass the software component while passing other non-matching packets to the software component for more sophisticated state analysis.

Tools and experiments supporting a testing-based theory of component composition

Abstract: Development of software using off-the-shelf components seems to offer a chance for improving product quality and developer productivity. This article reviews a foundational testing-based theory of component composition, describes tools that implement the theory, and presents experiments with functional and nonfunctional component/system properties that validate the theory and illuminate issues in component composition.The context for this work is an ideal form of Component-Based Software Development (CBSD) supported by tools. Component developers describe their components by measuring approximations to functional and nonfunctional behavior on a finite collection of subdomains. Systems designers describe an application-system structure by the component connections that form it. From measured component descriptions and a system structure, a CAD tool synthesizes the system properties, predicting how the system will behave. The system is not built, nor are any test executions performed. Neither the component sources nor executables are needed by systems designers. From CAD calculations a designer can learn (approximately) anything that could be learned by testing an actual system implementation. The CAD tool is often more efficient than it would be to assemble and execute an actual system.Using tools that support an ideal separation between component- and system development, experiments were conducted to investigate two related questions: (1) To what extent can unit (that is, component) testing replace system testingq (2) What properties of software and subdomains influence the quality of subdomain testingq

Software Component Retrieval Using Genetic Algorithms

Abstract: Maintaining consistency between the architecture of a component based software system and the components available in the component repository is a persistent concern in component-based software engineering . Nowadays in the software development practice, the percentage of time and effort allocated to this task is still too small to avoid bugs, which are late to discover and hard to fix. Various methodologies exist to annotate component selection models with data related to verification and validation, and to translate the annotated models into component performance. In any component selection method, it is unrealistic to expect a perfect match between components needed and components available. A group of components that compose a system may have overlaps and gaps in required functionality. A gap represents a lack of functionality; an overlap can cause a confusion of responsibility and degrade nonfunctional properties like size and performance. In the series of these technical unsolved issues, this proposed paper would be an attempt to throw light which on the one of the major issue of component based software engineering is concerned with the “Component Selection”.Recently a Genetic Algorithms based approach is used for component selection to Minimize the gap between components needed and components available. A relevant objective is now at hand in this direction, that is to make these methodologies acceptable from the software engineering community. Therefore, in this paper we develop Genetic Algorithms based approach for selection component.

Increasing Reuse in Component Models through Genericity

Abstract: A current limitation to component reusability is that component models target to describe a deployed assembly and thus bind the behavior of a component to the data-types it manipulates This paper studies the feasibility of supporting genericity within component models, including component and port types The proposed approach works by extending the meta-model of an existing component model It is applied to the SCA component model; a working prototype shows its feasibility

A framework for reasoning on component composition

Abstract: The main characteristics of component models is their strict structure enabling better code reuse Correctness of component composition is well understood formally but existing works do not allow for mechanised reasoning on composition and component reconfigurations, whereas a mechanical support would improve the confidence in the existing results This article presents the formalisation in Isabelle/HOL of a component model, focusing on the structure and on basic lemmas to handle component structure Our objective in this paper is to present the basic constructs, and the corresponding lemmas allowing the proof of properties related to structure of component models and the handling of structure at runtime We illustrate the expressiveness of our approach by presenting component semantics, and properties on reconfiguration primitives

Leveraging component-based software engineering with Fraclet

Abstract: Component-based software engineering has achieved wide acceptance in the domain of software engineering by improving productivity, reusability and composition. This success has also encouraged the emergence of a plethora of component models. Nevertheless, even if the abstract models of most of lightweight component models are quite similar, their programming models can still differ a lot. This drawback limits the reuse and composition of components implemented using different programming models. The contribution of this article is to introduce Fraclet as a programming model common to several lightweight component models. This programming model is presented as an annotation framework, which allows the developer to annotate the program code with the elements of the abstract component model. Then, using a generative approach, the annotated program code is completed according to the programming model of the component model to be supported by the component runtime environment. This article shows that this annotation framework provides a significant simplification of the program code by removing all dependencies on the component model interfaces. These benefits are illustrated with the Fractal and OpenCOM component models.

A component based design framework for robot software architecture

Abstract: Componentization is an important method to improve the reusability of robot software and reduce the difficulty of system design. In this paper, we propose a component based design framework for robot software architecture. First, the robot system is functionally decomposed into reusable components. On this basis, the static model and run-time model of component are established, and a component interface definition language based on the model is designed. Second, a lightweight middleware is proposed according to the communication mode between robot components, and a component development tool and a visual component assembly environment based on the middleware are designed to facilitate the developers. Finally, an application based on the framework is introduced to verify the validation of the design framework.

An Ontology-Driven Paradigm for Component Representation and Retrieval

Abstract: Component-based software reuse is an important research topic in software engineering and is the basis of software product line. Many methods for representation and retrieval of components have been proposed and most of them are faceted-based or specification-based. There is no a uniform formulism for component representation and retrieval. In order to solve this problem, an ontology-based representation model for component and the retrieval algorithm based on this model are proposed. The key factors of component reuse are discussed and it is pointed out that component reuse is the reuse of knowledge about component. Component ontology is employed to represent the knowledge about component. Domain-specific terms are used to represent component by importing domain ontology into component ontology. Component retrieving algorithm is implemented by ontology query and reasoning. The model is used in a large scale distributed simulation system and the fact revealed that component ontology is flexible enough for component reuse and efficiency of retrieving algorithm is gratifying.

Component and dependency discovery

Abstract: Methods, systems, and computer-readable media are disclosed for discovering components and dependencies in a distributed computing environment. A particular method includes discovering a first component and a second component of a distributed computing environment, where the first component and the second component are associated with different discoverable technologies. Each component is discovered based on a match between a characteristic of the component and a technology specification associated with the discoverable technology. The method also includes discovering a dependency between the first component and the second component.

Fine-Grained Tailoring of Component Behaviour for Embedded Systems

Abstract: The application of run-time reconfigurable component models to networked embedded systems has a number of significant advantages such as encouraging software reuse, adaptation to dynamic environmental conditions and management of changing application demands. However, reconfiguration at the granularity of components is inherently heavy-weight and thus costly in embedded scenarios. This paper argues that in some cases component-based reconfiguration imposes an unnecessary overhead and that more fine-grained support for the tailoring of component functionality is required. This paper advocates for a high-level policy-based approach to tailoring component functionality. To that end, we introduce a lightweight framework that supports fine-grained adaptation of component functionality based upon high-level policy specifications. We have realized and evaluated a prototype of this framework for the LooCI component model.

Formal concept analysis-based service classification to dynamically build efficient software component directories

Abstract: Component directories index components by the services they offer thus enabling us to rapidly access them. Component directories are also the cornerstone of dynamic component assembly evolution when components fail or when new functionalities have to be added to meet new requirements. This work targets semi-automatic evolution processes. It states the theoretical basis of on-the-fly construction of component directories using formal concept analysis based on the syntactic description of the services that components require or provide. In these directories, components are more clearly organised and new abstract and highly reusable component external descriptions suggested. Moreover, this organisation speeds up both automatic component assembly and automatic component substitution.

Component Metrics to Measure Component Quality

Abstract: Recently, component-based software development is getting accepted in industry as a new effective software development paradigm. Since the introduction of component-based software engineering (CBSE) in later 90`s, the CBSD research has focused largely on component modeling, methodology, architecture and component platform. However, as the number of components available on the market increases, it becomes more important to devise metrics to quantify the various characteristics of components. In this Paper, we propose metrics for measuring the complexity, customizability, and reusability of software components. Complexity metric can be used to evaluate the complexity of components. Customizability is used to measure how efficiently and widely the components can be customized for organization specific requirement. Reusability can be used to measure the degree of features that are reused in building applications. We expect that these metrics can be effectively used to quantify the characteristics of components.

Automated architectural component classification using concept lattices

Abstract: While the use of components grows in software development, building effective component directories becomes a critical issue as architects need help to search components in repositories. During the life-cycle of component-based software, several tasks, such as construction from scratch or component substitution, would benefit from an efficient component classification and retrieval. In this paper, we analyze how we can build a classification of components using their technical description (i.e. functions and interfaces) in order to help automatic as well as manual composition and substitution. The approach is implemented in the CoCoLa prototype, which is dedicated to Fractal component directory management and validated through a case study.

A new method for component reuse

Abstract: Achieving software reuse is a fundamental problem in software engineering. Component-based development (CBD) is widely accepted as a promising approach for software reuse. Current methods for component reuse concentrate primarily on the component consumer perspective, which are lack of the potential for component evolution itself. This paper proposes two complementary approaches to reusing existing components: binary class-level inheritance and feature composition. To meet variability requirements, a new component can be derived across component module from an old component. Furthermore, to narrow the gulf between the user and the developer perspectives, the system features are decomposed into a set of independent feature components that can be plugged into running object. The design and implementation method on component platform is presented. At last, this paper introduces the graphic user interface and mobile telephone projects development experiments that show the two approaches contribute to reuse.

Extending a Software Component Repository to Provide Services

Abstract: A Software Component Repository is a tool that supports component based development (CBD). Generally, most of the existing repositories only provide components physically, not considering another important way of pro viding them: as services. Therefore, this paper presents an infrastructure for providing component services in a component repository. This infrastructure deals with access control, utilization monitoring, components to services con version, and composite services generation issues.

Component assessment and proactive model for support of dynamic integration in self adaptive system

Abstract: Component Based Software Engineering (CBSE) is a paradigm in use by most of the software developers. In a multi component system, each component is a probable point of malfunction. Typical work to make such system more vigorous and safe are both brittle and time intense. A model has been designed for self-adaptive system that automates the component integration process at runtime by accessing the equivalent component from diversified set of components that may be needed in future. The proposed general model is for proactive adaptation, which pre-fetch the component from the pre available repository. This model integrates the caching technique to reduce the amount of time that has been spent during search of best-fitted component to replace the required one, when a system fails to respond due to component failure. To pre-fetch the required component we perform the component assessment on the basis of numerical metadata for each component present in the repository. In the computation of numerical metadata we design an algorithm which uses the concept of Abstract Syntax Tree. To ensure the consistency in the system after the modification, we have used a technique which is used in GUI based component architecture model. To asses the component at run-time, we provide prototype in .Net technology using its attribute feature, which support run-time component evolution without its execution.

Adaptive Application Composition in Quantum Chemistry

Abstract: Component interfaces, as advanced by the Common Component Architecture (CCA), enable easy access to complex software packages for high-performance scientific computing. A recent focus has been incorporating support for computational quality of service (CQoS), or the automatic composition, substitution, and dynamic reconfiguration of component applications. Several leading quantum chemistry packages have achieved interoperability by adopting CCA components. Running these computations on diverse computing platforms requires selection among many algorithmic and hardware configuration parameters; typical educated guesses or trial and error can result in unexpectedly low performance. Motivated by the need for faster runtimes and increased productivity for chemists, we present a flexible CQoS approach for quantum chemistry that uses a generic CQoS database component to create a training database with timing results and metadata for a range of calculations. The database then interacts with a chemistry CQoS component and other infrastructure to facilitate adaptive application composition for new calculations.

Towards Self-management in Service-Oriented Computing with Modes

Abstract: A self-managed system is both self-assembling and self-healing. Service-oriented Computing (SoC) architectures, such as a Web Services Architecture (WS-A)illustrate a highly distributed, potentially dynamic,domain for component configurations. We propose the use of component architecture "modes" to facilitate the self-management of services within a SoC environment. A mode abstracts a set of services that are composed to complete a given task. Our approach, named "SelfSoC" includes designing and implementing key parts of a self-managed system specifically aimed at supporting a dynamic services architecture. We extend Darwin component models, Alloy constraint models and distributed system management policies to specify the mode architectures. We also propose the generation of dynamic orchestrations for service compositions to coordinate different modes of an automotive services platform.

A Development of Software Component Framework for Robotic Services

Abstract: Robot software components, which can be accessed through their interface, are reusable and replaceable software modules used in composing robotic services. Using robot software components in developing a robot, developers can expect shortening of developing times, reduction of maintenance cost and improvement of program reusability, because interoperability among components is guaranteed. We have developed a component framework assisting robot developers to make robot application with ease. The component framework consists of a specification of component model, a component authoring tool, a component composer, and a component container. In this paper, we will not only show the developed component framework, but also demonstrate its usability by applying to commercial robots.

Modular architecture for real-time contract-based framework

Abstract: Component-based development of distributed real-time applications is a challenging task since satisfying timing requirements of individual components after system integration requires support from the component middleware which is not common today. This paper presents a software architecture of contract-based on-line resource reservation framework which can be used as a basis for a real-time component-based middleware. The main contribution of this architecture is its modularity which allows for support of many different resources such as CPU, networks, disks, FPGAs etc. The paper describes algorithms used to integrate the management of multiple resources and presents some experimental results from Linux implementation.

Metrics of Graph Abstraction for Component-Based Software Architecture

Abstract: The challenges for building the component-based software architecture are how to estimate the assembly of reusable software components and make the properties forecast to the associated architecture To address these issues, this paper discerns the assembly patterns of components and proposes using graph theory to depict the component-based architecture at first Then, the component assembly graph has been defined as the abstract representation of the component assembly in the architecture, which is a key factor in determining the suitable architectural structure Based on such graph theory, some metrics have been defined to measure the components assembly At the end, the paper discusses how to optimize the architecture from component level, which also shows the graph theory should be paid attention to for the software engineering in future

A Model-Driven Engineering Framework for Component Models Interoperability

Abstract: A multitude of component models exist today, characterized by slightly different conceptual architectural elements, focusing on a specific operational domain, covering different phases of component life-cycle, or supporting analysis of different quality attributes. When dealing with different variants of products and in evolution of systems, there is a need for transformation of system models from one component model to another one. However, it is not obvious that different component models can accurately exchange models, due to their differences in concepts and semantics. This paper demonstrate an approach to achieve that. The paper proposes a generic framework to interchange models among component models. The framework, named D U AL Ly allows for tool and notations interpretability easing the transformation among many different component models. It is automated inside the Eclipse framework, and fully-extensible. The D U AL Ly approach is applied to two different component models for real-time embedded systems and observations are reported.

Component Library-Based ERP Software Development Methodology

Abstract: Building ERP system with reusable components brings many advantages. In this paper we discuss how to use component library to support development process of ERP system. First the necessity of researching component library-based software development (CLBSD) is introduced. Then, development methodology and development process based on component library are analyzed at a macro level. After that, we illuminate how to decompose ERP functions into component requirements and the component mapping relations between component requirements and atomic components. According to component requirements, we can retrieve components from component library. With these components, it’s convenient to assemble a whole ERP guiding by main framework component level diagram. Finally, conclusions are given.

Flexible integration of data qualities in wireless sensor networks

Abstract: Wireless sensor networks have been confirmed as a valuable asset to deploy in an increasing number of real-world business scenarios. The existence of several run-time reconfigurable component models for networked embedded systems facilitates this as they enable developers to build complete end-to-end systems composed of reusable building blocks. However, the integration of sensor networks with enterprise environments is not straightforward as it requires that several long-standing challenges related to data quality management and security be addressed. This paper advocates a high-level policy-based approach to more easily support the specification and enforcement of these non-functional requirements in existing component compositions for network embedded systems. We have realized and evaluated a prototype of this framework for the LooCI component model.

Evaluating an evolving software component: case of internal design

Abstract: Component based development is a reuse based approach in which already existing software components are used to assemble a new application. One of the commonly cited advantages of this approach is that application quality is high because mature components are used in the application. This indicates that as components mature their quality improves. In this paper, we have studied evolution of the design structure of a reusable component using package metrics proposed by Robert Martin. Metric values indicate that internal design of the component has improved over time.

A Software Component Model with Concurrency

Abstract: Component-Based Software Development (CBSD) represents a paradigm shift in software engineering, where the focus is on building systems out of pre-developed components. In CBSD, components developers are different from component users, where the former concentrate on building reusable components, whereas the latter concentrate on building customised systems out of components. The different roles in component development give rise to the idealised component life cycle which consists of the design, the deployment and the run-time phases. Ideally, component composition should occur in both design and deployment phases and it should be supported by a proper composition theory. Concurrency is an important issue in software engineering and in theoretical computer science. Decades of research have been devoted in finding efficient ways of discovering common concurrency errors, like deadlock, in abstract mathematical models and in software. Existing software component models do not address composition and concurrency completely. In general, component models support composition in either design or deployment phase but not in both. Regarding concurrency, the support provided varies, ranging from complete formal models to leaving the concurrency aspect undefined and dependant on the implementation. More importantly, not all component models support both passive and active components. In this thesis we define a software component model that supports composition of active and passive components using explicit composition operators, in both design and deployment phases of the idealised component life cycle. We also show that our composition connectors are control patterns and we define their composition. This means that composite connectors are composed out of simpler ones. This allows for the hierarchical construction of complex control structures that can be used in further connector and component compositions. Connector composition constitutes a unique feature of our model.