Source Code Complexity Research Articles

Comparative Study of Source Code Complexity in PHP Web Applications: Utilization of Commercial Code Generators and Manual Framework

Comparative Study of Source Code Complexity in PHP Web Applications: Utilization of Commercial Code Generators and Manual Framework

Effort-Aware Fault-Proneness Prediction Using Non-API-Based Package-Modularization Metrics

Source code complexity of legacy object-oriented (OO) software has a trickle-down effect over the key activities of software development and maintenance. Package-based OO design is widely believed to be an effective modularization. Recently, theories and methodologies have been proposed to assess the complementary aspects of legacy OO systems through package-modularization metrics. These package-modularization metrics basically address non-API-based object-oriented principles, like encapsulation, commonality-of-goal, changeability, maintainability, and analyzability. Despite their ability to characterize package organization, their application towards cost-effective fault-proneness prediction is yet to be determined. In this paper, we present theoretical illustration and empirical perspective of non-API-based package-modularization metrics towards effort-aware fault-proneness prediction. First, we employ correlation analysis to evaluate the relationship between faults and package-level metrics. Second, we use multivariate logistic regression with effort-aware performance indicators (ranking and classification) to investigate the practical application of proposed metrics. Our experimental analysis over open-source Java software systems provides statistical evidence for fault-proneness prediction and relatively better explanatory power than traditional metrics. Consequently, these results guide developers for reliable and modular package-based software design.

Measuring Cyclomatic Complexity of Source Code Using Machine Learning

Measuring Cyclomatic Complexity of Source Code Using Machine Learning

Integrated Visual Software Analytics on the GitHub Platform

Readily available software analysis and analytics tools are often operated within external services, where the measured software analysis data are kept internally and no external access to the data is available. We propose an approach to integrate visual software analysis on the GitHub platform by leveraging GitHub Actions and the GitHub API, covering both analysis and visualization. The process is to perform software analysis for each commit, e.g., static source code complexity metrics, and augment the commit using the resulting data, stored as git objects within the same repository. We show that this approach is feasible by integrating it into 64 open source TypeScript projects. Furthermore, we analyze the impact on Continuous Integration (CI) run time and repository storage. The stored software analysis data are externally accessible to allow for visualization tools, such as software maps. The effort to integrate our approach is limited to enabling the analysis component within a project’s CI on GitHub and embed an HTML snippet into the project’s website for visualization. This enables a large amount of projects to have access to software analysis as well as provide means to communicate the current status of a project.

Pride: Prioritizing Documentation Effort Based on a PageRank-Like Algorithm and Simple Filtering Rules

Code documentation can be helpful in many software quality assurance tasks. However, due to resource constraints (e.g., time, human resources, and budget), programmers often cannot document their work completely and timely. In the literature, two approaches (one is supervised and the other is unsupervised) have been proposed to prioritize documentation effort to ensure the most important classes to be documented first. However, both of them contain several limitations. The supervised approach overly relies on a difficult-to-obtain labeled data set and has high computation cost. The unsupervised one depends on a graph representation of the software structure, which is inaccurate since it neglects many important couplings between classes. In this paper, we propose an improved approach, named Pride, to prioritize documentation effort. First, Pride uses a weighted directed class coupling network to precisely describe classes and their couplings. Second, we propose a PageRank-like algorithm to quantify the importance of classes in the whole class coupling network. Third, we use a set of software metrics to quantify source code complexity and further propose a simple but easy-to-operate filtering rule. Fourth, we sort all the classes according to their importance in descending order and use the filtering rule to filter out unimportant classes. Finally, a threshold <inline-formula><tex-math notation="LaTeX">$k$</tex-math></inline-formula> is utilized, and the top- <inline-formula><tex-math notation="LaTeX">$k$</tex-math></inline-formula> % ranked classes are the identified important classes to be documented first. Empirical results on a set of nine software systems show that, according to the average ranking of the Friedman test, Pride is superior to the existing approaches in the whole data set.

Constructing an AI Compiler for ARM Cortex-M Devices

The diversity of software and hardware forces programmers to spend a great deal of time optimizing their source code, which often requires specific treatment for each platform. The problem becomes critical on embedded devices, where computational and memory resources are strictly constrained. Compilers play an essential role in deploying source code on a target device through the backend. In this work, a novel backend for the Open Neural Network Compiler (ONNC) is proposed, which exploits machine learning to optimize code for the ARM Cortex-M device. The backend requires minimal changes to Open Neural Network Exchange (ONNX) models. Several novel optimization techniques are also incorporated in the backend, such as quantizing the ONNX model’s weight and automatically tuning the dimensions of operators in computations. The performance of the proposed framework is evaluated for two applications: handwritten digit recognition on the Modified National Institute of Standards and Technology (MNIST) dataset and model, and image classification on the Canadian Institute For Advanced Research and 10 (CIFAR-10) dataset with the AlexNet-Light model. The system achieves 98.90% and 90.55% accuracy for handwritten digit recognition and image classification, respectively. Furthermore, the proposed architecture is significantly more lightweight than other state-of-the-art models in terms of both computation time and generated source code complexity. From the system perspective, this work provides a novel approach to deploying direct computations from the available ONNX models to target devices by optimizing compilers while maintaining high efficiency in accuracy performance.

A Deterministic Portable Parallel Pseudo-Random Number Generator for Pattern-Based Programming of Heterogeneous Parallel Systems

SkePU is a pattern-based high-level programming model for transparent program execution on heterogeneous parallel computing systems. A key feature of SkePU is that, in general, the selection of the execution platform for a skeleton-based function call need not be determined statically. On single-node systems, SkePU can select among CPU, multithreaded CPU, single or multi-GPU execution. Many scientific applications use pseudo-random number generators (PRNGs) as part of the computation. In the interest of correctness and debugging, deterministic parallel execution is a desirable property, which however requires a deterministically parallelized pseudo-random number generator. We present the API and implementation of a deterministic, portable parallel PRNG extension to SkePU that is scalable by design and exhibits the same behavior regardless where and with how many resources it is executed. We evaluate it with four probabilistic applications and show that the PRNG enables scalability on both multi-core CPU and GPU resources, and hence supports the universal portability of SkePU code even in the presence of PRNG calls, while source code complexity is reduced.

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.

Code Complexity and Version History for Enhancing Hybrid Bug Localization

Software projects are not void from bugs when they are released, so the developers keep receiving bug reports that describe technical issues. The process of identifying the buggy code files that correspond to the submitted bug reports is called bug localization. Automating the bug localization process can speed up bug fixing and improve the productivity of the developers, especially with a large number of submitted bug reports. Several automatic bug localization approaches were proposed in the literature reviews which are based on the textual and /or semantic similarity among the bug reports and the source code files. Nevertheless, none of the previous approaches made use of the source code complexity despite its importance; as high complexity source code files have higher probabilities to be modified than the low complexity files and are prone to bug occurrences. To improve the accuracy of the automatic bug localization task, this paper proposes a Hybrid Bug Localization approach (HBL) that makes full use of textual and semantic features of source code files, previously fixed bug reports, in addition to the source code complexity and version history properties. The effectiveness of the proposed approach was assessed using three open-source Java projects, ZXing, SWT, and AspectJ, of different sizes. Experimental results showed that the proposed approach outperforms several state-of-the-art approaches in terms of the mean average precision (MAP) and the mean reciprocal rank (MRR) metrics.

User Interface Matters: Analysing the Complexity of Mobile Applications from a Visual Perspective

Product-centric techniques to analyze mobile applications leverage traditional source code analysis, size, market success, complexity, and others. Many of these techniques converge in the strategy of evaluating metrics taken from the source code that delivers the functionality of the software product. However, when following the Model-View-Controller (MVC) architecture, mobile applications are typically constructed by a compound of at least two programming languages, one to deliver the functionality and the other to describe the visual aspects. The latter is commonly left out from source code analysis, even though critical parts of the application are present in the graphic User Interface (UI). In this paper, we identify an opportunity to strengthen the product-centric mobile app analysis by incorporating UI metrics. This approach aims to enhance the expressiveness of source code metrics and deliver a more comprehensive analysis of the complexity, maintainability, and effort estimation of a mobile app. To introduce the concept, we present a case study realized using a block-based programming language to create mobile apps, in which we describe and calculate functional and UI metrics, discover commonalities and differences, discuss traits, and open tracks for further research.

VulDetector: Detecting Vulnerabilities Using Weighted Feature Graph Comparison

Code similarity is one promising approach to detect vulnerabilities hidden in software programs. However, due to the complexity and diversity of source code, current methods suffer low accuracy, high false negative and poor performance, especially in analyzing a large program. In this paper, we propose to tackle these problems by presenting VulDetector, a static-analysis tool to detect C/C++ vulnerabilities based on graph comparison at the granularity of function. At the key of VulDetector is a weighted feature graph (WFG) model which characterizes function with a small yet semantically rich graph. It first pinpoints vulnerability-sensitive keywords to slice the control flow graph of a function, thereby reducing the graph size without compromising security-related semantics. Then, each sliced subgraph is characterized using WFG, which provides both syntactic and semantic features in varying degrees of security. As for graph comparison, we take full usage of vulnerability graph and patch graph to improve accuracy. In addition, we propose two optimization methods based on analysis of vulnerabilities. We have implemented VulDetector to automatically detect vulnerabilities in software programs with known vulnerabilities. The experimental results prove the effectiveness and efficiency of VulDetector.

An exploratory study of smart contracts in the Ethereum blockchain platform

Ethereum is a blockchain platform that supports smart contracts. Smart contracts are pieces of code that perform general-purpose computations. For instance, smart contracts have been used to implement crowdfunding initiatives that raised a total of US$6.2 billion from January to June of 2018. In this paper, we conduct an exploratory study of smart contracts. Differently from prior studies that focused on particular aspects of a subset of smart contracts, our goal is to have a broader understanding of all contracts that are currently deployed in Ethereum. In particular, we elucidate how frequently used the contracts are (activity level), what they do (category), and how complex they are (source code complexity). To conduct this study, we mined and cross-linked data from four sources: Ethereum dataset on the Google BigQuery platform, Etherscan, State of the DApps, and CoinMarketCap. Our study period runs from July 2015 (inception of Ethereum) until September 2018. With regards to activity level, we notice that it is concentrated on a very small subset of the contracts. More specifically, only 0.05% of the smart contracts are the target of 80% of the transactions that are sent to contracts. New solutions to cope with Ethereum’s limited scalability should take such an activity imbalance into consideration. With regards to categories, we highlight that the new and widely advertised rich programming model of smart contracts is currently being used to develop very simple applications that tend to be token-centric (e.g., ICOs, Crowdsales, etc). Finally, with regards to code complexity, we observe that the source code of high-activity verified contracts is small, with at most 211 instructions in 80% of the cases. These contracts also commonly include at least two subcontracts and libraries in their source code. The comment ratio of these contracts is also significantly higher than that of GitHub top-starred projects written in Java, C++, and C#. Hence, the source code of high-activity verified smart contracts exhibit particular complexity characteristics compared to other popular programming languages. Further studies are necessary to uncover the actual reasons behind such differences. Finally, based on our findings, we propose an open research agenda to drive and foster future studies in the area.

Entropy-Based Two-Dimensional Software Reliability Growth Modeling for Open-Source Software Incorporating Change-Point

This study provides an analytical model to predict the fixing pattern of issues in the open-source software (OSS) packages to assist developers in software development and maintenance. Moreover, the continuous evolution of software due to bugs removal, new features addition or existing features modification results in the source code complexity. The proposed model quantifies the complexity in the source code using the Shannon entropy measure. In addition, the issues fixing growth behavior is viewed as a function of continuation time of the software in the field environment and amount of uncertainty or complexity present in the source code. Therefore, a two-dimensional function called Cobb–Douglas production function is applied to model the intensity function of the issues fixing rate. Furthermore, the rate of fixing the different issue types is considered variable that may alter after certain time points. Thus, this study incorporates the concept of multiple change-points to predict and assess the fixing behavior of issues in the software system. The performance of the proposed model is validated by fitting the proposed model to the actual issues data of three open-source projects. Findings of the data analysis exhibit excellent prediction and estimation capability of the model.

How Combinatory Logic Can Limit Computing Complexity

As computing capabilities are extending, the amount of source code to manage is inevitably becoming larger and more complex. No matter how hard we try, the bewildering complexity of the source code always ends up overwhelming its own creator, to the point of giving the appearance of chaos. As a solution to the cognitive complexity of source code, we are proposing to use the framework of Combinatory Logic to construct complex computational concepts that will provide a model of description of the code that is easy and intuitive to grasp. Combinatory Logic is already known as a model of computation but what we are proposing here is to use a logic of combinators and operators to reverse engineer more and more complex computational concept up from the source code. Through the two key notions of computational concept and abstract operator, we will show that this model offers a new, meaningful and simple way of expressing what the intricate code is about.

Student placement and skill ranking predictors for programming classes using class attitude, psychological scales, and code metrics

In some situations, it is necessary to measure personal programming skills. For example, often students must be divided according to skill level and motivation to learn or companies recruiting employees must rank candidates by evaluating programming skills through programming tests, programming contests, etc. This process is burdensome because teachers and recruiters must prepare, implement, and evaluate a placement examination. This paper tries to predict the placement and ranking results of programming contests via machine learning without such an examination. Explanatory variables used for machine learning are classified into three categories: Psychological Scales, Programming Tasks, and Student-answered Questionnaires. The participants are university students enrolled in a Java programming class. One target variable is the placement result based on an examination by a teacher of a class and the ranking results of the programming contest. Our best classification model with a decision tree has an F-measure of 0.912, while our best ranking model with an SVM-rank has an nDCG of 0.962. In both prediction models, the best explanatory variable is from the Programming Task followed in order by Psychological Sale and Student-answered Questionnaire. Our classification model uses 9 explanatory variables, while our ranking model uses 20 explanatory variables. These include all three types of explanatory variables. The source code complexity, which is a source code metrics from Programming Task, shows best performance when the prediction uses only one explanatory variable. Contribution (1), this method can automate some of the teacher’s workload, which may improve educational quality and increase the number of acceptable students in the course. Contribution (2), this paper shows the potential of using difficult-to-formulate information for an evaluation such as a Psychological Scale is demonstrated. These are the contributions and implications of this paper.

Patterns of developers behaviour: A 1000-hour industrial study

Abstract Monitoring developers’ activity in the Integrated Development Environment (IDE) and, in general, in their working environment, can be useful to provide context to recommender systems, and, in perspective, to develop smarter IDEs. This paper reports results of a long (about 1000 h) observational study conducted in an industrial environment, in which we captured developers’ interaction with the IDE, with various applications available in their workstation, and related them with activities performed on source code files. Specifically, the study involved six developers working on three software systems and investigated (i) how much time developers spent on various activities and how they shift from one activity to another (ii) how developers navigate through the software architecture during their task, and (iii) how the complexity and readability of source code may trigger further actions, such as requests for help or browsing/changing other files. Results of our study suggest that: (i) not surprisingly, developers spend most or their time (∼ 61%) in development activities while the usage of online help is limited (2%) but intensive in specific development sessions; (ii) developers often execute the system under development after working on code, likely to verify the effect of applied changes on the system’s behaviour; (iii) while working on files having a high complexity, developers tend to more frequently execute the system as well as to use more online help websites.

An Approach for Detecting Unnecessary Cyclomatic Complexity on Source Code

Seeking product's quality is essential nowadays. One of the many quality aspects in software development is the source code complexity. Not paying attention to the complexity during the development can result in unexpected cost, caused by the difficulty on the source code understanding. The goal of this paper is to introduce an initial approach to identify unnecessary complexity in source code. Besides identifying, the approach can also show to its user how to properly rewrite the source code without the unnecessary complexity. The approach is based on the static analysis of the source code control flow graph. Once the unnecessary complexity is identified, the graph is refactored in order to allow the user to understand the improvement on the source code. The approach was included in a software tool in order to prove its concept. A performance evaluation of the approach was performed, resulting in a high accuracy. Two experimental studies were also performed to assess the viability of the approach when used by real users. The evidences provided by these studies suggests that the approach support the unnecessary complexity removal.

ARINC661 Graphics Rendering Based on OpenVG and Its Use Cases with Wireless Communications

ARINC 661 is a standard for the CDS (Cockpit Display Systems) defined by ARINC (Aeronautical Radio, Inc.) and used for application to communicate and display sensing data and information. ARINC 661 contains various two-dimensional GUI (Graphical User Interface) widget definitions. The widget set covers a variety of graphics elements including circles, arcs, crowns and others. Additionally, the symbol widgets provide rendering of user defined polygonal shapes which are typically described with triangle fans and triangle strips. ARINC 661 has various rendering features including text, image output, transformation of object and the halo effect which renders the outlines of graphics objects for highlighting. It is possible to use 3D graphics libraries like OpenGL and DirectX for implementation of graphics features. However those 3D graphics libraries are too heavy and over-powered to show 2D graphics primitives defined in ARINC 661. In this paper, we propose ARINC661 rendering based on OpenVG. OpenVG is a standard of 2D vector graphics API defined by the Khronos Group. OpenVG is designed for embedded system GUI rendering and its features are appropriate to implement ARINC661. Compare with OpenGL, OpenVG defined with fixed pipeline architecture without programmable shader. Therefore, OpenVG is cost effective to rendering and certification of software quality by reducing complexity of application source code. We also propose ARINC661 use cases for wireless application to communicate and display data from various sensor network, information gathered from unmanned aerial and land vehicles.

Automated refactoring to the Null Object design pattern

ContextNull-checking conditionals are a straightforward solution against null dereferences. However, their frequent repetition is considered a sign of poor program design, since they introduce source code duplication and complexity that impacts code comprehension and maintenance. The Null Object design pattern enables the replacement of null-checking conditionals with polymorphic method invocations that are bound, at runtime, to either a real object or a Null Object. ObjectiveThis work proposes a novel method for automated refactoring to Null Object that eliminates null-checking conditionals associated with optional class fields, i.e., fields that are not initialized in all class instantiations and, thus, their usage needs to be guarded in order to avoid null dereferences. MethodWe introduce an algorithm for automated discovery of refactoring opportunities to Null Object. Moreover, we specify the source code transformation procedure and an extensive set of refactoring preconditions for safely refactoring an optional field and its associated null-checking conditionals to the Null Object design pattern. The method is implemented as an Eclipse plug-in and is evaluated on a set of open source Java projects. ResultsSeveral refactoring candidates are discovered in the projects used in the evaluation and their refactoring lead to improvement of the cyclomatic complexity of the affected classes. The successful execution of the projects’ test suites, on their refactored versions, provides empirical evidence on the soundness of the proposed source code transformation. Runtime performance results highlight the potential for applying our method to a wide range of project sizes. ConclusionOur method automates the elimination of null-checking conditionals through refactoring to the Null Object design pattern. It contributes to improvement of the cyclomatic complexity of classes with optional fields. The runtime processing overhead of applying our method is limited and allows its integration to the programmer’s routine code analysis activities.

Handover of managerial responsibilities in global software development: a case study of source code evolution and quality

Studies report on the negative effect on quality in global software development (GSD) due to communication and coordination-related challenges. However, empirical studies reporting on the magnitude of the effect are scarce. This paper presents findings from an embedded explanatory case study on the change in quality over time, across multiple releases, for products that were developed in a GSD setting. The GSD setting involved periods of distributed development between geographically dispersed sites as well as a handover of project management responsibilities between the involved sites. Investigations were performed on two medium-sized products from a company that is part of a large multinational corporation. Quality is investigated quantitatively using defect data and measures that quantify two source code properties, size and complexity. Observations were triangulated with subjective views from company representatives. There were no observable indications that the distribution of work or handover of project management responsibilities had an impact on quality on both products. Among the product-, process- and people-related success factors, we identified well-designed product architectures, early handover planning and support from the sending site to the receiving site after the handover and skilled employees at the involved sites. Overall, these results can be useful input for decision-makers who are considering distributing development work between globally dispersed sites or handing over project management responsibilities from one site to another. Moreover, our study shows that analyzing the evolution of size and complexity properties of a product’s source code can provide valuable information to support decision-making during similar projects. Finally, the strategy used by the company to relocate responsibilities can also be considered as an alternative for software transfers, which have been linked with a decline in efficiency, productivity and quality.