Prototype software complexity metrics tools

1987 ◽  
Vol 12 (3) ◽  
pp. 58-60 ◽  
Author(s):  
C. C. Cook ◽  
M. Nanja
Keyword(s):  
Software Complexity ◽  
Complexity Metrics ◽  
Prototype Software

scholarly journals Metrics for evaluation of metaprogram complexity

2010 ◽  
Vol 7 (4) ◽  
pp. 769-787 ◽  
Author(s):  
Robertas Damasevicius ◽  
Vytautas Stuikys
Keyword(s):  
Measurement Techniques ◽  
Graph Algorithm ◽  
Aspect Oriented Programming ◽  
Engineering Software ◽  
Software Complexity ◽  
Complexity Management ◽  
Complexity Metrics ◽  
Cognitive Difficulty ◽  
Cognitive Dimensions

The concept of complexity is used in many areas of computer science and software engineering. Software complexity metrics can be used to evaluate and compare quality of software development and maintenance processes and their products. Complexity management and measurement is especially important in novel programming technologies and paradigms, such as aspect-oriented programming, generative programming, and metaprogramming, where complex multilanguage and multi-aspect program specifications are developed and used. This paper analyzes complexity management and measurement techniques, and proposes five complexity metrics (Relative Kolmogorov Complexity, Metalanguage Richness, Cyclomatic Complexity, Normalized Difficulty, Cognitive Difficulty) for measuring complexity of metaprograms at information, metalanguage, graph, algorithm, and cognitive dimensions.

Investigating the Effect of Software Complexity Metrics on Software Cost

2014 ◽  
Vol 548-549 ◽  
pp. 1319-1325
Author(s):  
Bouchaib Falah ◽  
Sara El Alaoui ◽  
Hajar Abbadi
Keyword(s):  
Life Cycle ◽  
Software Engineering ◽  
Software Metrics ◽  
Software Life Cycle ◽  
Software Cost ◽  
Software Complexity ◽  
Complexity Metrics ◽  
Extended Lifespan ◽  
New Methodologies ◽  
Do So

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.

Predicting aging-related bugs using software complexity metrics

2013 ◽  
Vol 70 (3) ◽  
pp. 163-178 ◽  
Author(s):  
Domenico Cotroneo ◽  
Roberto Natella ◽  
Roberto Pietrantuono
Keyword(s):  
Software Complexity ◽  
Complexity Metrics

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

2021 ◽  
Vol 6 (5) ◽  
Author(s):  
Bello Muriana ◽  
Ogba Paul Onuh
Keyword(s):  
Software Engineering ◽  
Programming Languages ◽  
Search Algorithm ◽  
Source Code ◽  
Search Algorithms ◽  
Binary Search ◽  
Software Systems ◽  
Software Complexity ◽  
Complexity Metrics ◽  
Binary Search Algorithm

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.

scholarly journals Pengukuran Metrik Kompleksitas Web Service Sekolah

2020 ◽  
Vol 5 (1) ◽  
pp. 147
Author(s):  
Ahmad Riza ◽  
Mohamad Alif Irfan Anshori ◽  
Farrah Arrazy ◽  
M. Ainul Yaqin
Keyword(s):  
Information System ◽  
Information Systems ◽  
Web Service ◽  
Case Studies ◽  
Software Developers ◽  
Software Complexity ◽  
Complexity Metrics ◽  
Test Parameters ◽  
Class Diagrams ◽  
Academic Information

The Complexity Metric Diagram is a method of measuring software complexity. This method uses Class Diagrams as test parameters. This study uses test data from previous research regarding the design of Information Systems accompanied by Class Diagrams with case studies of School Academic Information Systems. The facts found in the field that school software developers do not conduct application audits so it is not ripe to face problems that will arise in the future. The results of the calculation of the complexity metrics in the School Academic Information System produce an output of 993.32 units.

Complexity and Nesting Evolution in Open Source Software Systems: Experimental Study

2020 ◽  
Vol 13 (4) ◽  
pp. 572-578 ◽  
Author(s):  
Mamdouh Alenezi ◽  
Mohammad Zarour ◽  
Mohammed Akour
Keyword(s):  
Open Source Software ◽  
Correlation Coefficients ◽  
Software Systems ◽  
Software Cost ◽  
Software Complexity ◽  
Complexity Metrics ◽  
Cyclomatic Complexity ◽  
Code Refactoring ◽  
Nesting Problem ◽  
The Relationship

Background: Software complexity affects its quality; a complex software is not only difficult to read, maintain and less efficient, but it also can be less secure with many vulnerabilities. Complexity metrics, e.g. cyclomatic complexity and nesting levels, are commonly used to predict and benchmark software cost and efficiency. Complexity metrics are also used to decide if code refactoring is needed. Objective: Software systems with high complexity need more time to develop and test and may lead to bad understandability and more errors. Nesting level in the target structure may result in developing more complex software in what is so-called the nesting problem. Nesting problem should be shortened by rewriting the code or breaking into several functional procedures. Method: In this paper, the relationship between the nesting levels, the cyclomatic complexity, and lines of code (LOC) metrics are measured through several software releases. In order to address how strong a relationship between these factors with the nesting level, correlation coefficients are calculated. Moreover, to examine to what extent the developers are aware of and tackle the nesting problem, the evolution of nesting levels for ten releases of five open sources systems is studied to see if it is improving over successive versions or not. Results: The result shows that the nesting level has variant effects on the cyclomatic complexity and SLOC for the five studied systems. Conclusion: nesting level has the tendency to have a positive correlation with other factors (cyclomatic complexity and LOC).

Sign in / Sign up

Export Citation Format

Share Document