Showing papers on "Common Component Architecture published in 2005"

Generic framework for integrating components with different interfaces in an enterprise application intergration environment

Abstract: A method, system, and computer program code for integrating components with different interfaces in an enterprise application integration environment. When an enterprise application is assembled, a user may try to wire a component to another component in the enterprise. However, if the reference on the source component does not match the interface on the target component, the components cannot be wired together. In this situation, the user is prompted to introduce an interface mediation component between the source and target application components. The mediation component comprises an interface matching the reference on the source component and a reference matching the interface on the target component. The mediation component mediates the different interfaces at runtime by binding an operation in the source component to an operation in the target component, and performing a parameter mediation of parameters in the first operation to parameters in the second operation.

A taxonomy of software component models

Abstract: CBSE currently lacks a universally accepted terminology. Existing component models adopt different component definitions and composition operators. We believe that for future research it would be crucial to clarify and unify the CBSE terminology, and that the starting point for this endeavour should be a study of current component models. In this paper, we take this first step and present and discuss a taxonomy of these models. The purpose of this taxonomy is to identify the similarities and differences between them with respect to commonly accepted criteria, with a view to clarification and/or potential unification.

Component evolution and versioning state of the art

Abstract: Emerging component-based software development architectures promise better re-use of software components, greater flexibility, scalability and higher quality of services. But like any other piece of software too, software components are hardly perfect, when being created. Problems and bugs have to be fixed and new features need to be added.This paper analyzes the problem of component evolution and the incompatibilities which result during component upgrades. We present the state of the art in component versioning and compare the different methods in component models, frameworks and programming languages. Special attention is put on the automation of processes and tool support in this area. The concluding section sketches a possible solution of these problems we are cur rently working on.

Data redistribution and remote method invocation in parallel component architectures

Abstract: With the increasing availability of high-performance massively parallel computer systems, the prevalence of sophisticated scientific simulation has grown rapidly. The complexity of the scientific models being simulated has also evolved, leading to a variety of coupled multi-physics simulation codes. Such cooperating parallel programs require fundamentally new interaction capabilities, to efficiently exchange parallel data structures and collectively invoke methods across programs. So-called "M/spl times/N" research, as part of the Common Component Architecture (CCA) effort, addresses these special and challenging needs, to provide generalized interfaces and tools that support flexible parallel data redistribution and parallel remote method invocation. Using this technology, distinct simulation codes with disparate distributed data decompositions can work together to achieve greater scientific discoveries.

Digital rights management system based on hardware identification

Abstract: A method for digital rights management is provided. The method is used for managing the right to use a digital software application having a main code component including application code and data resources. The method generates a security component including a hardware identification attribute and appends the security component to the main code component to form a software application package. When the software application package is installed on a hardware device, the security component enables the software application only if the hardware identification attribute is also present in the hardware device.

Microcomponent-based component controllers: a foundation for component aspects

Abstract: In most component models, a software component consists of a functional part and a controller part. The controller part may be extensible; however, existing component models provide no means to capture the structure of the controller part, and therefore neither to specify the controller part extensions. In this paper, we introduce a minimalist component model to capture the structure of the controller part, coining the term microcomponent for the controller part elements. We further introduce the concept of a component aspect as a consistent set of controller part extensions. Within this framework, it is possible to seamlessly integrate controller part extensions, applying them to the components selected in the application's launch configuration. We have evaluated these concepts in a prototype implementation.

On Building Parallel & Grid Applications: Component Technology and Distributed Services

Abstract: Software Component Frameworks are well known in the commercial business application world and now this technology is being explored with great interest as a way to build large-scale scientific applications on parallel computers. In the case of Grid systems, the current architectural model is based on the emerging web services framework. In this paper we describe progress that has been made on the Common Component Architecture model (CCA) and discuss its success and limitations when applied to problems in Grid computing. Our primary conclusion is that a component model fits very well with a services-oriented Grid, but the model of composition must allow for a very dynamic (both in space and in time) control of composition. We note that this adds a new dimension to conventional service workflow and it extends the "Inversion of Control" aspects of most component systems.

Automating the performance management of component-based enterprise systems through the use of redundancy

Abstract: Component technologies are increasingly being used for building enterprise systems, as they can address complex functionality and flexibility problems and reduce development and maintenance costs. Nonetheless, current component technologies provide little support for predicting and controlling the emerging performance of software systems that are assembled from distinct components.This paper presents a framework for automating the performance management of complex, component-based systems. The adopted approach is based on the alternate usage of multiple component variants with equivalent functional characteristics, each one optimized for a different running environment. A fully-automated framework prototype for J2EE is presented, along with results from managing a sample enterprise application on JBoss. A mechanism that uses monitoring data to learn and automatically improve the framework's management behaviour is proposed. The framework imposes no extra requirements on component providers, or on the component technologies.

A strategy for selecting multiple components

Abstract: This paper presents a systematic method for simultaneously defining a software architecture and selecting off-the-shelf components for reuse. The method builds upon existing techniques for component selection and architecture evaluation. We identify architectural decisions that have a large effect on the components used early in the process so that different ways of building the system can be investigated. The result of applying the method is a partial definition of a system's architecture along with a set of components that could be incorporated.

Multilevel Parallelism in Computational Chemistry using Common Component Architecture and Global Arrays

Abstract: The development of complex scientific applications for high-end systems is a challenging task. Addressing complexity of the involved software and algorithms is becoming increasingly difficult and requires appropriate software engineering approaches to address interoperability, maintenance, and software composition challenges. At the same time, the requirements for performance and scalability to thousand processor configurations magnifies the level of difficulties facing the scientific programmer due to the variable levels of parallelism available in different algorithms or functional modules of the application. This paper demonstrates how the Common Component Architecture (CCA) and Global Arrays (GA) can be used in context of computational chemistry to express and manage multi-level parallelism through the use of processor groups. For example, the numerical Hessian calculation using three levels of parallelism in NWChem computational chemistry package outperformed the original version of the NWChem code based on single level parallelism by a factor of 90% when running on 256 processors.

Specification and evaluation of safety properties in a component-based software engineering process

Abstract: Over the past years, component-based software engineering has become an established paradigm in the area of complex software intensive systems. However, many techniques for analyzing these systems for critical properties currently do not make use of the component orientation. In particular, safety analysis of component-based systems is an open field of research. In this chapter we investigate the problems arising and define a set of requirements that apply when adapting the analysis of safety properties to a component-based software engineering process. Based on these requirements some important component-oriented safety evaluation approaches are examined and compared.

Design, implementation, and performance of an automatic configuration service for distributed component systems

Abstract: SUMMARY Component technology promotes code reuse by enabling the construction of complex applications by assembling off-the-shelf components. However, components depend on certain characteristics of the environment in which they execute. They depend on other software components and on hardware resources. In existing component architectures, the application developer is left with the task of resolving those dependencies, i.e., making sure that each component has access to all the resources it needs and that all the required components are loaded. Nevertheless, according to encapsulation principles, developers should not be aware of the component internals. Thus, it may be difficult to find out what a component really needs. In complex systems, such as the ones found in modern distributed environments, this manual approach to dependency management can lead to disastrous results. Current systems rely heavily on manual configuration by users and system administrators. This is tolerable now, when users have to manage a few computers. But, in the near future, people will have to deal with thousands of computing devices and it will no longer be acceptable to require the user to configure each of them. This article presents the results of our six-year research (from 1998 to 2003) in the area of automatic configuration, describing an integrated architecture for managing dependencies in distributed componentbased systems. The architecture supports automatic configuration and dynamic resource management in distributed heterogeneous environments. We describe a concrete implementation of this architecture, present experimental results, and compare our approach to other works in the area.

A component-based toolkit for simulating reacting flows with high order spatial discretisations on structured adaptively refined meshes

Abstract: We present an innovative methodology for developing scientific and mathematical codes for computational studies of reacting flow. High-order (>2) spatial discretisations are combined, for the first time, with multi-level block structured adaptively refined meshes (SAMR) to resolve regions of high gradients efficiently. Within the SAMR context, we use 4th order spatial discretisations to achieve the desired numerical accuracy while maintaining a shallow grid hierarchy. We investigate in detail the pairing between the order of the spatial discretisation and the order of the interpolant, and their effect on the overall order of accuracy. These new approaches are implemented in a high performance, component-based architecture (Common Component Architecture) and achieve software re-usability, flexibility and modularity. The high-order approach and the software design are demonstrated and validated on three test cases modelled as reaction-diffusion systems of increasing complexity. We also demonstrate that the 4th order SAMR approach can be computationally more economical compared to second-order approaches.

Enabling self-management of component-based high-performance scientific applications

Abstract: Emerging high-performance parallel/distributed scientific applications and environments are increasingly large, dynamic and complex. As a result, it requires programming systems that enable the applications to detect and dynamically respond to changing requirements, state and execution context by adapting their computational behaviors and interactions. In this paper, we present such a programming system that extends the common component architecture to enable self-management of component-based scientific applications. The programming system separates and categorizes operational requirements of scientific applications, and allows them to be specified and enforced at runtime through reconfiguration, optimization and healing of individual components and the application. Two scientific simulations are used to illustrate the system and its self-managing behaviors. A performance evaluation is also presented.

Performance technology for parallel and distributed component software

Abstract: This work targets the emerging use of software component technology for high-performance scientific parallel and distributed computing While component software engineering will benefit the construction of complex science applications, its use presents several challenges to performance measurement, analysis, and optimization The performance of a component application depends on the interaction (possibly nonlinear) of the composed component set Furthermore, a component is a ‘binary unit of composition’ and the only information users have is the interface the component provides to the outside world A performance engineering methodology and development approach is presented to address evaluation and optimization issues in high-performance component environments We describe a prototype implementation of a performance measurement infrastructure for the Common Component Architecture (CCA) system A case study demonstrating the use of this technology for integrated measurement, monitoring, and optimization in CCA component-based applications is given Copyright © 2005 John Wiley & Sons, Ltd

A component-based control system for agile manufacturing:

Abstract: Increasing complexity and interdependency in manufacturing enterprises requires an agile manufacturing paradigm This paper considers the characteristics that a component-based control system needs to embody to support agility in this context The concept of a component that incorporates automation hardware, software, control services, and manufacturing-related services into a basic modular unit is reported A component encapsulates low-level, real-time implementation and component-specific knowledge, which are abstracted and exposed as standard interfaces to enable it to be integrated into a manufacturing system as a common, reusable building block The concept and control of the component is outlined in this paper and the methodology for the implementation of a component-based control system is illustrated Finally, the implementation of the component-based concept at Johann A Krause Maschinenfabrik GmbH, a major manufacturer of automotive assembly automation systems, is described

Method and system for a reference model for an enterprise architecture

Abstract: Systems and methods for a reference model for the representation of an arbitrarily complex enterprise architecture are disclosed. These systems and methods provide a reference model composed of component types and relationship types useful in modeling an enterprise architecture. The reference model may be constructed according to a set of domains. A set of component types associated with each of these domains may be defined and relationship types defined for these component types. A data model of a particular enterprise architecture may then be instantiated using this reference model.

A model-driven environment for component deployment

Abstract: This paper presents deployment factory, a model-driven unified environment for deploying component-based applications. While there are projects aiming to develop a unified deployment environment for component-based applications, none of them is generic enough - they do not support heterogeneous applications, they are targeted for a single component technology and/or impose modifications of the underlying technologies. The deployment factory targets all these issues. It is based on (i) the OMG deployment and configuration specification, (ii) an analysis of contemporary used component technologies, and (iii) our experience from component-based development. Moreover, the paper also shows that a plain MDA approach (the one used in the OMG deployment and configuration specification) for building real systems is not always appropriate.

Composition assessment metrics for CBSE

Abstract: The objective of this paper is the formal definition of composition assessment metrics for CBSE, using an extension of the CORBA component model metamodel as the ontology for describing component assemblies. The method used is the representation of a component assembly as an instantiation of the extended CORBA component model metamodel. The resulting meta-objects diagram can then be traversed using object constraint language clauses. These clauses are a formal and executable definition of the metrics that can be used to assess quality attributes from the assembly and its constituent components. The result is the formal definition of context-dependent metrics that cover the different composition mechanisms provided by the CORBA component model and can be used to compare alternative component assemblies; a metamodel extension to capture the topology of component assemblies. The conclusion is that providing a formal and executable definition of metrics for CORBA component assemblies is an enabling precondition to allow for independent scrutiny of such metrics which is, in turn, essential to increase practitioners confidence on predictable quality attributes.

Component-based software engineering

Abstract: We discuss some of the difficulties and significant issues that we need to consider when developing a formal method for component-based software engineering. We argue that to deal with the challenges, there is a need in research to link existing theories and methods of programming for effective support to component-based software engineering. We then present our initiative on a unified multi-view approach to modelling, design and analysis of component systems, emphasising the integration of models for different views.

A Common Criteria Based Approach for COTS Component Selection

Abstract: Component-based software engineering (CBSE) endeavors to enable software developers to develop quality software systems with less time and resources than traditional development approaches. Software components must be identified and evaluated in order to determine if they provide required functionality for systems being developed. Consideration of security requirements for component selection is of interest. This research considers how the Common Criteria (CC), an internationally recognized standard for security requirements definition and security assessment of IT systems, can be applied towards the development of component-based systems. A CCbased COTS component selection process is proposed which integrates activities of the CC for security requirements specification and evaluation. Research questions are presented for the evaluation of the process to establish its value for COTS component selection as well as to identify areas for improvement.

Ccaffeine framework : composing and debugging applications interactively and running them statically.

Abstract: Ccaffeine is a Common Component Architecture (CCA) framework devoted to high-performance computing. In this note we give an overview of the system features of Ccaffeine and CCA that support component-based HPC application development. Object-oriented, single-threaded and lightweight, Ccaffeine is designed to get completely out of the way of the running application after it has been composed from components. Ccaffeine is one of the few frameworks, CCA or otherwise, that can compose and run applications on a parallel machine interactively and then automatically generate a static, possibly self-tuning, executable for production runs. Users can experiment with and debug applications interactively, improving their productivity. When the application is ready, a script is automatically generated, parsed and turned into a static executable for production runs. Within this static executable, dynamic replacement of components can be performed by self-tuning applications.

Towards automatic monitoring of component-based software systems

Abstract: The quality of software components is very important for the overall service quality of the component-based software systems. Several factors make exhaustive testing of components very difficult. Furthermore, the behavioral correctness of each independently produced component does not guarantee the behavioral correctness of the composed software system. Experience shows that there are faults in components which elude the testing effort and do not surface until the system is operating. In this paper, a specification-based software monitor is presented which can be used for detecting certain kinds of errors and failures of a component as well as the whole system while the system is operating. The behavior of each component is assumed to be specified in a formalism based on communicating finite state machines with addressing variables, and inter-component communications are achieved via asynchronous message passing. The monitor passively observes the external input/output and receives partial state information of the target system or component. These are used to interpret the specification. The approach is compositional as it achieves global monitoring by analyzing the behavior of the components of a system individually, and then combining the results obtained from the independent component analyses. The paper describes the architecture and operations of the monitor and includes illustrative examples. Techniques for dealing with non-determinism and concurrency issues in monitoring a concurrent component-based system are also discussed.

Encapsulation and unified access scheme for components

Abstract: A method is provided for encapsulating and accessing components, comprising: configurating component warehouse and storing components acquired from the Internet into the component warehouse to form a component warehouse computer; configurating a component directory library on another computer to form a component directory library computer; fetching component from the component computer by a user computer, encapsulating the component to form a encapsulated component, and organizing and storing the encapsulated component in the component directory library computer; and performing unified access to component resources by a user computer based on the component encapsulation information in the component directory library computer. The method can implement unified description and efficient organization of the existing component resources, to thereby support efficient retrieval and unified access to the component resources by high level applications. The method can also improve the reuse of network software and the efficiency of software development in many application fields.

Adaptive component allocation in scudware middleware for ubiquitous computing

Abstract: With the increasing prevalence of ubiquitous computing, the software component allocation while meeting various resources constraints and component interdependence is crucial, which poses many kinds of challenges This paper mainly presents an adaptive component allocation algorithm in ScudWare middleware for ubiquitous computing, which uses dynamic programming and forward checking methods We have applied this algorithm to a mobile music space program and made many experiments to test its performance The contribution of our work is twofold First, our algorithm considers resources constraints requirement, component interdependence, and component tolerant issues Second, we put forward a component interdependence graph to describe interdependent relationships between components As a result, the evaluation of component allocations has showed our method is applicable and scalable

Specifying interaction constraints of software components for better understandability and interoperability

Abstract: A vital issue in the correct use of commercial-off-the-shelf (COTS) components is the proper understanding of their functionality, quality attributes and ways of operation. Traditionally, COTS component vendors provide some of this information in accompanying documentation. However, the documentation is often informal and likely contains ambiguous and inconsistent statements. Even equipped with interface descriptions clearly defining the basic aspects of component use, such as operation signatures and operating platforms, this documentation does not provide a mathematically sound means for addressing the behavioural interoperability issues in component-based system design. In this paper, we propose a formal but user-friendly component specification approach which augments commercial IDLs with the capability of capturing component interoperability requirements. This approach uses unambiguous temporal operators to define sequencing and concurrency constraints between component operation invocations. Accordingly, it enables precise specifications of how a component provides its services and the correct way in which its services should be used.

Building Applications from a Web Service based Component Architecture

Abstract: This chapter describes an approach to building large-scale, distributed applications based on a software component composition model that allows web services to be used as the basic units. The approach extends the Common Component Architecture used in many parallel supercomputer applications, from static composition of directly coupled processes to a system that incorporates mediated workflow between remote services. The system also allows legacy applications to be easily wrapped as a component and executed from a service factory. We motivate the work in terms of a large, distributed application for modeling severe storms. The entire system is based on a three-level architecture with a portal providing the user interface, a set of security and factory service utilities in the middle and the application services and components in the back-end.