A Complexity Metrics Set for Large-Scale Object-Oriented Software Systems

2006 ◽  
Author(s):  
Yutao Ma ◽  
Keqing He ◽  
Dehui Du ◽  
Jing Liu ◽  
Yulan Yan
Keyword(s):  
Large Scale ◽  
Object Oriented ◽  
Software Systems ◽  
Complexity Metrics

A Hybrid Set of Complexity Metrics for Large-Scale Object-Oriented Software Systems

2010 ◽  
Vol 25 (6) ◽  
pp. 1184-1201 ◽  
Author(s):  
Yu-Tao Ma ◽  
Ke-Qing He ◽  
Bing Li ◽  
Jing Liu ◽  
Xiao-Yan Zhou
Keyword(s):  
Large Scale ◽  
Object Oriented ◽  
Software Systems ◽  
Complexity Metrics

scholarly journals A new technique for understanding large-scale software systems

2020 ◽  
Vol 12 (1) ◽  
pp. 34-39
Author(s):  
Thamer Al-Rousan ◽  
Hasan Abualese
Keyword(s):  
Case Studies ◽  
Large Scale ◽  
Object Oriented ◽  
Software Systems ◽  
Specific Class ◽  
Dynamic Coupling ◽  
Novel Technique ◽  
Execution Trace ◽  
Class Dynamic ◽  
A New Technique

Comprehending a huge execution trace is not a straightforward task due to the size of data to be processed. Detecting and removing utilities are useful to facilitate the understanding of software and decrease the complexity and size of the execution trace. The goal of this study is to develop a novel technique to minimize the complexity and the size of traces by detecting and removing utilities from the execution trace of object-oriented software. Two novel utility detection class metrics were suggested to decide the degree that a specific class can be counted as a utility class. Dynamic coupling analysis forms the basis for the proposed technique to address object-oriented features. The technique presented in this study has been tested by two case studies to evaluate the effectiveness of the proposed technique. The results from the case studies show the usefulness and effectiveness of our technique.

How Complex is the Unified Modeling Language?

2002 ◽  
pp. 294-306 ◽  
Author(s):  
Keng Siau ◽  
Qing Cao
Keyword(s):  
Unified Modeling Language ◽  
Object Oriented ◽  
Quantitative Measure ◽  
Software Systems ◽  
Modeling Language ◽  
Unified Modeling ◽  
Complexity Metrics ◽  
Modeling Methods

Unified Modeling Language (UML) has emerged as the software industry’s dominant modeling language. It is the de facto modeling language standard for specifying, visualizing, constructing, and documenting the components of software systems. Despite its prominence and status as the standard modeling language, UML has its critics. Opponents argue that it is complex and difficult to learn. Some question the rationale of having nine diagramming techniques in UML and the raison d’être of those nine techniques in UML. Others point out that UML lacks a comprehensive methodology to guide its users, which makes the language even more convoluted. A few studies on UML can be found in the literature. However, no study exists to provide a quantitative measure of UML complexity or to compare UML with other object-oriented techniques. In this research, we evaluate the complexity of UML using complexity metrics. The objective is to provide a reliable and accurate quantitative measure of UML complexity. A comparison of the complexity metrical values of UML with other object-oriented techniques was also carried out. Our findings suggest that each diagram in UML is not distinctly more complex than techniques in other modeling methods. But as a whole, UML is very complex–2-11 times more complex than other modeling methods.

Research on the Potential Characteristics of Object Oriented Software by the Core Structure

2013 ◽  
Vol 278-280 ◽  
pp. 2029-2032
Author(s):  
Hao Hua Zhang ◽  
Yu Ren Zhai ◽  
Wen Jiang Feng ◽  
Hai Shen
Keyword(s):  
Complex Networks ◽  
Open Source Software ◽  
Degree Distribution ◽  
Large Scale ◽  
Object Oriented ◽  
Core Structure ◽  
Software Systems ◽  
The Core ◽  
Result Show ◽  
Structure Decomposition

The networks of interdependencies in large-scale Object Oriented software systems are complex, visualization and understand become the important issues for developer. We propose that topology structure can be imaged to network and better understood via core structure decomposition based on complex networks. The core structure analysis allows characterizing networks beyond the degree distribution and uncovering some potential characteristics, Such as structural hierarchies, centrality and evolution. We analyze the core structure of some popular open source software and discuss the differences and similarities, get some noticeable properties, the result show the method provides an interesting view helping to comprehend and evaluate system in development.

SOFTWARE COMPONENTS FOR OBJECT-ORIENTED DATABASE SYSTEMS

1993 ◽  
Vol 03 (02) ◽  
pp. 165-192 ◽  
Author(s):  
DON BATORY ◽  
DEVANG VASAVADA
Keyword(s):  
Large Scale ◽  
Object Oriented ◽  
Database Systems ◽  
Software Systems ◽  
Software Components ◽  
Component Reuse ◽  
System Generator ◽  
Self Tuning ◽  
Relational Database Systems ◽  
Object Oriented Database

Genesis is a software system generator for database management systems that relies exclusively on as-is large scale component reuse. We review the general model of software components on which Genesis is based and discuss component libraries for relational database systems that we have implemented. We then explain how we have evolved Genesis and its libraries to be able to synthesize object-oriented database systems. We study a subproblem of creating “self-tuning” software systems by examining the performance of selected components for object-oriented database systems.

The Static Structural Complexity Metrics for Large-Scale Software System

2010 ◽  
Vol 44-47 ◽  
pp. 3548-3552 ◽  
Author(s):  
Hao Hua Zhang ◽  
Wen Jiang Feng ◽  
Li Juan Wu
Keyword(s):  
Complex Networks ◽  
Large Scale ◽  
Software Metrics ◽  
Structural Complexity ◽  
Software Systems ◽  
Software System ◽  
Complexity Metrics ◽  
Software Structure ◽  
Basic Parameters ◽  
Software Development Practices

Measuring the complexity of a large-scale software system has been a urgent demand in software development practices. The traditional software metrics can hardly describe the structural complexity in modern software. As the complex networks theory has been used to study the software structure, we analyzed a great many software systems. The analyzing results reveal the parameters in complex networks can be used to represent property of software structure. And this paper introduces some efficient metrics and measuring methods based on basic parameters in complex networks. A practice example was described to demonstrate the effectiveness of the metrics.

Extraction and Analysis of Crucial Fraction in Software Networks

2014 ◽  
Vol 24 (04) ◽  
pp. 617-634 ◽  
Author(s):  
Hui Li ◽  
Rong Chen ◽  
Xin Ge ◽  
Li-Ying Hao ◽  
Hai Zhao
Keyword(s):  
Real World ◽  
Large Scale ◽  
Empirical Studies ◽  
Object Oriented ◽  
Small World ◽  
Structural Features ◽  
Hierarchical Organization ◽  
Software Systems ◽  
Strong Connectivity ◽  
Scale Free

Many complex systems, such as software systems, are full of complexity arising from interactions among basic units (such as classes, interfaces and struts in object-oriented software systems). One of the most successful approaches to capture the underlying structural features of large-scale software systems is the investigation of hierarchical organization. However, the hierarchy of software networks has not been thoroughly investigated. In this paper, the crucial fraction (CF) in software networks has been extracted and analyzed in a set of real-world software systems. First, the classes and the relationships between them have been extracted into software networks. Then software networks have been divided into different layers, and CF of software networks has been extracted by k-core. The empirical studies in this paper reveal that software networks represent flat hierarchical structure. Finally, CF has been measured by the relevant complex network parameters respectively, and the relations between CF and overall network have been analyzed by the case studies of software networks. The results show that CF represents characteristics of scale-free, small-world, strong connectivity, and the units in CF are frequently reused and dominate the overall system.

A TOOL TO AUTOMATICALLY MAP IMPLEMENTATION-BASED TESTING TECHNIQUES TO CLASSES

2006 ◽  
Vol 16 (04) ◽  
pp. 585-614 ◽  
Author(s):  
PETER J. CLARKE ◽  
JUNHUA DING ◽  
DJURADJ BABICH ◽  
BRIAN A. MALLOY
Keyword(s):  
Large Scale ◽  
Object Oriented ◽  
Exception Handling ◽  
Software Systems ◽  
Test Coverage ◽  
Analysis And Design ◽  
Class A ◽  
Testing Techniques

The object-oriented (OO) paradigm provides several benefits during analysis and design of large-scale software systems, but scores lower in terms of testability. The low testability score for OO software is due mainly to the composition of OO systems exhibiting the characteristics of abstraction, encapsulation, genericity, inheritance, polymorphism, concurrency and exception handling. To address the difficulty of testing the features of a class, a plethora of implementation-based testing techniques (IBTTs) have been developed. However, no one IBTT has emerged as the preferred technique to test the implementation of a class. In this paper we present a technique that automatically identify those IBTTs that are most suitable for testing a class based on the characteristics of that class. Our approach uses a taxonomy of OO classes that is used to succinctly abstract the characteristics of a class under test (CUT). We have implemented a tool that automates the process of mapping IBTTs to a class. In addition to identifying the IBTTs that would be best suited for testing a class, our tool provides feedback to the tester facilitating the identification of the characteristics of the class that are not suitably tested by any of the IBTTs in the list. We provide results of a study supporting the notion that using more than on IBTT during testing improves test coverage of a CUT.

Sign in / Sign up

Export Citation Format

Share Document