Complexity Metrics for Component-based Software Systems
Abubaker Wahaballa2011, International Journal of Digital Content Technology and its Applications
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 recent years, the software engineering community has put considerable efforts into the design and development of component-based software system (CBSS) in order to manage the software increasing complexity and to maximize the reuse of code. This paper presents some of such efforts by investigating the improved measurement tools and techniques, i.e., through the effective software metrics. Upon the research on the classical evaluation measures for software systems, we argue the traditional metrics are not suitable for CBSS. Therefore we provide an account of novel software measures for component by adequate coupling, cohesion and interface metrics. The complexity metrics combined with three metrics on the CBSS level is also investigated. The advantages of our method are discussed as well through a case study in this paper.
Related papers
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.
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 ...
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.
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.
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.
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.
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...
Metrics-guided quality management for component-based software systems
25th Annual International Computer Software and Applications Conference. COMPSAC 2001, 2001
The growing reliance on Commercial-Off-The-Shelf (COTS) components for developing large-scale projects introduces a new paradigm in software engineering, which requires the design of new software development and business processes. Large scale component reuse leads to savings in development resources, enabling these resources to be applied to areas such as quality improvement. These savings come at the price of integration dificulties, performance constraints, and incompatibility of components from multiple vendors. Relying on COTS Components also increases the system's vulnerability to risks arising from third-parq development, which can negatively affect the quality of the system, us well as causing expenses not incurred in traditional software development. We aim to alleviate such concerns by using software nietrics to accurately quantijj factors contributing to the overall quality of a Component-Based System (CBS), guiding quality and risk nianagement by identifiing and eliminating sources of risk,
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 ...
Structuring Software Reusability Metrics for Component-Based Software Development
2012
Abstract: The idea of reusing software components has been present in software engineering for several decades. Although the software industry developed massively in recent decades, component reuse is still facing numerous challenges and lacking adoption by practitioners. One of the impediments preventing efficient and effective reuse is the difficulty to determine which artifacts are best suited to solve a particular problem in a given context and how easy it will be to reuse them there.
Related topics
Related papers
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.
Evaluating Quality of Software Component using Metrics
2015
The main aim of software engineering community is to provide a high quality system or a product. To achieve this in recent years, many considerable efforts have put by software engineers in to the design and development of Component based software system (CBSS).This Paper presents some such efforts by using measurement tools and technique, i.e. through the effective software metrics. We provide an account of novel software measures for component by adequate coupling, cohesion and interface metrics. The advantages of our technique are discussed as well through a case study in this paper. Introduction Component-based software (CBS) construction has brought a new revolution in software engineering. Component based software engineering is a methodology that emphasizes the design and construction of computer-based systems using reusable component. It’s also developing a kind of software which relies on reuse and it emerged from the failure of object oriented development. Component provid...
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.
A Metrics Suite for Measuring Software Components
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.
A new suite of metrics for the integration of software components
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.
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 ...
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.
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.
A Complete Metrics Based View to Estimate Software Quality in Component based System
Most of the applications in today's IT industry are developed with the help of existing codes, libraries, design, open source etc. As the code is accessed in a program it is represented as the software component. Code is a ready to use component in programming. Developing software with the help of existing component or code is called software reusability. These components can be code, architecture, documents, designs etc. While using these components the main question arises whether to use such components is worth full or not which means reusing these components increases or decreases the quality of the software. In this proposed work i have made an attempt to answer this question. In this work i am presenting a set of software metrics that will check the interconnection between the software components and the application. How strong this relation defines the software quality after using this software component. For this to be happen work i have taken four components having interconnection between them. After applying software metrics on them i will be able to suggest which component will increase the quality of the software produced. The overall metrics will return the final result in terms of the dependencies of the component with application. No doubt many techniques have been developed to estimate the quality of the software but my approach will estimate the quality of software with the help of a concept called Software Reusability. As I earlier said software reuse is the process of developing software systems using existing software assets. Good software reuse always results in the increase of productivity, quality, reliability and the decrease of costs as well as implementation
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.