Showing papers on "Common Component Architecture published in 2008"

Component-based tailorability: Enabling highly flexible software applications

Abstract: Component technologies are perceived as an important means to keep software architectures flexible. Flexibility offered by component technologies typically addresses software developers at design time. However, the design of software which should support social systems, such as work groups or communities, also demands 'use-time', or technically spoken, 'run-time' flexibility. In this paper, we summarize a decade of research efforts on component-based approaches to flexibilize groupware applications at run-time. We address the user as a 'casual programmer' who develops and individualizes software for his work context. To deal with the challenges of run-time flexibility, we developed a design approach which covers three levels: software architecture, user interface, and collaboration support. With regard to the software architecture, a component model, called FlexiBeans, has been developed. The FreEvolve platform serves as an environment in which component-based applications can be tailored at run-time. Additionally, we have developed three different types of graphical user interfaces, enabling users to tailor their applications by recomposing components. To enable collaborative tailoring activities, we have integrated functions that allow sharing component structures among users. We also present different types of support techniques which are integrated into the user interface in order to enable users' individual and collaborative tailoring activities. We conclude by elaborating on the notion of 'software infrastructure' which offers a holistic approach to support design activities of professional and non-professional programmers.

A Model Transformation from the Palladio Component Model to Layered Queueing Networks

Abstract: For component-based performance engineering, software component developers individually create performance specifications of their components. Software architects compose these specifications to architectural models. This enables assessing the possible fulfilment of performance requirements without the need to purchase and deploy the component implementations. Many existing performance models do not support component-based performance engineering but offer efficient solvers. On the other hand, component-based performance engineering approaches often lack tool support. We present a model transformation combining the advanced component concepts of the Palladio Component Model (PCM) with the efficient performance solvers of Layered Queueing Networks (LQN). Joining the tool-set for PCM specifications with the tool-set for LQN solution is an important step to carry component-based performance engineering into industrial practice. We validate the correctness of the transformation by mapping the PCM model of a component-based architecture to an LQN and conduct performance predictions.

The time-triggered System-on-a-Chip architecture

Abstract: It is the objective of the presented System-on-a-Chip (SoC) architecture to provide a predictable integrated execution environment for the component-based design of many different types of embedded applications (e.g., automotive, avionics, consumer electronics). At the core of this architecture is a time-triggered network-on-a-chip for the predictable interconnection of heterogeneous components. A component can be a self-contained computer, including system and application software, an FPGA, or a custom hardware unit. By providing a single uniform interface to all types of components for the exchange of messages, the architecture supports the component-based design of large applications and enables the massive reuse of components. The time-triggered network-on-a-chip offers inherent fault isolation to facilitate the seamless integration of independently developed components, possibly with different criticality levels. Furthermore, mechanisms for integrated resource management support dynamically changing resource requirements (e.g., different operational modes of an application), fault-tolerance, a power-aware system behavior, and the implementation of fault-handling by reconfiguration.

A Software Component Model with Spatial and Temporal Compositions for Grid Infrastructures

Abstract: Grids are very complex and volatile infrastructures that exhibit parallel and distributed characteristics. To harness their complexity as well as the increasing intricacy of scientific applications, modern software engineering practices are needed. As of today, two major programming models dominate: software component models that are mainly based on a spatial composition and service oriented models with their associated workflow languages promoting a temporal composition. This paper tends to unify these two forms of composition into a coherent spatio-temporal software component model while keeping their benefits. To attest the validity of the proposed approach, we describe how the Grid Component model, as defined by the CoreGRID Network of Excellence, and the Askalon-AGWL workflow language have been adapted.

A component infrastructure for performance and power modeling of parallel scientific applications

Abstract: Characterizing the performance of scientific applications is essential for effective code optimization, both by compilers and by high-level adaptive numerical algorithms. While maximizing power efficiency is becoming increasingly important in current high-performance architectures, little or no hardware or software support exists for detailed power measurements. Hardware counter-based power models are a promising method for guiding software-based techniques for reducing power. We present a component-based infrastructure for performance and power modeling of parallel scientific applications. The power model leverages on-chip performance hardware counters and is designed to model power consumption for modern multiprocessor and multicore systems. Our tool infrastructure includes application components as well as performance and power measurement and analysis components. We collect performance data using the TAU performance component and apply the power model in the performance and power analysis of a PETSc-based parallel fluid dynamics application by using the PerfExplorer component.

Components for integral evaluation in quantum chemistry.

Abstract: Sharing low-level functionality between software packages enables more rapid development of new capabilities and reduces the duplication of work among development groups. Using the component approach advocated by the Common Component Architecture Forum, we have designed a flexible interface for sharing integrals between quantum chemistry codes. Implementation of these interfaces has been undertaken within the Massively Parallel Quantum Chemistry package, exposing both the IntV3 and Cints/Libint integrals packages to component applications. Benchmark timings for Hartree-Fock calculations demonstrate that the overhead due to the added interface code varies significantly, from less than 1% for small molecules with large basis sets to nearly 10% for larger molecules with smaller basis sets. Correlated calculations and density functional approaches encounter less severe performance overheads of less than 5%. While these overheads are acceptable, additional performance losses occur when arbitrary implementation details, such as integral ordering within buffers, must be handled. Integral reordering is observed to add an additional overhead as large as 12%; hence, a common standard for such implementation details is desired for optimal performance.

TADL - An Architecture Description Language for Trustworthy Component-Based Systems

Abstract: Existing architecture description languages mainly support the specification of the structural elements of the system under design with either only a limited support or no support to specify non-functional requirements. In a component-based development of trustworthy systems, the trustworthiness properties must be specified at the architectural level. Analysis techniques should be available to verify the trustworthiness properties early at design time. Towards this goal we present in this paper a meta-architecture and TADL, a new architecture description language suited for describing the architecture of trustworthy component-based systems. The TADL is a uniform language for specifying the structural, functional, and nonfunctional requirements of component-based systems. It also provides a uniform source for analyzing the different trustworthiness properties.

Component meets service: what does the mongrel look like?

Abstract: Computing with services has attracted much attention as a promising approach for developing distributed applications. The approach is often advertised as being superior to distributed component-based software engineering (CBSE), because it provides a higher potential to bridge heterogeneous IT application and infrastructure landscapes. It facilitates cross-institutional cooperation, lets services run over all kinds of ubiquitous communication infrastructure, scales better and simplifies legacy software integration. If this were absolutely true, there would be no reason for a consortium of major vendors of service and Java EE technology to come up with a new specification, called service component architecture (SCA). This emerging standard tries to leverage service-oriented architecture (SOA) principles with component-based software development techniques. In this article we discuss some commonalities and fundamental differences of the CBS and SOA worlds. We illustrate SCA briefly using snippets of an ongoing case study based on an e-university federation. Then we elaborate on the qualities and current deficits of SCA in the light of CBSE findings and related works.

Designing Fault-Tolerant Component Based Applications with a Model Driven Approach

Abstract: The requirement for higher reliability and availability of systems is continuously increasing even in domains not traditionally strongly involved in such issues. Solutions are expected to be efficient, flexible, reusable on rapidly evolving hardware and of course at low cost. Model driven approaches can be very helpful for this purpose. In this paper, we propose a study associating model-driven technology and component-based development. This work is illustrated by the realization of a use case from aerospace industry that has fault-tolerance requirements: a launch vehicle. UML based modeling is used to capture application structure and related non-functional requirements thanks to the profiles CCM (CORBA Component Model) and QoS&FT (Quality of Service and Fault Tolerance). The application model is enriched with infrastructure component dedicated to fault-tolerance. From this model we generate CCM descriptor files which in turns are used to build bootcode (static deployment) which instantiates, configures and connects components. Within this process, component replication and FT properties are declaratively specified at model level and are transparent for the component implementation.

Software test management system and method with facilitated reuse of test components

Abstract: A system and appertaining method is provided for identifying a software test component for reuse in a system whose attributes are stored in a repository, based on the attributes of a component that is in the process of being developed or has been developed. A checking algorithm looks to a repository for a new software test component to see if a similar one exists by comparing various attributes of the new component to attributes of a stored component. If a match is found, the developer is notified and thus uses the stored component instead of the new one.

A Metrics Based Approach to Evaluate Design of Software Components

Abstract: Component based software development approach makes use of already existing software components to build new applications. Software components may be available in-house or acquired from the global market. One of the most critical activities in this reuse based process is the selection of appropriate components. Component evaluation is the core of the component selection process. Component quality models have been proposed to decide upon a criterion against which candidate components can be evaluated and then compared. But none is complete enough to carry out the evaluation. It is advocated that component users need not bother about the internal details of the components. But we believe that complexity of the internal structure of the component can help estimating the effort related to evolution of the component. In our ongoing research, we are focusing on quality of internal design of a software component and its relationship to the external quality attributes of the component.

Integrating Component and Product Lines Technologies

Abstract: In this paper, we explore the integration of product line and component technologies in the context of the product derivation process. In particular, we propose new extensions to our existing model-based product derivation tool, called GenArch, in order to address the new abstractions and mechanisms provided by the Spring and OSGi component models. The GenArch extensions enable the automatic instantiation of product lines and applications - implemented using these component technologies. Moreover, it also enables different levels of customization, from fine-grained configuration of component properties to the automatic selection of components that will compose the final product.

A Lightweight Approach to Partially Reuse Existing Component-Based System in Service-Oriented Environment

Abstract: A fundamental derailment factor for reusing today's business applications is the tight coupling among program components. While SOA advocates an architecture with loose coupling among components, the invocation dependencies among components are still tangled with implementation code traditionally. SCA (Service Component Architecture) - an emerging service-oriented component model - uses a standard and declarative way to handle inter-component dependencies. Thus, SCA components have better reusability from this perspective. This paper proposes a lightweight approach to partially reuse existing components by wrapping them as SCA components. Several challenges are identified and addressed in this paper, especially the one of externalizing component dependencies without changing source code. The proposed approach addresses the challenges systematically, with a supporting system implemented. Moreover, an example scenario is given to better illustrate the usage of the approach. Finally, some future directions of the work are pointed out.

iComponent: A Platform Independent Component Model for Dynamic Execution Environments

Abstract: Service-oriented component models support the dynamic availability of components at run-time and offer the possibility to build dynamically adaptable applications. However, building service-oriented components is a complex task due to the complexity of service-oriented frameworks. In this context today frameworks try to simplify the component development by allowing developers to concentrate only on implementing the business logic of the component and then to configure declaratively the component deployment. In this paper we present a platform-independent component model, iCOMPONENT, which provides these features. We also define a UML profile for constructing components as UML models according to the OMG's model driven architecture. This work is part of a series refering to COMDEVALCO - a framework for software component definition, validation, and composition. As part of COMDEVALCO framework we present a tool for executing UML components expressed in terms of the proposed component model.

A Component Selection Framework for COTS Libraries

Abstract: Component-based software engineering proposes building complex applications from COTS (Commercial Off-The-Shelf) organized into component markets. Therefore, the main development effort is required in selection of the components that fit the specific needs of an application. In this article, we propose a mechanism allowing the automatic selection of a component among a set of candidate COTS, according to functional and non-functional properties. This mechanism has been validated on an example using the ComponentSourcecomponent market.

Deploying Software Components for Performance

Abstract: Performance is a critical attribute of software systems and depends heavily on the software architecture. Though the impact of the component and connector architecture on performance is well appreciated and modeled, the impact of component deployment has not been studied much. For a given component and connector architecture, the system performance is also affected by how components are deployed onto hardware resources. In this work we first formulate this problem of finding the deployment that maximizes performance, and then present a heuristic-based solution approach for it. Our approach incorporates the software architecture, component resource requirements, and the hardware specifications of the system. We break the problem into two sub-problems and formulate heuristics for suggesting the best deployment in terms of performance. Our evaluation indicates that the proposed heuristic performs very well and outputs a deployment that is the best or close to the best, in more than 96% cases.

FCA-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 organized and new abstract and highly reusable component external descriptions suggested. Moreover, this organization speeds up both automatic component assembly and automatic component substitution.

Component Model and Architecture of Smart Devices for Elderly

Abstract: This paper describes a component model and component-based architecture of smart devices and systems that are designed to enhance life quality and well being of elderly individuals. In addition to providing the traditional view of hardware, firmware and software components, the model also provides developers with an operational view. The view enables the developer to specify device-user interactions as executable workflows and allows the device operations and user actions to be experimented with and their correctness ascertained throughout the design and development process. The paper also presents a simulation environment for this purpose.

Typing communicating component assemblages

Abstract: Building complex component-based software architectures can lead to subtle assemblage errors. In this paper, we introduce a type-system-based approach to avoid message handling errors when assembling component-based communication systems. Such errors are not captured by classical type systems of host programming languages such as Java or ML. Our approach relies on the definition of a small process calculus that captures the operational essence of our target component-based framework for communication systems, and on the definition of a novel type system that combines row types with process types.

Life-Cycle Aware Modelling of Software Components

Abstract: Current software component models insufficiently reflect the different stages of component life-cycle, which involves design, implementation, deployment, and runtime. Therefore, reasoning techniques for component-based models (e.g., protocol checking, QoS predictions, etc.) are often limited to a particular life-cycle stage. We propose modelling software components in different design stages, after implemenatation, and during deployment. Abstract models for newly designed components can be combined with refined models for already implemented components. As a proof-of-concept, we have implemented the new modelling techniques as part of our Palladio Component Model (PCM).

A component-based framework for radio-astronomical imaging software systems

Abstract: This paper describes a component-based framework for radio-astronomical imaging software systems. We consider optimal re-use strategies for packages of disparate architectures brought together within a modern component framework. In this practical case study, the legacy codes include both procedural and object-oriented architectures. We consider also the special requirements on scientific component middleware, with a specific focus on high-performance computing. We present an example application in this component architecture and outline future development planned for this project. Copyright © 2007 John Wiley & Sons, Ltd.

From a Business Component to a Functional Component using a Multi-View Variability Modelling.

Abstract: The ability of reusable components to be varied and appropriate to different designers and re-users requirements is a key property in reusable component development, especially in Business Component (BC) development. The primary objective of this work is BCs reuse in different Business Domains. In order to achieve this goal, we focus on the variability concept, which is defined as the ability of a software artefact to be changed or customized so as to be reused in multiple contexts. Thus, we introduce the concept of Functional Component (FC) that captures similarities and variations between BCs that share common behaviours in order to increase their reusability in different business domains. The FC is modelled by using a multiview variability.

Research and Application on CORBA Component Assembly

Abstract: The component-based software development is the inevitable trend in software industrial production,and component assembling is an important step of component-based software development,and also is a hotspot which studies at present.The CORBA component model is introduced,builded a component assembling model based on CORBA,which is used in an E-Commerce system.

Research on architecture-centric component model design

Abstract: Component-based software reuse techniques are one of the efficient ways to improve software quality and productivity.Time is witnessing the trend that systems are developed from components rather than scratch.However,there are still some problems in the field of software reuse,especially concern component modeling.An architecture-centric component model design method is presented.Firstly,software architecture concepts and it's integrated are provided,and then different profiles on component like organization,in-teraction,reality,etc are summarized.The method also imports finite state machine to express component interactive model,then component interface definition is build by analysis state moving,next,component inter-structure is made by class and property description,last,a kind of component description language is used to formalize component model.The modeling approach is presented and the specific process of modeling is illustrated.The validity of the method is proved with an instance "Printer Service".