Software Complexity Metrics Research Articles

Comparative Study of Java and Python Languages with Reference to Data Science

This research provides a comprehensive comparison & analysis between Java and Python, focusing on their application in data science. Key aspects such as encapsulation, AI capabilities, software complexity metrics (Halstead), data statistics, and algorithmic performance (Bubble Sort) are analyzed. This study aims to guide developers in choosing the appropriate language for their data science projects by evaluating performance, memory management, multithreading, and ecosystem richness. The findings are supported by empirical data, benchmarks, and detailed analysis, emphasizing when and how each language excels.

A Comparative Study of Different Software Complexity Metrics in Measuring Software Interoperability

Software interoperability is crucial for organizations that rely on multiple software systems to perform their operations. However, due to the complexity and variety of software systems, ensuring interoperability can be difficult. Measuring software complexity metrics can be used to identify potential problems and assess how well different interoperability strategies work. In this study, we investigated and compared the effectiveness of different software complexity metrics in measuring software interoperability. We used statistical methods to analyze data collected from a sample of software systems. The results of our study show that certain metrics, such as coupling and cohesion, are more effective than others in measuring software interoperability. By selecting appropriate metrics, developers can ensure better productivity, lower costs, and more adaptable use of software systems. The findings of this study have implications for the creation of software and can guide businesses in choosing the right criteria to achieve software interoperability.

Development of a hybrid method for calculation of software complexity

The use of code metrics allows software developers and project managers to evaluate various features of the software (to be built or already in existence), predict workload, determine software complexity and reliability, and quantify the quality of software systems being developed. Articles written in recent years have proposed various methods for solving this problem. However, there is still no very effective approach to measuring software complexity. This article provides a brief overview of existing software complexity metrics and proposes a new hybrid method for computing software complexity. The proposed hybrid method for evaluating software complexity combines the key features of the Halsted, Maccabe, and SLOC metrics and also allows for a more efficient assessment of complexity.

Cognitive Complexity Beyond Generalization: A Subjective Rating for the Human Comprehension

The cognitive complexity of a software determines the comprehension effort of a particular individual faces when designing, developing and maintaining a software. The comprehension level tends to be varied with each human resulting the cognitive complexity a subjective measurement. Expressing the cognitive complexity as a form of metric quantifies the comprehensibility as a generic value, which does not imply the subjectivity of human factor. This study elaborates the significance of expressing the cognitive complexity as a form of a subjective rating. The cognitive complexity rating has been pioneered with respect to the human and programming dependent factors related to human cognition. The Divisive hierarchical clustering algorithm has been used to train and predict the cognition rating per user. It has been clearly elaborated the subjectivity of the cognitive ratings over the quantitative and static complexity values of current cognitive and software complexity metrics. Thereby, the concept of cognition rates has been proposed as a preliminary step of determining and expressing the cognitive complexity.

COMPARISON OF SOFTWARE COMPLEXITY OF SEARCH ALGORITHM USING CODE BASED COMPLEXITY METRICS

Measures of software complexity are essential part of software engineering. Complexity metrics can be used to forecast key information regarding the testability, reliability, and manageability of software systems from study of the source code. This paper presents the results of three distinct software complexity metrics that were applied to two searching algorithms (Linear and Binary search algorithm). The goal is to compare the complexity of linear and binary search algorithms implemented in (Python, Java, and C++ languages) and measure the sample algorithms using line of code, McCabe and Halstead metrics. The findings indicate that the program difficulty of Halstead metrics has minimal value for both linear and binary search when implemented in python. Analysis of Variance (ANOVA) was adopted to determine whether there is any statistically significant differences between the search algorithms when implemented in the three programming languages and it was revealed that the three (3) programming languages do not vary considerably for both linear and binary search techniques which implies that any of the (3) programming languages is suitable for coding linear and binary search algorithms.

Analysis and evaluation of document-oriented structures

Document-oriented bases allow high flexibility in data representation which facilitates a rapid development of applications and enables many possibilities for data structuring. Unfortunately, in many cases, due to this flexibility and the absence of data modelling, the choice of a data representation is neglected by developers leading to many issues on several aspects of the document base and application quality; e.g., memory print, data redundancy, readability and maintainability. We aim at facilitating the study of data structuring alternatives and providing objective metrics to better reveal the advantages and disadvantages of a structure with respect to user needs. The main contributions of our approach are twofold. First of all, the semi-automatic generation of many suitable alternatives for data structuring given an initial UML model. Second, the automatic computation of structural metrics, allowing a comparison of the alternatives for JSON-compatible schema abstraction. These metrics reflect the complexity of the structure and are intended to be used in decision criteria for schema analysis and design process. This work capitalises on experiences with MongoDB, XML and software complexity metrics. The paper presents the schema generation and the metrics together with a validation scenario where we discuss how to use the results in a schema recommendation perspective.

Can EEG Be Adopted as a Neuroscience Reference for Assessing Software Programmers' Cognitive Load?

An emergent research area in software engineering and software reliability is the use of wearable biosensors to monitor the cognitive state of software developers during software development tasks. The goal is to gather physiologic manifestations that can be linked to error-prone scenarios related to programmers’ cognitive states. In this paper we investigate whether electroencephalography (EEG) can be applied to accurately identify programmers’ cognitive load associated with the comprehension of code with different complexity levels. Therefore, a controlled experiment involving 26 programmers was carried. We found that features related to Theta, Alpha, and Beta brain waves have the highest discriminative power, allowing the identification of code lines and demanding higher mental effort. The EEG results reveal evidence of mental effort saturation as code complexity increases. Conversely, the classic software complexity metrics do not accurately represent the mental effort involved in code comprehension. Finally, EEG is proposed as a reference, in particular, the combination of EEG with eye tracking information allows for an accurate identification of code lines that correspond to peaks of cognitive load, providing a reference to help in the future evaluation of the space and time accuracy of programmers’ cognitive state monitored using wearable devices compatible with software development activities.

Evaluating Python, C++, JavaScript and Java Programming Languages Based on Software Complexity Calculator (Halstead Metrics)

Various software organizations used software metrics to assessing and assuring operation, maintenance, and quality of software codes. Halstead is an essential type of software complexity metrics used to measure source code complexity. We presented a comparative analysis study using this metric to benefit software testing process by showing the possibility of software metrics to measure the characteristics of the software in all its aspects. Halstead metric is used to analyse the written code in python, C, JavaScript and Java programming languages. It provides a better tool to evaluate the complexity level of the language and displays the differences levels of code complexity. The conducted experiments show that python is the simplest programming language and Java is the difficulty and more complex language than others. These results benefit the automation in software metrics computation to decide which programming language can produce high quality and the less complexity software.

PRACTICAL QUALITY ANALYSIS OF OPEN SOURCE SOFTWARE

The success of any project is determined by its ability to meet the needs of the consumer, and therefore ensuring a high level of quality is a necessary task of any production, including software engineering. Insufficient quality of the created software requires many IT-organizations, up to 70% of the budget of the information system to reserve for the maintenance stage, with up to 60% of all software modifications performed to eliminate errors, and only the remaining 40% - to correct software within the business process, improvement certain indicators of software quality, or to prevent potential problems. Software quality is a complex concept. Standards highlight the quality of development processes, internal and external quality of the software product, the quality of the software product at the stage of use. For each of the components of quality can be called a set of metrics that determine the quality of the software product. The resulting structure is called the software quality model. Software metrics are a measure that allows you to get the numerical value of a property of software or its specifications, as well as the method of its calculation. Metrics allow you to get numeric values for each property of the software or its specifications. Of particular interest are software complexity metrics. Complexity is an important factor on which other parameters of software quality depend, such as accuracy, correctness, reliability, convenience of support. The existence of methods and algorithms for automatic calculation of software complexity metrics using software allows you to get a comprehensive formal report on the quality of software in a short time. This allows for objective monitoring of the quality of software throughout the project life cycle, make adjustments to the project plan, as well as make timely decisions about the need for refactoring.

Toward recursion aware complexity metrics

Abstract Context: Software developers spend a significant amount of time on reading, comprehending, and debugging of source code. Numerous software metrics can give us awareness of incomprehensible functions or of flaws in their collaboration. Invocation chains, especially recursive ones, affect solution complexity, readability, and understandability. Even though decomposed and recursive solutions are characterized as short and clear in comparison with iterative ones, they hide the complexity of the observed problem and solution. As the collaboration between functions can strongly depend on context, difficulties are usually detected in debugging, testing or by static analysis, while metrics support is still very weak. Objective: We introduce a new complexity metric, called Overall Path Complexity (OPC), which is aware of (recursive) call chains in the observed source code. As invocations are basic collaboration mechanism and recursions are broadly accepted, the OPC metric is intended to be applicable independently on programming language and paradigm. Method: We propose four different versions of the OPC calculation algorithm and explore and discuss their suitability. We have validated proposed metrics based on a Framework specially designed for evaluation and validation of software complexity metrics and accordingly performed theoretical, empirical and practical validation. Practical validation was performed on toy examples and industrial cases (47012 LOCs, 2899 functions, and 758 recursive paths) written in Erlang. Result: Based on our analysis we selected the most suitable (of 4 proposed) OPC calculation formula, and showed that the new metric expresses advanced properties of the software in comparison with other available metrics that was confirmed by low correlation. Conclusion: We introduced the OPC metric calculated on the Overall Control Flow Graph as an extension of Cyclomatic Complexity by adding awareness of (recursive) invocations. The values of the new metric can lead us to find the problematic fragments of the code or of the execution paths.

The performance cost of software obfuscation for Android applications

Software security of Android applications is especially susceptible (vulnerable) to malicious reverse engineer than the native code based software, because its Java bytecode is easier to decompile and to reconstruct the original Java source code. Therefore obfuscation is an essential criterion for the protection of Android applications. Meanwhile, the unpredicted performance loss will be caused by the obfuscation, which might seriously influence the user experience of the software. Therefore the obfuscation degree and the performance cost out of it require being optimized. In this paper, we are working on the problem that: to obfuscate an Android application to a target level of “difficulty” degree, while not substantially “slowing it down”. We measure “difficulty” by utilizing software complexity metrics and the “slow” in CPU cycles. Within the framework designed for obfuscating Android applications, we implement the “Naïve Bayesian Classifier” algorithm for the optimized obfuscation of the software complexity and the performance, and show that it outperforms the algorithm whose predictions rely on mean values. We furthermore investigate the performance penalty imposed by obfuscation process when framework targets different complexity values and metrics. We show that some obfuscation methods are more performance costly than others to achieve the same metric value increase. Our result shows that, for any given software complexity, the required performance benefits can be achieved if the right obfuscation techniques are used.

The Impact of Software Complexity on Cost and Quality - A Comparative Analysis Between Open Source and Proprietary Software

Early prediction of software quality is important for better software planning and controlling. In early development phases, design complexity metrics are considered as useful indicators of software testing effort and some quality attributes. Although many studies investigate the relationship between design complexity and cost and quality, it is unclear what we have learned beyond the scope of individual studies. This paper presented a systematic review on the influence of software complexity metrics on quality attributes. We aggregated Spearman correlation coefficients from 59 different data sets from 57 primary studies by a tailored meta-analysis approach. We found that fault proneness and maintainability are most frequently investigated attributes. Chidamber and Kemerer metric suite is most frequently used but not all of them are good quality attribute indicators. Moreover, the impact of these metrics is not different in proprietary and open source projects. The result provides some implications for building quality model across project type

When do Software Complexity Metrics Mean Nothing? – When Examined out of Context.

When do Software Complexity Metrics Mean Nothing? – When Examined out of Context.

Towards measurement of structural complexity for ontologies

Ontologies represent knowledge of a particular domain and form an elementary unit for inference techniques on the semantic web. It is important to measure the complexity of ontologies in order for users to better understand, maintain, reuse and integrate them. Existing measures for the complexity of an ontology either handle complexity at schema and instance levels or define subjective parameters to measure ontology complexity. To this end, we present a semi-automated framework to measure the structural complexity at different abstraction levels of an ontology. Moreover, our metrics leverage the information provided by ontology editors, which can be useful to the ontology designer for selection of the ontology with optimum complexity among alternative ontologies. Our framework is inspired by the concept of component-based software complexity metrics and its metrics have been validated against Briand's and Weyuker's benchmarks. We have also performed comparative analysis on public ontologies.

When do Software Complexity Metrics Mean Nothing? – When Examined out of Context.

When do Software Complexity Metrics Mean Nothing? – When Examined out of Context.

Comparison of Software Complexity Metrics

Comparison of Software Complexity Metrics

Investigating the Effect of Software Complexity Metrics on Software Cost

Nowadays, software is expected to have an extended lifespan, which makes the evaluation of its complexity at the early stages critical in upcoming maintenance. Indeed, complexity is proportional to the evolution of software. Software metrics were introduced as tools that allow us to obtain an objective measurement of the complexity of software. Hence, enabling software engineering to assess and manage software complexity. Reducing software costs is one of the major concerns of software engineering which creates an increasing need for new methodologies and techniques to control those costs. Software complexity metrics can help us to do so. In this paper, we would investigate how those metrics can be used to reduce software costs. We would first analyze the most popular complexity metrics and distinguish their properties. Then, we will show how each of those metrics fit within the software life cycle. Finally, we will provide a detailed approach to use the complexity metrics to reduce software costs.

Web software complexity metrics based on projection pursuit

Web software complexity metrics does play a very important role in the software development.The traditional software complexity metrics method mainly targets on the non-Web applications which use language like C/C + + and Ada.This paper took object-oriented Web software based on Struts framework as research subject and put forward three complexity metrics suitable for the Web-Struts software.Besides,this paper also proposed a method for computing Web software complexity metrics based on Artificial Fish Swarm Algorithm(AFSA) with cross operator and Projection Pursuit(PP) algorithm.After integrating multiple complexity metrics into one-dimension comprehensive projection value,the optimized projection direction could be acquired through sample data.Then the comprehensive projection value of evaluation grades could also be determined.According to the comparison between the comprehensive projection values of the testing samples and the interval of level,the comprehensive metrics result could be finally obtained.The example evaluation results prove the feasibility and effectiveness of the proposed method.

A Review and Analysis of Software Complexity Metrics in Structural Testing

A Review and Analysis of Software Complexity Metrics in Structural Testing

Predicting aging-related bugs using software complexity metrics

Long-running software systems tend to show degraded performance and an increased failure occurrence rate. This problem, known as Software Aging, which is typically related to the runtime accumulation of error conditions, is caused by the activation of the so-called Aging-Related Bugs (ARBs). This paper aims to predict the location of Aging-Related Bugs in complex software systems, so as to aid their identification during testing. First, we carried out a bug data analysis on three large software projects in order to collect data about ARBs. Then, a set of software complexity metrics were selected and extracted from the three projects. Finally, by using such metrics as predictor variables and machine learning algorithms, we built fault prediction models that can be used to predict which source code files are more prone to Aging-Related Bugs.