Component-based Systems Research Articles

The design and use of the TMiner component-based data mining framework

This paper provides some practical guidelines for the design of data mining frameworks. It describes the rationale behind some of the key design decisions that guided the design, development, and implementation of the TMiner component-based data mining framework. TMiner is a flexible framework that can be used as a stand-alone tool or integrated into larger business intelligence (BI) solutions. TMiner is a general-purpose component-based system designed to support the whole KDD process into a single framework and thus facilitate the implementation of complex data mining scenarios.

A Case Study in Parallel Verification of Component-Based Systems

In large component-based systems, the applicability of formal verification techniques to check interaction correctness among components is becoming challenging due to the concurrency of a large number of components. In our approach, we employ parallel LTL-like model checking to handle the size of the model. We present the results of the actual application of the technique to the verification of a complex model of a real system created within the CoCoME Modelling Contest [Zimmerova, B., P. Vařeková, N. Beneš, I. Černá, L. Brim and J. Sochor, “The Common Component Modeling Example: Comparing Software Component Models, chapter Component-Interaction Automata Approach (CoIn),” To appear in LNCS, 2007]. In this case study, we check the validity of the model and the correctness of the system via checking various temporal properties. We concentrate on the component-specific properties, like local deadlocks of components, and correctness of given use-case scenarios.

Interface Automata with Complex Actions: Limiting Interleaving in Interface Automata

Many formalisms use interleaving to model concurrency. To describe some system behaviours appropriately, we need to limit interleaving. For example, in a component-based system, we might wish to limit interleaving to force the inputs to a method to arrive together in order. InWeb services, the arrival of XML messages consisting of multiple simple parts should not be interleaved with the behaviour of another component. We introduce interface automata with complex actions (IACA), which adds complex actions to de Alfaro and Henzinger's interface automata (IA). A complex action is a sequence of actions that may not be interleaved with actions from other components. The composition operation and refinement relation are more involved in IACA compared to IA, and we must sacrifice associativity of composition. However, we argue that the advantages of having complex actions make it a useful formalism. We provide proofs of various properties of IACA and discuss the use of IACA for modellingWeb services.

Performance evaluation of Fractal component-based systems

Component-based system development is now a well accepted design approach in software engineering. Numerous component models have been proposed, and for most of them, specific software tools allow building component-based systems (CBS). Although these tools perform several checks on the built system, few of them provide formal verification of behavioural properties nor performance evaluation of the resulting system. In this context, we have developed a general method associating to a CBS, a formal model, based on stochastic well formed nets, a class of high-level Petri nets, allowing qualitative behavioural analysis together with performance evaluation of this CBS. The definition of the model heavily depends on the (run time) component model used to describe the CBS. In this paper, we instantiate our method to Fractal CBS and its reference Java implementation Julia. The method starts from the Fractal architectural description of a system and defines rules to systematically generate element models of the CBS and their interactions. We then apply a structured method for both qualitative and performance analysis, taking into account the given implementation of the Fractal model. The main interest of our method is to take advantage of the compositional definition of such systems to carry out an efficient analysis. The paper concentrates on performance evaluation and presents our method step by step with an illustrative example.

A component-based policy-neutral architecture for kernel-level access control

Protection should fundamentally be flexible for devices roaming in Beyond 3G networks. In this federation of heterogeneous access networks, each sub-network comes with its own security requirements, policies, and protocols. Foundational element of device security, the embedded OS itself, should become adaptable to make it possible to tune its protection mechanisms to the current security context, notably to support multiple authorization policies. We show how flexibility can be applied to the kernel authorization architecture by adopting a component-based OS design, the component serving as single abstraction for reconfiguration and security. We present a policy-neutral access control architecture called CRACKER (Component-based Reconfigurable Access Control for KERnels) for component-based operating systems. CRACKER supports a wide range of authorization policies, and permits policy reconfiguration, in the same or in different security models. Specified in the Fractal component model, and implemented in the Think OS, CRACKER illustrates how flexible kernel authorization can be realized while maintaining acceptable system performance.

EMPIRICAL EVALUATION AND VALIDATION OF INTERFACE COMPLEXITY METRICS FOR SOFTWARE COMPONENTS

The major drivers for complex applications are cost, efficiency, development time, understandability, usability and more importantly the maintainability. Due to their black box nature, complexity of software components is more crucial for component-based systems. This paper discusses various complexity concerns for these systems and reviews a number of complexity metrics for software components and component-based systems. As interfaces are the only source of information to know about the black-box components, this paper proposes a new interface complexity metric for these components. This metric is based on the information available in the interfaces like interface methods and properties. It also discusses the methodology to assign the weight values to these methods and properties to finally evaluate the complexity of the component. This paper validates the proposed metric against standard Weyukar's properties and empirically evaluates the metric for several Java Bean components. Finally a correlation analysis between proposed metrics and several other metrics like performance, customizability and readability is done to validate the metric.

Extracting Interactions in Component-Based Systems

Monitoring, analysing and understanding component based enterprise software systems are challenging tasks. These tasks are essential in solving and preventing performance and quality problems. Obtaining component level interactions which show the relationships between different software entities is a necessary prerequisite for such efforts. This paper focuses on component based Java applications, currently widely used by industry. They pose specific challenges while raising interesting opportunities for component level interaction extraction tools. We present a range of representative approaches for dynamically obtaining and using component interactions. For each approach we detail the needs it addresses, and the technical requirements for building an implementation of the approach. We also take a critical look at the different available implementations of the various techniques presented. We give performance and functional considerations and contrast them against each other by outlining their relative advantages and disadvantages. Based on this data, developers and system integrators can better understand the current state-of-the-art and the implications of choosing or implementing different dynamic interaction extraction techniques.

Estimation of quality for software components

Component-Based Development (CBD) approach now is widely accepted in software industry. This approach enables efficient application development through the integration of already developed software components. The success of these applications heavily depends upon the selection of appropriate components to fit customer requirements. Therefore it is very necessary to evaluate the quality of components before using them in the final system. Quality models proposed so far can not be fully implemented as-it-is on components and component-based systems (CBS) due to architectural differences in the development approach. Present paper surveys a number of quality models for traditional and component-based systems and proposes a new model for CBS by proposing some new characteristics, which may be very relevant in the context of components. All the quality characteristics may not be of prime importance for an application to be developed for a specific domain. Therefore, it is necessary to identify only those characteristics/sub-characteristics, which may have higher priorities over the others. The present work uses Analytical Hierarchy Process (AHP) to assign the weight values to the characteristics for the proposed model. These weight values are then used to evaluate the quality contribution of sub-characteristics, characteristics and then finally the overall quality of the component by using the appropriate metrics. This approach can be used to identify and select better quality component among several others which can be used in the final system.

A new formalism for mathematical description and verification of component-based systems

In this paper, we introduce a formal approach for composing software components into a distributed system. We describe the system as a hierarchical composition of some components, which can be distributed on a wide variety of hardware platforms and executed in parallel. We represent each component by a mathematical model and specify the abstract communication protocols of the components using Interface Automata (IAs). To model hierarchical systems, besides the basic components' model, we will present other components, called nodes. A node consists of a set of subnodes interacting under the supervision of a controller. Each subnode, in turn, is a node or discrete event component. By considering a subnode as a node we can make hierarchical nodes/components. The entire system, therefore, forms the root of the hierarchy. A controller, in turn, is a set of subcontrollers/interface automata that specifies interaction protocol of the components inside a node. We have also presented an example demonstrating the model by illustrating nodes, subnodes, controllers, and subcontrollers. To address the state space explosion problem in system verification, we utilize the controller as a contract for independent analysis of the components and their interactions. Therefore, a node will not be analyzed directly; instead, we will analyze the controller.

MODEL CHECKING OF COMPONENT BASED SOFTWARE USING COMPOSITIONAL REDUCTIONS

A component-based computing system consists of two main parts: a set of components and a coordination subsystem. Reo is an exogenous coordination language for compositional construction of the coordination subsystem. Constraint automaton has been defined as the operational semantics of Reo. The main goal of this paper is to prepare a model checking method for verifying linear time temporal properties of component-based systems whose coordinating subsystems are modeled by Reo and components are modeled by labeled transition systems. For this purpose, we introduce modified definitions of constraint automata and their composition operators by which, every constraint automaton can be considered as a labeled transition system and each labeled transition system can be translated into a constraint automaton. We show that failure-based equivalences CFFD and NDFD are congruences with respect to the composition operators of constraint automata. Also we present a method for compositional model checking of component-based systems using these equivalences for reducing the sizes of constraint automata models.

An architectural approach to the correct and automatic assembly of evolving component-based systems

Software components are specified, designed and implemented with the intention to be reused, and they are assembled in various contexts in order to produce a multitude of software systems. However, in the practice of software development, this ideal scenario is often unrealistic. This is mainly due to the lack of an automatic and efficient support to predict properties of the assembly code by only assuming a limited knowledge of the properties of single components. Moreover, to make effective the component-based vision, the assembly code should evolve when things change, i.e., the properties guaranteed by the assembly, before a change occurs, must hold also after the change. Glue code synthesis approaches technically permit one to construct an assembly of components that guarantees specific properties but, practically, they may suffer from the state-space explosion phenomenon. In this paper, we propose a Software Architecture (SA) based approach in which the usage of the system SA and of SA verification techniques allows the system assembler to design architectural components whose interaction is verified with respect to the specified properties. By exploiting this validation, the system assembler can perform code synthesis by only focusing on each single architectural component, hence refining it as an assembly of actual components which respect the architectural component observable behaviour. In this way code synthesis is performed locally on each architectural component, instead of globally on the whole system interactions, hence reducing the state-space explosion phenomenon. The approach can be equally well applied to efficiently manage the whole reconfiguration of the system when one or more components need to be updated, still maintaining the required properties. The specified and verified system SA is used as starting point for the derivation of glue adaptors that are required to apply changes in the composed system. The approach is firstly illustrated over an explanatory example and is then applied and validated over a real-world industrial case study.

RELIABILITY MODEL FOR COMPONENT-BASED SYSTEMS IN COSMIC (A CASE STUDY)

Software component technology has a substantial impact on modern IT evolution. The benefits of this technology, such as reusability, complexity management, time and effort reduction, and increased productivity, have been key drivers of its adoption by industry. One of the main issues in building component-based systems is the reliability of the composed functionality of the assembled components. This paper proposes a reliability assessment model based on the architectural configuration of a component-based system and the reliability of the individual components, which is usage- or testing-independent. The goal of this research is to improve the reliability assessment process for large software component-based systems over time, and to compare alternative component-based system design solutions prior to implementation. The novelty of the proposed reliability assessment model lies in the evaluation of the component reliability from its behavior specifications, and of the system reliability from its topology; the reliability assessment is performed in the context of the implementation-independent ISO/IEC 19761:2003 International Standard on the COSMIC method chosen to provide the component's behavior specifications. In essence, each component of the system is modeled by a discrete time Markov chain behavior based on its behavior specifications with extended-state machines. Then, a probabilistic analysis by means of Markov chains is performed to analyze any uncertainty in the component's behavior. Our hypothesis states that the less uncertainty there is in the component's behavior, the greater the reliability of the component. The system reliability assessment is derived from a typical component-based system architecture with composite reliability structures, which may include the composition of the serial reliability structures, the parallel reliability structures and the p-out-of-n reliability structures. The approach of assessing component-based system reliability in the COSMIC context is illustrated with the railroad crossing case study.

Design and implementation of TinyOS integrated developing environment

TinyOS is an open-source component-based operating system,which is designed for sensor networks nodes that have very limiting resources.TinyOS is implemented in component-developing language nesC.Benefiting from the Component-based Software Engineering(CBSE),TinyOS itself is a library of components,making application-developing work much more simple,but currently lack of mature Integrated Development Environment(IDE).Through analyzing nesC and the process of TinyOS development,this paper designed an IDE for TinyOS development.Results demonstrate the IDE makes the developing work much more efficient.

Synthesis of decentralized and concurrent adaptors for correctly assembling distributed component-based systems

Building a distributed system from third-party components introduces a set of problems, mainly related to compatibility and communication. Our existing approach to solve such problems is to build a centralized adaptor which restricts the system’s behavior to exhibit only deadlock-free and desired interactions. However, in a distributed environment such an approach is not always suitable. In this paper, we show how to automatically generate a distributed adaptor for a set of black-box components. First, by taking into account a specification of the interaction behavior of each component, we synthesize a behavioral model for a centralized glue adaptor. Second, from the synthesized adaptor model and a specification of the desired behavior that must be enforced, we generate one local adaptor for each component. The local adaptors cooperatively behave as the centralized one restricted with respect to the specified desired interactions.

Dependency and interaction oriented complexity metrics of component-based systems

Component-Based Development (CBD) practice is gaining popularity among software developers in the software industry. Researcher community is striving hard to identify the attributes characterizing component-based development and further proposing metrics that may help in controlling the complexity of the component-based systems. The present paper introduces a set of component-based metrics, namely, Component Dependency Metric (CDM) and Component Interaction Density Metric (CIDM), which measure the dependency and coupling aspects of the software components respectively. Graph theoretic notions have been used to illustrate the dependency and interaction among software components for all the four cases chosen for present study. Dependency and interaction-oriented complexity metrics for component-based systems have been computed. The results of the present study are quite encouraging and may further help the researchers in controlling the complexity of component-based systems so as to minimize the integration and maintenance costs.

Component behavior relativity analysis

Component-Based Development, CBD for short, is becoming a main stream software development paradigm which reuses the off-the-shelf components and assembles them together to form a component-based application. CBD paradigm obviously has aroused a great attention among the engineering and academic domain and many new concepts, tools, and development methodologies have been coming out. However, CBD paradigms are usually questioned by its feasibility and performance. The inherent reason of this dilemma is lacking a methodology to guide researchers or engineers to clarify the behavior relativity among components. In this paper we proposed a new formalism, named component network, which is an extension of Petri net and its powerful capability to modeling distributed system is the guarantee of successful modeling component-based system. Further more, a series operation and theorems are presented, which are concerned to be the footstone of component behavior relativity analysis and software evolution research.

Information System of the Minjiang River Estuary Wetland Based on MapObjects

The component-based GIS system has enormous advantages in seamless integration and the flexibility of the system.It stands for the development trend of GIS.Applying the ComGIS based technology,a specific GIS system for monitoring and management of the Minjiang River Estuary wetland based on MapObjects and Visual Basic has been developed in this research.The spatial visualization analysis of the wetlands' dynamic change,in turn,can be implemented.

Integration of Simulink Models with Component-based Software Models

Model based development aims to facilitate the development of embedded control systems by emphasizing the separation of the design level from the implementation level. Model based design involves the use of multiple models that represent different views of a system, having different semantics of abstract system descriptions. Usually, in mechatronics systems, design proceeds by iterating model construction, model analysis, and model transformation. Constructing a MATLAB/Simulink model, a plant and controller behavior is simulated using graphical blocks to represent mathematical and logical constructs and process flow, then software code is generated. A Simulink model is a representation of the design or implementation of a physical system that satisfies a set of requirements. A software component-based system aims to organize system architecture and behaviour as a means of computation, communication and constraints, using computational blocks and aggregates for both discrete and continuous behaviour, different interconnection and execution disciplines for event-based and time-based controllers, and so on, to encompass the demands to more functionality, at even lower prices, and with opposite constraints. COMDES (Component-based Design of Software for Distributed Embedded Systems) is such a component-based system framework developed by the software engineering group of Mads Clausen Institute for Product Innovation (MCI), University of Southern Denmark. Once specified, the software model has to be analyzed. One way of doing that is to integrate in wrapper files the model back into Simulink S-functions, and use its extensive simulation features, thus allowing an early exploration of the possible design choices over multiple disciplines. The paper describes a safe translation of a restricted set of MATLAB/Simulink blocks to COMDES software components, both for continuous and discrete behaviour, and the transformation of the software system into the S-functions. The general aim of this work is the improvement of multidisciplinary development of embedded systems with the focus on the relation between control engineering and software engineering.

Framework for quiescence management in support of reconfigurable multi-threaded component-based systems

In component-based software systems, the basic building block is the component, and applications are built as component compositions. ‘Dynamic reconfiguration’ in such systems is defined as the ability to replace individual components at runtime, or to change the compositional topology by adding/removing components and/or changing the patterns of their interconnection. A ‘quiescence service’ supports dynamic reconfiguration by pushing a system into a stable state in which such changes can be safely made. It is thus a key enabler of dynamic reconfiguration. The authors present the design of a quiescence service, which has been implemented for the OpenCOM component-based programming platform. It is argued that this design shows significant advances over the state of the art in quiescence support for component-based systems. In particular, it minimises programmer overhead and system disruption, and efficiently supports a large class of systems without imposing architectural constraints.

Architecture Design and Prototyping of a Web-based, Synchronous Collaborative 3D GIS

Collaborative GIS has emerged as an efficient, spatial decision-making tool, especially when 3D GIS models are integrated. While centralized architecture is still dominating the design and development of such tools and/or systems, alternative architecture, such as peer-to-peer (P2P), and hybrids have been given increasingly more attention in designing more scalable and efficient systems. This paper presents a conceptual hybrid system architecture for the development of integrated, synchronously collaborative environments with 3D GIS tools for group decision-making and 3D information sharing. In this paper, we discuss the major design issues related to such an architectural design and identify the spatial requirements of synchronous collaborative 3D GIS. A hybrid architectural model integrating centralized and replicated computing architecture is then designed to address the identified requirements. The proposed architecture was tested using data/message flow models developed to facilitate component-based collaborative 3D GIS systems. The results show that collaborative 3D GIS require collaboration computing different from that applied in generic GIS systems, and that a component-based development approach can lead to more light-weight systems.