A new suite of metrics for the integration of software components
Bayu Hendradjaya
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
In this paper we propose two sets of metrics to measure complexity and criticality of large software systems designed and integrated using the principles of Component Based Software Engineering (CBSE). From the Component Interface Definition Language (CIDL) specification [32], we derive two suites of complexity metrics, namely, Component Packing Density (CPD) metrics and Component Interaction Density (CID). The CPD metric relates component co nstituents to the number of integrated components. The CID metric suite relates interactions between components to the number of available interactions in the entire system. We also define a set of criticality criteria for component integration. Our proposed experimental design and the expected results are also outlined in this paper.
Related papers
Complexity metrics for component-oriented software systems
ACM SIGSOFT Software Engineering Notes, 2008
Component-based software development (CBSD) has become one of the preferred streams for developing large and complex systems by integrating prefabricated software components that not only facilitates the process of software development but is also changing the ways for software professionals to develop software applications. Till today, numerous attempts have been made by several organizations, software development teams, developers as well as researchers to improve component-oriented software systems (COSS) through improved measurement tools and techniques i.e. through an effective metrics. Our paper is a simple attempt to work for the demand of an appropriate and relevant integration metrics for the measurement of complexity of a software component that could be used as one of the approaches for further guidance in component complexity measurement and problem reduction. We represented a component metrics as an instantiation of the integration complexity measurement which can then ...
Complexity Metrics for Component-based Software Systems: Developer Perspective
Background: A Component-Based Development (CBD) is an integration centric system focusing on assembling individual components in order to build a software system. Most of the existing CBD metrics rely on parameters that are too difficult to measure in practice due to the component's internal elements may not be visible to developers or testers. Objective: We proposed two suite of metrics to measure the structural complexity and interaction complexity of Component-Based Software System (CBSS) from perspective of component developer. Methods: Based on the analysis of the component specification, the elements of interface which includes properties, methods and events are measured. The proposed metrics quality is evaluated from a mathematical perspective using BMB properties. Finding: The theoretical evaluation results indicated that the proposed metrics are valid internal measures. The proposed metrics are useful in understanding and identifying the areas in the design where improvements are likely to have a high attention. Thus, the proposed metrics appear promising as a means of capturing the quality of the CBSS design in question. Application/Improvements: It has been widely reported that lower complexity is believed to provide advantages such as lower maintenance time, easier to test, highly reusable and easier to understand.
Few important considerations for deriving interface complexity metric for component-based systems
ACM Sigsoft Software Engineering Notes, 2004
Component-based software engineering (CBSE) represents an exciting and promising paradigm for software development. Software components are one of the key issues in CBSE. The software development community is continuously seeking new methods for improving software quality and enhancing development productivity. There is an increasing need for component-based metrics to help manage and foster quality in component-based software development. The traditional software product and process metrics are neither suitable nor sufficient in measuring the complexity of software components, which ultimately is necessary for quality and productivity improvement within organisations adopting CBSE. In this paper, we propose an interface complexity metric (ICM) aimed at measuring the complexity of a software component based on the interface characterisation model of a software component that mainly include such as interface signature, interface constraints, interface packaging and configurations. Based on the value of this metric, the complexity of the software component could be managed within reasonable complexity limits. In this way, the software components could be kept simple which in turn help in enhancing the quality and productivity.
Some theoretical considerations for a suite of metrics for the integration of software components
Information Sciences, 2007
We have defined two suites of metrics, which cover static and dynamic aspects of component assembly. The static metrics measure complexity and criticality of component assembly, wherein complexity is measured using Component Packing Density and Component Interaction Density metrics. Further, four criticality conditions namely, Link, Bridge, Inheritance and Size criticalities have been identified and quantified. The complexity and criticality metrics are combined to form a Triangular Metric, which can be used to classify the type and nature of applications. Dynamic metrics are collected during the runtime of a complete application. Dynamic metrics are useful to identify super-component and to evaluate the degree of utilisation of various components. In this paper both static and dynamic metrics are evaluated using Weyuker's set of properties. The result shows that the metrics provide a valid means to measure issues in component assembly. We relate our metrics suite with McCall's Quality Model and illustrate their impact on product quality and to the management of component-based product development.
Dependency and interaction oriented complexity metrics of component-based systems
ACM Sigsoft Software Engineering Notes, 2008
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.
Multidimentional size measure for design of component-based software system
The motivation of this study is to bridge the gap between component providers and component users, especially in the area of component evaluation, using component information flow (CIF) measurement and multidimensional approaches for measurement interpretation. By measuring the design of component-based software systems (CBSS), software designers, testers and maintainers may be able to locate weaknesses in the system design and to estimate the effort required to test as well as the cost of maintenance. This study proposes a CIF based on inter-component flow and intra-component flow. Moreover, a set of metrics based on the CIF was developed to characterise and evaluate the effect of the component design size on the quality of CBSS design. The theoretical evaluation results indicated that the proposed metrics are valid size measures. An application that demonstrates the intuitiveness of the mentioned approach is also presented. Results show that multidimensional analysis of design size appears promising as a means of capturing the quality of the CBSS design in question.
Metrics for component-based system development
2007
Component-based development (CBD) advocates the acquisition, adaptation, and integration of reusable software components to rapidly develop and deploy complex software systems with minimum engineering effort and resource cost. The work of integrating the components with each other and with the rest of the system is the most important part of the component-based development process.
Component-Based Software Engineering
Traditional software estimation models are directed towards large monolithic software development projects. Contemporary software development practices require a new approach to software cost estimation. Contemporary development practices characterize a software application as interacting, independent components. Component-based development offers many potential benefits such as a greater reuse. Component based software development approach is based on the idea to develop software systems by selecting appropriate off-the shelf components and then to assemble them with a welldefined software architecture. Software community faces a major challenge that is raised by fast growing demand for rapid and cost-effective development and maintenance of large scale and complex software systems. To overcome the challenge, the new trend is to adopt component based software engineering (CBSE).The key difference between CBSE and traditional software engineering is that CBSE views a software system as a set of off-the-shelf components integrated within appropriate software architecture. CBSE promotes large-scale reuse, as it focuses on building software on building software systems by assembling off-the-shelf components rather than implementing the entire system from scratch. CBSE also emphasis on selection and creation of software architecture that allow systems to achieve their quality requirements .As a result, CBSE has introduced fundamental changes in software development and maintenance.
A mapping study to investigate component-based software system metrics
A component-based software system (CBSS) is a software system that is developed by integrating components that have been deployed independently. In the last few years, many researchers have proposed metrics to evaluate CBSS attributes. However, the practical use of these metrics can be difficult. For example, some of the metrics have concepts that either overlap or are not well defined, which could hinder their implementation. The aim of this study is to understand, classify and analyze existing research in component-based metrics, focusing on approaches and elements that are used to evaluate the quality of CBSS and its components from a component consumer's point of view. This paper presents a systematic mapping study of several metrics that were proposed to measure the quality of CBSS and its components. We found 17 proposals that could be applied to evaluate CBSSs, while 14 proposals could be applied to evaluate individual components in isolation. Various elements of the software components that were measured are reviewed and discussed. Only a few of the proposed metrics are soundly defined. The quality assessment of the primary studies detected many limitations and suggested guidelines for possibilities for improving and increasing the acceptance of metrics. However, it remains a challenge to characterize and evaluate a CBSS and its components quantitatively. For this reason, much effort must be made to achieve a better evaluation approach in the future.
Related papers
Empirical Evaluation of Complexity Metrics for Component Based Systems
2015
Reuse-based software engineering is gaining currency as an approach for constructing software applications that are based on existing software components. Factors that have contributed to increased reliance on software components include increased dependability, reduced process risk, standards compliance and reduced time to market. Software components are usually delivered and handled as “black boxes,” which tremendously increases risks associated component integration, system testing and deployment. Due to these risks, metrics for evaluating the quality of component-based systems must be developed and validated. In this work, we analyze the Interface Complexity Metric for JavaBeans components and propose an enhanced metric. We also perform validation of the proposed metric and make recommendations for future research work.
Analysis and Estimation of Interaction and Reusability Complexities of Components in Component-Based Software Engineering
International Journal of Recent Technology and Engineering (IJRTE), 2020
Reuse is the elementary and essential attribute of the component-based software engineering. Reusability focuses on building huge and complex software through assembling pre-fabricated software constructs. In this paper, our emphasis is on to analyze and quantify the two core notions of component-based software, that is, reusability and interaction behavior of the components with the goal of minimum complexity generation. We analyse prominent works available in the literature in the area of reuse and interaction complexities. We Analyze and Estimate reusability complexities of components in Component-Based Software Engineering and we propose efficient and useful metrics to compute the reusability of components. Reusability metrics are defined for individual components as well as overall system level. Different types of components are defined on the basis of their reusability, that is, components that can be reused as it as, and tailored components. To define the metrics we have used...
Predicting Quantitative Functional Dependency Metric based upon the Interface Complexity Metric in Component based Software Systems: A New Approach
International Journal of Computer Applications, 2013
One of the major issues in component based software systems structuring and quality prediction is the interdependencies of system components. This paper proposes a novel technique for determining the strength of functional coupling in component based software systems. Authors propose Strength of Functional Dependency (SFD) metric, which is based upon two new metrics Operational Coupling complexity Index (OCI), and Instance Coupling complexity Index (ICI). It allows us to quantify the functional dependencies, formed by different kinds of operations and instances between these components. Compared to other existing dependency metrics, which are often based on number of operations or instance variables between the components only, authors consider operational complexity and instance variables complexity as a measure to how strong this dependency is and therefore promote a more systematic approach to the reasoning about modularity in component based software systems. This paper can be divided broadly into two parts. The first part quantifies interface operations and instance variables. The quantification is performed by considering the number of input, output parameters and their types. Based upon these factors of operations and instance variables, authors used analytical hierarchy approach (AHP) to assign weights to these factors and outcomes OCI, ICI and SFD. The second part shows the experimentation and validation of the proposed metrics. The advantages of the proposed method are discussed as well through a case study in this paper.
Empirical Evaluation and Validation of Interface Complexity Metrics for Software Components
International Journal of Software Engineering and Knowledge Engineering, 2008
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 component...
Measuring complexity of component based architecture
ACM SIGSOFT Software Engineering Notes, 2011
Component based software development (CBSD) is an evolving paradigm where emphasis is laid on reuse of existing components and effective designing of components. As complexity of software systems increases, the challenge of CBSD lies in designing highly cohesive, testable components. Researcher community is striving hard to identify the attributes characterizing component-based development and proposing metrics that may help in controlling the complexity of the component-based systems. This paper proposes a metric-based approach for the determination of complexity along with a set of architectural aspects of componentbased architectures. The Component Architecture Complexity Measurement Metrics (CACMM) has been proposed based on Component Architecture Graph (CAG), a graphical model used for representing UML component diagram. Analysis of the graph is done to measure complexity at different levels -- individual component level, component-to-component level and the complexity for the ...
Criticality-Driven Component Integration in Complex Software Systems
Lecture Notes in Computer Science, 2011
Complex software systems are commonly developed by integrating multiple, occasionally Off-The-Shelf (OTS), components. This process results into a more modular design and reduces development costs; however, it raises new dependability challenges in case of safety critical systems. Testing activities conducted during the development of the individual components might be not enough to ensure a proper safety level after the integration. The failures of the components and their impact on the overall system safety have to be assessed in critical scenarios. This paper proposes a method to support component integration in complex software systems. The method uses (i) the knowledge of the architectural dependencies among the system components, and (ii) the results of failure-modes emulation experiments, to assess both error propagation phenomena within the system and the criticality of the components in the system architecture. This information is valuable to design effective error-mitigation means and, when needed, to select the most suitable OTS item if multiple equivalent options are available. The method is applied to a real world Air Traffic Control system, developed in the context of an academic-industrial collaboration.
Evaluation of a Suite of Metrics for Component Based Software Engineering (CBSE)
Issues in Informing Science and Information Technology
Component-Based Software Engineering (CBSE) has shown significant prospects in rapid production of large software systems with enhanced quality, and emphasis on decomposition of the engineered systems into functional or logical components with well-defined interfaces used for communication across the components. In this paper, a series of metrics proposed by various researchers have been analyzed, evaluated and benchmarked using several large-scale publicly available software systems. A systematic analysis of the values for various metrics has been carried out and several key inferences have been drawn from them. A number of useful conclusions have been drawn from various metrics evaluations, which include inferences on complexity, reusability, testability, modularity and stability of the underlying components. The inferences are argued to be beneficial for CBSE-based software development, integration and maintenance.
Theoretical considerations for software component metrics
… on Engineering, Computing and Technology V
AbstractWe have defined two suites of metrics, which cover static and dynamic aspects of component assembly. The static metrics measure complexity and criticality of component assembly, wherein complexity is measured using Component Packing Density and Component Interaction ...
Empirical Evaluation and Critical Review of Complexity Metrics for Software Components
2007
Component-based development has become a highly widespread approach for application development. Various metrics have been developed by researchers for improving the quality of software components as traditional software products and process metrics are neither suitable nor sufficient in measuring the complexity of these components. The paper proposes a complexity metric for components based on the different constituents of the components, like inheritance of classes, methods and attributes. This metric is applied to various JavaBean components for empirical evaluation. Further, a correlation study has been conducted for this metric with another metric called Rate of Component Customizability (RCC), available in the literature. The study conducted shows the negative correlation between the two which confirms the assumption that high complexity of the components leads to the high cost of maintainability.
Component-based Software System Dependency Metrics based on Component Information Flow Measurements
The motivation of this paper is that the measurement based on the flow of information connecting software components can be used to evaluate component-based software system dependency. The ability to measure system dependency implies the capability to locate weakness in the system design and to determine the level of software quality. In this paper, dependency between components is considered as a major factor affecting the structural design of Component-based software System (CBSS). Two sets of metrics namely, Component Information Flow Metrics and Component Coupling Metrics are proposed based on the concept of Component Information Flow from CBSS designer's point of view. We also discuss the motivation for and possible uses of system level metrics and component level metrics. Initial results from our ongoing empirical evaluation indicate that the proposed metrics are very intuitive.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.