A new suite of metrics for the integration of software components

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 ...

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.

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.

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.

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.

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.

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.

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.

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.

2009

Software metrics can provide an automated way for software practitioners to assess the quality of their software. The earlier in the software development lifecycle this information is available, the more valuable it is, since changes are much more expensive to make later in the lifecycle. As far as the Component-Based Software Engineering is concerned, the metrics can help estimate, plan and identify areas to improve quality, reduce costs, enhance project management and facilitate risk management. Ultimately the success of the CBSE projects can be ensured from the metrics. In this paper we define seventeen metrics for seven component characters. It includes three functional characters namely the suitability, accuracy and complexity and four non-functional characters namely the usability, maintainability, reusability and performance. The metrics are arrived at, based on a metric model. The metrics are then validated with a case study.