Component-based Systems Research Articles

A Data Mining Technique to Improve Configuration Prioritization Framework for Component-Based Systems: An Empirical Study

Department of Software Engineering, In the current application development strategies, families of productsare developed with personalized configurations to increase stakeholders’ satisfaction. Product lines have theability to address several requirements due to their reusability and configuration properties. The structuringand prioritizing of configuration requirements facilitate the development processes, whereas it increases theconflicts and inadequacies. This increases human effort, reducing user satisfaction, and failing to accommodatea continuous evolution in configuration requirements. To address these challenges, we propose a framework formanaging the prioritization process considering heterogeneous stakeholders priority semantically. Featuresare analyzed, and mined configuration priority using the data mining method based on frequently accessed andchanged configurations. Firstly, priority is identified based on heterogeneous stakeholder’s perspectives usingthree factors functional, experiential, and expressive values. Secondly, the mined configuration is based on frequentlyaccessed or changed configuration frequency to identify the new priority for reducing failures or errorsamong configuration interaction. We evaluated the performance of the proposed framework with the help ofan experimental study and by comparing it with analytical hierarchical prioritization (AHP) and Clustering.The results indicate a significant increase (more than 90 percent) in the precision and the recall value of theproposed framework, for all selected cases.

Optimal components selection based on fuzzy-intra coupling density for component-based software systems under build-or-buy scheme

Component-Based Software Engineering (CBSE) is an approach to building and developing software systems based on software components. In component-based software systems, there are various software components, including Commercial off the Shelf (COTS) and in-house components. Software developers can build their desired software component as in-house or COTS. The problem of deciding optimally between COTS and in-house components is one of the major challenges of software developers, which is known as the component selection problem. This can be resolved by evaluating the criteria for optimality in component selection and then solving the component selection problem by optimization techniques. In this paper, an attempt was made to optimize the component selection problem through the multi-objective optimization by maximizing the Fuzzy-Intra Coupling Density (Fuzzy-ICD) and functionality as objective functions, and also taking into account budget, delivery time, reliability, and Fuzzy-ICD as constraints of multi-objective problems. Fuzzy ICD is a more accurate criterion to calculate the relationship between Cohesion and Coupling of components, which is obtained through the fuzzy computing of each of them, based on the Meyers classification. Thus, after a two-criterion optimization model formulation, this optimization problem was solved by fuzzy multi objectives approach. Finally, the proposed method was evaluated by performing the case study of financial-accounting system. Comparison of the results showed that the proposed method could select optimal components with maximum functionality and Fuzzy-ICD and fewer rates of time and Budget (0.29, 0.43, 1.1 s, and 88$ were the improved rates of functionality, Fuzzy-ICD, time, and budget, respectively).

An automated system analysis and design tool for spacecrafts

In this paper, a generic full-system estimation software tool is introduced and applied to a data set of actual flight missions to derive a heuristic for system composition for mass and power ratios of considered sub-systems. The capability of evolutionary algorithms to analyse and effectively design spacecraft (sub-)systems is shown. After deriving top-level estimates for each spacecraft sub-system based on heuristic heritage data, a detailed component-based system analysis follows. Various degrees of freedom exist for a hardware-based sub-system design; these are to be resolved via an evolutionary algorithm to determine an optimal system configuration. A propulsion system implementation for a small satellite test case will serve as a reference example of the implemented algorithm application. The propulsion system includes thruster, power processing unit, tank, propellant and general power supply system masses and power consumptions. Relevant performance parameters such as desired thrust, effective exhaust velocity, utilised propellant, and the propulsion type are considered as degrees of freedom. An evolutionary algorithm is applied to the propulsion system scaling model to demonstrate that such evolutionary algorithms are capable of bypassing complex multidimensional design optimisation problems. An evolutionary algorithm is an algorithm that uses a heuristic to change input parameters and a defined selection criterion (e.g., mass fraction of the system) on an optimisation function to refine solutions successively. With sufficient generations and, thereby, iterations of design points, local optima are determined. Using mitigation methods and a sufficient number of seed points, a global optimal system configurations can be found.

Using Architectural Runtime Verification for Offline Data Analysis

Analyzing runtime behavior as part of debugging complex component-based systems used in the vehicle industry is an important aspect of the integration process. It is a laborious task that involves many manual steps. One reason for this is that, as of today, the analysis is usually not performed on the architecture level, where the system has initially been designed. Instead, it relies on source code debugging or visualizing signals and events. With an ever-growing complexity of such systems, it becomes increasingly difficult to find errors that manifest at integration level, i.e., when the components interact with each other in a complex environment. Architectural Runtime Verification (ARV) is an approach specifically designed for the integrator—a generic way to analyze system behavior on architecture level using the principles of Runtime Verification. This paper draws on our initial publication. It provides further details and an evaluation of the ideas using a database hosted in the cloud.

Formal Verification Issues For Component-Based Development

Component-based development has made a breakthrough in software industry, it offers safer systems and easier to maintain, furthermore, costs and time to market are reduced. However, several issues, such as the correctness of component-based systems, their adaptation or the interactions between their components, require rigorous verification through the use of formal methods and tools. In this paper, we first present an introduction to component-based development; afterward we propose a classification of formal verification issues for component-based systems.

Checking deadlock-freedom of parametric component-based systems

We propose an automated method for computing inductive invariants used to proving deadlock freedom of parametric component-based systems. The method generalizes the approach for computing structural trap invariants from bounded to parametric systems with general architectures. It symbolically extracts trap invariants from interaction formulae defining the system architecture. The paper presents the theoretical foundations of the method and proves its soundness. It also reports on a preliminary experimental evaluation on several textbook examples.

Mission-based reliability prediction in component-based systems

This paper develops a framework for the extraction of a reliability block diagram in component-based systems for reliability prediction with respect to specific missions. A mission is defined as a composition of several high-level functions occurring at different stages and for a specific time during the mission. The high-level functions are decomposed into lower-level functions, which are then mapped to their corresponding components or component assemblies. The reliability block diagram is obtained using functional decomposition and function-component association. Using the reliability block diagram and the reliability information on the components such as failure rates, the reliability of the system carrying out a mission can be estimated. The reliability block diagram is evaluated by converting it into a logic (Boolean) expression. A modeling language created using the Generic Modeling Environment (GME) platform is used, which enables modeling of a system and captures the functional decomposition and function-component association in the system. This framework also allows for real-time monitoring of the system performance where the reliability of the mission can be computed over time as the mission progresses. The uncertainties in the failure rates and operational time of each high-level function are also considered which are quantified through probability distributions using the Bayesian framework. The dependence between failures of components are also considered and are quantified through a Bayesian network (BN). Other quantities of interest such as mission feasibility and function availability can also be assessed using this framework. Mission feasibility analysis determines if the mission can be accomplished given the current state of components in the system, and function availability provides information whether the function will be available in the future given the current state of the system. The proposed methodology is demonstrated using a radio-controlled (RC) car to carry out a simple surveillance mission.

Assessing the changeability of component-based system design: a controlled experiment

ABSTRACT Component-based software system (CBSS) must be designed and implemented not only to meet the current customers’ requirements, but also to be receptive to future changes. Therefore, most often, one or more components of the system may need to be changed. Usually, designers do not exactly know what the future state looks like. The need for change continues to increase as technology evolves. For the reusable software components, this modification may be compromised, perhaps for the system architecture that comprises components or interfaces that are difficult to change. An essential way for controlling and managing such changes is to develop metrics as an indicator of changeability. The aim of this paper is to present the relationship between the proposed component information flow-based measures and changeability of software components. Although the component information flow complexity (CIFC) and component coupling (CC) could make a significant contribution to the understanding of software design processes, they need to be adjusted to an external quality attributed to determine the usefulness of the metrics. A controlled change experiment was conducted involving eighteen software components and twelve changes for verifying certain hypotheses to justify the validity of the measured external attribute. The empirical findings showed that there was a significant statistical correlation between the proposed information-flow-based metrics and changeability of software components. CBSS designers can achieve some quality insight in terms of changeability if the metrics are applied in the right context.

A type language for message passing component-based systems

Component-based development is challenging in a distributed setting, for starters considering programming a task may involve the assembly of loosely-coupled remote components. In order for the task to be fulfilled, the supporting interaction among components should follow a well-defined protocol. In this paper we address a model for message passing component-based systems where components are assembled together with the protocol itself. Components can therefore be independent from the protocol, and reactive to messages in a flexible way. Our contribution is at the level of the type language that allows to capture component behaviour so as to check its compatibility with a protocol. We show the correspondence of component and type behaviours, which entails a progress property for components.

An effective component-based age-invariant face recognition using Discriminant Correlation Analysis

Face is an important characteristic for biometric identification and verification systems, as it holds the needed information about individual’s identity. However, it is the characteristic most impacted by aging process, and facial aging is the main effect which decreases significantly the performance of face recognition algorithms. The main idea of this study relies on the fact that aging affects facial components such as mouth, eyes and nose differently. Therefore, we suggest to consider face as an independent component set, and each facial component (eyes, mouth, and nose) will be processed separately, and we propose an effective component-based method for age-invariant face recognition using a Discriminant Correlation Analysis(DCA) as a feature-level fusion algorithm to combine Deep-based features computed from separated facial components, and a Support Vector Machine (SVM) as a classifier. To evaluate the proposed approach, a comprehensive experimental study is performed on a widely used face-aging database, namely FG-NET, also the proposed method has been compared with a Particle Swarm Optimization (PSO)-based score-level fusion method. Experimental results show that the proposed component-based system worked effectively for face recognition across age progression, as it achieves significant high mean accuracy rates.

PUTRACOM: A Formalism of a Novel Component Model

The composition mechanisms and interactions of current component models are mostly base on port or function calls from other components. However, in both styles, the number of interactions that depend on the number of ports and method calls may increase dramatically. Hence, to avoid such complexity of composing components and coordination of the interaction among them, a component model and policy to provide a separation between the components and coordinating is needed. This study presents a formal specification of a novel component model for discrete-event and non-blocking component-based systems called PUTRACOM. A new component model, named PUTRACOM is presented in this paper. PUTRACOM supports to develop concurrent software systems with discrete-event. PUTRACOM defines components by two essential features; they are the Observer/Observable unit and a computation unit. These two features allow a component to have fixed behavior without any dependency on other components. The components can be composed using a well-defined set of connectors. PUTRACOM has been formally defined based on the well-defined and sound methods like CSP and RTSs. PUTRACOM provides a way to construct components and coordinate them with a well-founded mechanism. The model defines a set of exogenous connectors and an observer/observable unit to encapsulate components and coordination. In order to illustrate the way of component composition in the proposed model, an example of the control system of a refrigerator is used. Moreover, to evaluate its applicability, the example has been implemented in Colored Petri Net (CPN) tools.

Event-B formalization of a variability-aware component model patterns framework

Abstract In the domain of model-driven engineering, patterns have emerged as a ubiquitous structuring mechanism. Patterns are used for instance at the requirement analysis level, during system design, and during the deployment and code generation phases. We focus on formalizing the operational semantics of pattern application on component-based system designs. More precisely, our ultimate goal is to provide a semantic framework to support the use of patterns for the production of correct-by-construction architectures, i.e., the structural (static) correctness of the architectures obtained through the formal application of patterns. To that end, we propose an Event-B framework for patterns specification, instantiation and application. This model is built incrementally through horizontal refinements which introduce components, ports, and connectors. Patterns with variability are defined, instantiated and can be applied to user models. We show that these operations preserve the structural properties of hierarchical component models.

Causality analysis and fault ascription in component-based systems

This article introduces a general framework for fault ascription, which consists in identifying, within a multi-component system, the components whose faulty behavior has caused the failure of said system. Our framework uses configuration structures as a general semantical model to handle truly concurrent executions, partial and distributed observations in a uniform way. As a first contribution, and in contrast with most of the current literature on counterfactual analysis which relies heavily on a set of toy examples, we first define a set of expected formal properties for counterfactual builders, i.e. operators that build counterfactual executions. We then show that causality analyses that satisfy our requirements meet a set of elementary soundness and completeness properties. Finally we present a concrete causality analysis meeting all our requirements, and we show that it behaves well under refinement. We present several examples illustrating various phenomena such as causal over-determination or observational determinism, and we discuss the relationship of our approach with Halpern and Pearl's actual causality analysis.

Component-based system reliability subject to positive and negative correlation

Traditional system reliability modeling methods assume statistical independence of component failures, while past research emphasizes methods to characterize positive correlation and dependence. However, negative dependence and correlation are also important for system reliability and resilience modeling. This paper develops a method to assess the reliability of a system subject to arbitrary combinations of positive and negative correlation between the failures of its components. The method enables derivation of expressions composed of a vector of unequal component reliabilities and unequal pairwise component correlations. The method is illustrated through a sequence of examples, which conduct sensitivity analysis on correlation parameters of the model as well as quantify the impact of component correlations on system reliability. Coverage experiments formally assess the flexibility and scalability of the approach.

Development of a novel component-based open CNC software system

Component-based software development (CBSD) is widely utilized to develop open CNC applications. It aims to build an open CNC application by composing a set of components, each implementing specific CNC sub-domain logic. Components conform to a certain component model to keep conformant interactive behaviors. Due to there is no standard granularity to decompose CNC domain and no general component model, as well as seldom consider extra-functional properties, components are heterogeneous. Moreover, they have a direct dependency rather than depending on abstractions. In a nutshell, there are many open-source CNC applications built by heterogeneous and tightly coupled components. They can implement CNC functionality but are good at functional extension and reconfiguration. In this paper, we apply CBSD and dependency inversion principle to develop a novel open CNC application which allows customizing CNC functionality. Specifically, a new granularity to decompose CNC domain is proposed. A special sub-domain is designed to encapsulate the execution logic of other sub-domains at an abstract level and instantiate concrete implementation details at runtime according to configuration. The functional properties of sub-domains are exposed via abstractions. Therefore, as long as re-writing the execution logic and configuring corresponding implementation details, CNC functionality can be extended or reconfigured. A prototype and several components have been developed to test the performance of the application.

DUST Initializr — Graph-based platform for designing modules and applications in the revised DUST framework

The DUST framework is a middleware platform developed to create software components that are distributable across heterogeneous networks. The development and maintenance of a component-based system can become a challenge. In this paper, we present a web-based tool that allows engineers to visually draw a graph to model an application in DUST. This graph is used by the back-end template generators to create code templates and associated configuration files in order to focus on the business logic. The latest version of the tool is compatible with the revised DUST version. It generates fully functional message objects and builder classes for transparent communication over DUST channels. Engineers are now able to manage and update DUST application through a GUI interface instead of error-prone coding and debugging.

Locating Arrays with Mixed Alphabet Sizes

Locating arrays (LAs) can be used to detect and identify interaction faults among factors in a component-based system. The optimality and constructions of LAs with a single fault have been investigated extensively under the assumption that all the factors have the same values. However, in real life, different factors in a system have different numbers of possible values. Thus, it is necessary for LAs to satisfy such requirements. We herein establish a general lower bound on the size of mixed-level ( 1 ¯ , t ) -locating arrays. Some methods for constructing LAs including direct and recursive constructions are provided. In particular, constructions that produce optimal LAs satisfying the lower bound are described. Additionally, some series of optimal LAs satisfying the lower bound are presented.

Consecutive Detecting Arrays for Interaction Faults

The concept of detecting arrays was developed to locate and detect interaction faults arising between the factors in a component-based system during software testing. In this paper, we propose a family of consecutive detecting arrays (CDAs) in which the interactions between factors are considered to be ordered. CDAs can be used to generate test suites for locating and detecting interaction faults between neighboring factors. We establish a general criterion for measuring the optimality of CDAs in terms of their size. Based on this optimality criterion, the equivalence between optimum CDAs and consecutive orthogonal arrays with prescribed properties is explored. Using the advantages of this equivalence, a great number of optimum CDAs are presented. In particular, the existence of optimum CDAs with few factors is completely determined.

A refinement checking based strategy for component-based systems evolution

We propose inheritance and refinement relations for a CSP-based component model (BRIC), which supports a constructive design based on composition rules that preserve classical concurrency properties such as deadlock freedom. The proposed relations allow extension of functionality, whilst preserving behavioural properties. A notion of extensibility is defined on top of a behavioural relation called convergence, which distinguishes inputs from outputs and the context where they are communicated, allowing extensions to reuse existing events with different purposes. We mechanise the strategy for extensibility verification using the FDR4 tool, and illustrate our results with an autonomous healthcare robot case study.

Observation-Enhanced QoS Analysis of Component-Based Systems

We present a new method for the accurate analysis of the quality-of-service (QoS) properties of component-based systems. Our method takes as input a QoS property of interest and a high-level continuous-time Markov chain (CTMC) model of the analysed system, and refines this CTMC based on observations of the execution times of the system components. The refined CTMC can then be analysed with existing probabilistic model checkers to accurately predict the value of the QoS property. The paper describes the theoretical foundation underlying this model refinement, the tool we developed to automate it, and two case studies that apply our QoS analysis method to a service-based system implemented using public web services and to an IT support system at a large university, respectively. Our experiments show that traditional CTMC-based QoS analysis can produce highly inaccurate results and may lead to invalid engineering and business decisions. In contrast, our new method reduced QoS analysis errors by 84.4–89.6 percent for the service-based system and by 94.7–97 percent for the IT support system, significantly lowering the risk of such invalid decisions.