Complex Code Research Articles

Культурные коды в контексте национальной безопасности

The article analyzes the role of cultural codes in ordering social processes and preserving the integrity and ethno-cultural uniqueness of Russian society. The authors prove that language, symbols and other sign systems, along with traditions, customs and rituals, as well as norms and rules of conduct, constitute a complex of cultural codes of ethnic groups and are the leading characteristics of ethno-cultural identity and national cultures that are used as social mechanisms of spiritual continuity and preservation of the integrity of society.

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.

Exploring Maintainability Index Variants for Software Maintainability Measurement in Object-Oriented Systems

During maintenance, software systems undergo continuous correction and enhancement activities due to emerging faults, changing environments, and evolving requirements, making this phase expensive and time-consuming, often exceeding the initial development costs. To understand and manage software under development and maintenance better, several maintainability measures have been proposed. The Maintainability Index is commonly used as a quantitative measure of the relative ease of software maintenance. There are several Index variants that differ in the factors affecting maintainability (e.g., code complexity, software size, documentation) and their given importance. To explore the variants and understand how they compare when evaluating software maintainability, an experiment was conducted with 45 Java-based object-oriented software systems. The results showed that the choice of the variant could influence the perception of maintainability. Although different variants presented different values when subjected to the same software, their values were strongly positively correlated and generally indicated similarly how maintainability evolved between releases and over the long term. Though, when focusing on fine-grained results posed by the Index, the variant selection had a larger impact. Based on their characteristics, behavior, and interrelationships, the variants were divided into two distinct clusters, i.e., variants that do not consider code comments in their calculation and those that do.

Automatic transformation of irreducible representations for efficient contraction of tensors with cyclic group symmetry

Tensor contractions are ubiquitous in computational chemistry and physics, where tensors generally represent states or operators and contractions express the algebra of these quantities. In this context, the states and operators often preserve physical conservation laws, which are manifested as group symmetries in the tensors. These group symmetries imply that each tensor has block sparsity and can be stored in a reduced form. For nontrivial contractions, the memory footprint and cost are lowered, respectively, by a linear and a quadratic factor in the number of symmetry sectors. State-of-the-art tensor contraction software libraries exploit this opportunity by iterating over blocks or using general block-sparse tensor representations. Both approaches entail overhead in performance and code complexity. With intuition aided by tensor diagrams, we present a technique, irreducible representation alignment, which enables efficient handling of Abelian group symmetries via only dense tensors, by using contraction-specific reduced forms. This technique yields a general algorithm for arbitrary group symmetric contractions, which we implement in Python and apply to a variety of representative contractions from quantum chemistry and tensor network methods. As a consequence of relying on only dense tensor contractions, we can easily make use of efficient batched matrix multiplication via Intel’s MKL and distributed tensor contraction via the Cyclops library, achieving good efficiency and parallel scalability on up to 4096 Knights Landing cores of a supercomputer.

Codebase release 1.3 for SymTensor

Tensor contractions are ubiquitous in computational chemistry and physics, where tensors generally represent states or operators and contractions express the algebra of these quantities. In this context, the states and operators often preserve physical conservation laws, which are manifested as group symmetries in the tensors. These group symmetries imply that each tensor has block sparsity and can be stored in a reduced form. For nontrivial contractions, the memory footprint and cost are lowered, respectively, by a linear and a quadratic factor in the number of symmetry sectors. State-of-the-art tensor contraction software libraries exploit this opportunity by iterating over blocks or using general block-sparse tensor representations. Both approaches entail overhead in performance and code complexity. With intuition aided by tensor diagrams, we present a technique, irreducible representation alignment, which enables efficient handling of Abelian group symmetries via only dense tensors, by using contraction-specific reduced forms. This technique yields a general algorithm for arbitrary group symmetric contractions, which we implement in Python and apply to a variety of representative contractions from quantum chemistry and tensor network methods. As a consequence of relying on only dense tensor contractions, we can easily make use of efficient batched matrix multiplication via Intel’s MKL and distributed tensor contraction via the Cyclops library, achieving good efficiency and parallel scalability on up to 4096 Knights Landing cores of a supercomputer.

N-Terminally arginylated ubiquitin is attached to histone H2A by RING1B E3 ligase in human cells

Ubiquitin (Ub) is highly conserved in all eukaryotic organisms and begins at the N-terminus with Met and Gln. Our recent research demonstrates that N-terminally (Nt-) arginylated Ub can be produced in the yeast Saccharomyces cerevisiae. However, the existence of Nt-arginylated Ub in multicellular organisms remains unknown. Here we explore the mechanism for creating Nt-arginylated Ub using human embryonic kidney HEK293 cells that express various Nt-modified Ubs. We found that Gln-starting Q-Ub was converted into Glu-starting E-Ub by NTAQ1 Nt-deamidase and subsequently Nt-arginylated by ATE1 arginyltransferase in HEK293 cells. We also found that the resulting Arg-Glu-starting RE-Ub was mainly deposited on the Lys119 residue of histone H2A. Furthermore, RING1B E3 Ub ligase mediated the attachment of RE-Ub to H2A. These findings reveal a previously unknown type of histone ubiquitylation which greatly increases the combinatorial complexity of histone and ubiquitin codes.

On the accuracy of code complexity metrics: A neuroscience-based guideline for improvement.

Complexity is the key element of software quality. This article investigates the problem of measuring code complexity and discusses the results of a controlled experiment to compare different views and methods to measure code complexity. Participants (27 programmers) were asked to read and (try to) understand a set of programs, while the complexity of such programs is assessed through different methods and perspectives: (a) classic code complexity metrics such as McCabe and Halstead metrics, (b) cognitive complexity metrics based on scored code constructs, (c) cognitive complexity metrics from state-of-the-art tools such as SonarQube, (d) human-centered metrics relying on the direct assessment of programmers' behavioral features (e.g., reading time, and revisits) using eye tracking, and (e) cognitive load/mental effort assessed using electroencephalography (EEG). The human-centered perspective was complemented by the subjective evaluation of participants on the mental effort required to understand the programs using the NASA Task Load Index (TLX). Additionally, the evaluation of the code complexity is measured at both the program level and, whenever possible, at the very low level of code constructs/code regions, to identify the actual code elements and the code context that may trigger a complexity surge in the programmers' perception of code comprehension difficulty. The programmers' cognitive load measured using EEG was used as a reference to evaluate how the different metrics can express the (human) difficulty in comprehending the code. Extensive experimental results show that popular metrics such as V(g) and the complexity metric from SonarSource tools deviate considerably from the programmers' perception of code complexity and often do not show the expected monotonic behavior. The article summarizes the findings in a set of guidelines to improve existing code complexity metrics, particularly state-of-the-art metrics such as cognitive complexity from SonarSource tools.

A Halo abstraction for distributed n-dimensional structured grids within the C++ PGAS library DASH.

The Partitioned Global Address Space (PGAS) library DASH provides C++ container classes for distributed N-dimensional structured grids. This article presents enhancements on top of the DASH library to support stencil operations and halo areas to conveniently and efficiently parallelize structured grids. The improvements include definitions of multiple stencil operators, automatic derivation of halo sizes, efficient halo data exchanges, as well as communication hiding optimizations. The main contributions of this article are two-fold. First, the halo abstraction concept and the halo wrapper software components are explained. Second, the code complexity and the runtime of an example code implemented in DASH and pure Message Passing Interface (MPI) are compared.

Quality Evaluation of Modern Code Reviews Through Intelligent Biometric Program Comprehension

Code review is an essential practice in software engineering to spot code defects in the early stages of software development. Modern code reviews (e.g., acceptance or rejection of pull requests with Git) have become less formal than classic Fagan's inspections, lightweight, and more reliant on individuals (i.e., reviewers). However, reviewers may encounter mentally demanding challenges during the code review, such as code comprehension difficulties or distractions that might affect the code review quality. This work proposes a novel approach that evaluates the quality of code reviews in terms of bug-finding effectiveness and provides the reviewers with a clear message of whether the review should be repeated, indicating the code regions that may not have been well-reviewed. The proposed approach utilizes biometric information collected from the reviewer during the review process using non-intrusive biofeedback devices (e.g., smartwatches). Biometric measures such as Heart Rate Variability (HRV) and task-evoked pupillary response are captured as a surrogate of the cognitive state of the reviewer (e.g., mental workload) and inexpensive desktop eye-trackers compatible with the software development settings. This work uses Artificial Intelligence techniques to predict the cognitive load from the extracted biomarkers and classify each code region according to a set of features. The final evaluation considers various factors such as code complexity, time of the code review, the experience level of the reviewer, and other factors. Our experimental results show the approach could predict the review quality with 87.77%±4.65 accuracy and a Spearman correlation coefficient of 0.85 (p-value < 0.001) between the predicted and the actual review performance. This evaluation validates the cognitive load measurement using electroencephalography (EEG) signals as ground truth for the HRV and pupil signals.

An End-to-End Natural Language Processing Application for Prediction of Medical Case Coding Complexity: Algorithm Development and Validation.

Medical coding is the process that converts clinical documentation into standard medical codes. Codes are used for several key purposes in a hospital (eg, insurance reimbursement and performance analysis); therefore, their optimization is crucial. With the rapid growth of natural language processing technologies, several solutions based on artificial intelligence have been proposed to aid in medical coding by automatically suggesting relevant codes for clinical documents. However, their effectiveness is still limited to simple cases, and it is not yet clear how much value they can bring in improving coding efficiency and accuracy. This study aimed to bring more efficiency to the coding process to improve the selection of codes by medical coders. To achieve this, we developed an innovative multimodal machine learning-based solution that, instead of predicting codes, detects the degree of coding complexity before coding is performed. The notion of coding complexity was used to better dispatch work among medical coders to eventually minimize errors and improve throughput. To train and evaluate our approach, we collected 2060 cases rated by coders in terms of coding complexity from 1 (simplest) to 4 (most complex). We asked 2 expert coders to rate 3.01% (62/2060) of the cases as the gold standard. The agreements between experts were used as benchmarks for model evaluation. A case contains both clinical text and patient metadata from the hospital electronic health record. We extracted both text features and metadata features, then concatenated and fed them into several machine learning models. Finally, we selected 2 models. The first used cross-validated training on 1751 cases and testing on 309 cases aiming to assess the predictive power of the proposed approach and its generalizability. The second model was trained on 1998 cases and tested on the gold standard to validate the best model performance against human benchmarks. Our first model achieved a macro-F1-score of 0.51 and an accuracy of 0.59 on classifying the 4-scale complexity. The model distinguished well between the simple (combined complexity 1-2) and complex (combined complexity 3-4) cases with a macro-F1-score of 0.65 and an accuracy of 0.71. Our second model achieved 61% agreement with experts' ratings and a macro-F1-score of 0.62 on the gold standard, whereas the 2 experts had a 66% (41/62) agreement ratio with a macro-F1-score of 0.67. We propose a multimodal machine learning approach that leverages information from both clinical text and patient metadata to predict the complexity of coding a case in the precoding phase. By integrating this model into the hospital coding system, distribution of cases among coders can be done automatically with performance comparable with that of human expert coders, thus improving coding efficiency and accuracy at scale.

On the diffusion of test smells and their relationship with test code quality of Java projects

AbstractTest smells are considered bad practices that can reduce the test code quality, thus harming software testing goals and maintenance activities. Prior studies have investigated the diffusion of test smells and their impact on test code maintainability. However, we cannot directly compare the outcomes of the studies as most of them use customized datasets. In response, we introduced the TSSM (Test Smells and Structural Metrics) dataset, containing test smells detected using the JNose Test tool and structural metrics (test code and production code) calculated with the CK metrics tool of 13,703 open‐source Java systems from GitHub. In addition, we perform an empirical study to investigate the relationship between test smells and structural metrics of test code and the relationship between test smells on a large‐scale dataset. We split the projects into three clusters to analyze the distribution of test smells, the co‐occurrences among test smells, and the correlation of test smells and structural metrics of test code. The ratio of smelly test classes with a specific test smell is similar among the clusters, but we could observe a significant difference in the number of test smells among them. The test smells Sleepy Test, Mystery Guest, and Resource Optimism rarely occur in the three clusters, and the last two are strongly correlated, indicating that those test smells are more severe than others. Our results point out that most test smells have a moderate correlation with high complexity, large size, and coupling of the test code, indicating that they can also negatively affect its quality. To support further studies, we made our dataset publicly available.

CN: Verifying Systems C Code with Separation-Logic Refinement Types

Despite significant progress in the verification of hypervisors, operating systems, and compilers, and in verification tooling, there exists a wide gap between the approaches used in verification projects and conventional development of systems software. We see two main challenges in bringing these closer together: verification handling the complexity of code and semantics of conventional systems software, and verification usability. We describe an experiment in verification tool design aimed at addressing some aspects of both: we design and implement CN, a separation-logic refinement type system for C systems software, aimed at predictable proof automation, based on a realistic semantics of ISO C. CN reduces refinement typing to decidable propositional logic reasoning, uses first-class resources to support pointer aliasing and pointer arithmetic, features resource inference for iterated separating conjunction, and uses a novel syntactic restriction of ghost variables in specifications to guarantee their successful inference. We implement CN and formalise key aspects of the type system, including a soundness proof of type checking. To demonstrate the usability of CN we use it to verify a substantial component of Google's pKVM hypervisor for Android.

A Customizable No-Code Realistic Motion Editor for VRM-Based Avatars

Avatar actions can be captured using certain gesture sensors or can be predefined by game designers through desktop applications. In other words, developing an online avatar editor could be necessary to specify the detailed actions for use by people who are not game creators. Our research team proposed a web-based toolset, myKLA, to construct and design avatar actions with editor and player features. The goal of myKLA is to help users define the required behaviors of avatars within a set time frame without codes. We used cyber–physical system theory in a software reconstruction initiative. Additionally, an exchangeable JSON file format for predefining the avatar actions was opened and shared here. Furthermore, the cyclomatic complexity of the main code blocks in our toolset was measured and changed using the McCabe approach to fine-tune the performance. An algorithm was proposed for quickly calculating an integrated activity diagram from several sub-activity diagrams. Our research showed that it is easy to create an avatar head and embed it in other web-based applications for additional interaction utilization. Therefore, our findings will be useful in creating and designing new educational tools.

Comparison of the Sentiment Analysis Model's Code Complexity and Processing Time

Text processing, which includes sentiment analysis, obviously demands a lot of resources. The extent to which resources are used to promote environmental conservation is directly impacted by code complexity or computational time. Twitter users' responses on the Indonesian Language of religious moderation and tolerance are used to test the model. The phases of doing the research include determining the research's needs, gathering data, text preprocessing (case folding, tokenizing, stopword removal, and stemming), word weighting with TF/IDF, and classification with Multinomial Naive Bayes (MNB) and Support Vector Machine (SVM), validation, and the last step was calculation of the code complexity and computation time. The validation results showed that the performance of the two models was still low, with an average accuracy of 75.5%. Based on computation time, SVM has a faster computational time than MNB. However, when compared in terms of the code complexity, the Cyclomatic Complexity in both models was the same because both models used existing libraries in Python Interpreter, and the complexity of the libraries cannot be calculated directly. Based on the Raw Metrics, it can be seen that MNB and SVM not significantly different in LOC, LLOC, and SLOC. It was evident that SVM has a greater Halstead Complexity than SVM in all measures when comparing the program code of MNB and SVM. Particularly on programming effort and volume metrics, SVM required more bits to run than an MNB program, and it also required more mental effort to convert a prepared SVM algorithm into a program than an MNB.

An Overview of the Reforms of Personal Income Tax (PIT) in Bangladesh

Bangladesh is a country of about 170 million people. But the tax-GDP ratio is yet to reach the double digit. There are some tax reform efforts already have taken to update the tax policy and tax administration for expected outcome. This paper attempted to review those reform efforts highlighting the personal income tax (PIT) and to summarize the reforms already have done and their implications in the revenue performance. It is an exploratory research and secondary sources of data are used to accomplish this study. After a thorough review of the reform initiatives, this study has got some point like complexity of the tax code, number of tax payers become double in last 5 years but the collected revenue is not proportional to the increased taxpayers. Collection of tax through TDS has increased to almost 60 percent. It implies the enhanced compliance and efficiency of the tax regime. Introduction of e-filing, e-payment, and universal self-assessment have reduced the hassle of taxpayers. Administrative capacity in terms of infrastructure and manpower has increased. All these progressive efforts do not bring any mentionable change in the tax structure of Bangladesh. Ratio of direct to indirect tax is very high i.e., about 30 to 70. Of this low-slung direct tax, contribution of PIT is about 40 per cent. To grow a middle-income country and sustain, contribution of PIT to the tax structure should be increased through appropriate reforms in this field.

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.

Monaco Support for an Improved Exception Specification in C++

Exception handling is a beneficial language construct in modern programming languages. However, C++’s type system does not really conform to these elements. As a consequence, developers have to pay attention to avoid mistakes because of the missing compiler support. Moreover, C++11 provides an approach in which exceptions appear in the function’s signature in an inverse manner compared to the earlier standards. Static analysis is an approach in which we reason about a program based on the source with no execution of the analyzed code. It can be used for many purposes, for instance, finding bugs, refactoring the code, or measuring code complexity. In this paper, we analyze how the older style exception specifications can be rejuvenated for modern idioms. Explicitly marking the functions as having a guaranteed exception-free execution is the primary way since C++11. We develop a static analyzer tool for providing hints for these specifications. We evaluate our method with the analysis of open-source projects. Based on the previous evaluation, not using the strictest possible exception-specification is a problem that occurred in every analyzed project. We would like to assist developers in identifying instances of this problem by providing an integrated comprehension tool, that enables them to make use of the exception analysis results in an interactive way in their IDEs.

Software Defect Prediction using Deep Learning by Correlation Clustering of Testing Metrics

The software industry has made significant efforts in recent years to enhance software quality in businesses. The use of proactively defect prediction in the software will assist programmers and white box testing in detecting issues early, saving time and money. Conventional software defect prediction methods focus on traditional source code metrics such as code complexities, lines of code, and so on. These capabilities, unfortunately, are unable to retrieve the semantics of source code. In this paper, we have presented a novel Correlation Clustering fine-tuned CNN (CCFT-CNN) model based on testing Metrics. CCFT-CNN can predict the regions of source code that contain faults, errors, and bugs. Abstract Syntax Tree (AST) tokens are extracted as testing Metrics vectors from the source code. The correlation among AST testing Metrics is performed and clustered as a more relevant feature vector and fed into Convolutional Neural Network (CNN). Then, to enhance the accuracy of defect prediction, fine-tuning of the CNN model is performed by applying hyperparameters. The result analysis is performed on the PROMISE dataset that contains samples of open-source Java applications such as Camel Dataset, Jedit dataset, Poi dataset, Synapse dataset, Xerces dataset, and Xalan dataset. The result findings show that the CCFT- CNN model increases the average F-measure by 2% when compared to the baseline model.

ENHANCING THIRD-YEAR COMPUTER SCIENCE STUDENTS' COMPUTER PROGRAMMING SKILLS AT HAWASSA UNIVERSITY, ETHIOPIA

Teaching programming in an efficient and effective method has been the most difficult subject in the world of computing for the last couple of decades. Aside from a lack of laboratory equipment, the most prevalent issues are the lengthy time it takes to understand a problem, devising algorithms, writing coding, syntax, and semantic complexity of the programming language. Because of the wide range of students' backgrounds, misconceptions about the course, traditional classroom teaching methodology, and the limited allotted time available to cover the course, it is extremely difficult for a teacher to go beyond the fundamental concepts that impede the development of students' problem-solving abilities. The major goal of thisstudy is to assist students to become better programmers by comprehending code and implementing applications for real-world problems.

The Guardians of the New Internal Revenue Code

The proliferation of electronic filing (e-filing) of income tax returns creates new problems and opportunities for the regulation of the tax return preparation industry. Now that e-filing is universal, the rules of the law are, for many taxpayers, the code of the tax software, not in the Internal Revenue Code. The natural consequences of universal e-filing are unremitting complexity in a tax code which is also used to deliver social benefits in the form of tax credits. This, combined with the political pariah status of the Internal Revenue Service (IRS), makes it imperative that the IRS work with the tax return preparers to ensure that their products are safe and accurate. More importantly, the existence of such an industry creates great opportunities for the IRS to leverage its relationship with this private sector group to improve the tax return filing experience for many taxpayers. The existing voluntary relationship between the IRS and the industry is likely no longer viable, but this article provides the blueprint for government-supervised self-regulation which can solve the problems with the new code.