Improving Prometer, A Measure For Programmer Performance

Context: A large number of source code metrics are reported in the literature. It is necessary to systematically collect, describe and classify source code metrics to support research and practice. Objective: We aim to utilize existing secondary studies to develop a catalog of source code metrics together with their descriptions. The catalog will also provide information about which units of code (e.g., operators, operands, lines of code, variables, parameters, code blocks, or functions) are used to measure the internal quality attributes and the scope on which they are collected. Method: We conducted a tertiary study to identify secondary studies reporting source code metrics. We have classified the source code metrics according to the measured internal quality attributes, the units of code used in the measures, and the scope at which the source code metrics are collected. Results: From 711 secondary studies, we identified 52 relevant secondary studies. We reported 423 source code metrics together with their descriptions and the internal quality attributes they measure. Source code metrics predominantly incorporate function as a unit of code to measure internal quality attributes. In contrast, several source code metrics use more than one unit of code when measuring internal quality attributes. Nearly 51% of the source code metrics are collected at the class scope, while almost 12% and 15% of source code metrics are collected at module and application levels, respectively. Conclusions: Researchers and practitioners can use the extensive catalog to assess which source code metrics meet their individual needs based on the description and classification scheme presented.

A feature of the interpretive BASIC languages supplied on most microcomputers is that codes from several "BASICS" may be combined in the same program. When the executed code is correct and the code foreign to the interpreter being used is bypassed, problems do not occur. Thus, BASIC programs can be prepared which run on several different .machines. A front-end menu query is utilized to identify the brand of microcomputer on which the program is running. The source code (see Appendix) displays a hybrid BASIC program that has been used to transfer both text and BASIC programs among ffiM-PC, Radio Shack TRS80 Model ill, and Apple lIe microcomputers. Lines 240360 are consistent with the syntax rules for all three computers and present the menu through which the computer brand is identified. The user answers a query about whether to send or receive a file, and names the file to be accessed for transmission or the file to be received and stored. Lines 70-200 handle communications to and from the TRS-80 microcomputer, lines 370-610 control communications to and from the ffiM-PC, and lines 620-820 govern communications to and from the Apple lIe. If a machine other than one of the three listed is used, it may trap certain types of errors; that is, lines of code which will not run under the machine's interpreter may not be enterable from the keyboard. Should this situation arise, the user simply bypasses that line and continues to enter the remaining lines of program code. This is not a problem when the program executes because the unenterable lines would not have been executed on the machine. Communications from the sending to the receiving microcomputers are handled using standard asynchronous (RS-232)procedures. Our approach is to fit the microcomputers' serial communications ports with the appropriate vendor's RS-232 cables and then connect these cables using a modem eliminator. If the necessary cables are not readily available from the computer manufacturers, then substitutes as well as a modem eliminator may be purchased from a retail computer store or outlet. The demonstration program shown in the Appendix utilizes timing delays, set within the program, to mediate

In Engineering and Scientific computing, a significant number of software systems that are being commonly used by the Engineering community are developed and deployed as Open Source Systems (OSS). This collaborative development model has been widely accepted in both academia and industry. As these systems are typically developed by developers who are experts in their fields (e.g., Engineering), some of those programmers may be lacking an essential skillset today's software quality and engineering concepts (e.g., source code maintainability and analyzability, source code vulnerability, parallelization, etc.). An empirical study is presented that examines some of the source code quality aspects and programming practices (e.g., jumps statements, usage of recursion) from software engineering perspective in ten open source Engineering software systems. The studied systems are written in the C/C++ programming languages and comprised of over ten million lines of code, and present numerous tasks of the engineering community, including computer-aided design, computational fluid dynamics, and finite element analysis. Static analysis methods are applied to each system to determine the number of jump statements (Goto and Break statements) and functions that are recursively invoked. Functions that contain direct or indirect recursive calls are determined and counted. The results show that number of the used jump statements and functions that have recursive calls are significant and thus pose more of a roadblock to effectively and automatically maintain, comprehend, analyze, and re-engineer systems. Lastly, this leads to inefficiencies in a software engineer's ability to accomplish these common tasks. The study showed that issues in source code stemming from the lack of coding standards have increased over time and are prevalent.

A software system undergoes many code changes, which may affect code quality and maintainability. Refactoring techniques are a common strategy for restructuring source code and improving internal architecture. However, refactoring activities are limited to a catalog of well-known modifications, and we intend to investigate modifications to the source code, looking for patterns that affect its internal quality. In this work, we present a process for identifying code improvements and then learning from the modifications. This process extracts syntactic patterns of code changes and classifies them based on their impact on software maintainability. We executed the classification process on 132,819 code changes from seven GitHub repositories, obtaining 2405 significant code change patterns. Most code change patterns involve simple modifications to structural elements that have only a slight impact on maintainability. These modifications include renaming or moving code elements, simple refactoring, and adding a new implementation. We analyzed both simple modification patterns and many modifications to identify their impact on internal source code quality. The results show how significant a subset of identified patterns is to internal source code quality, as it improves or reduces maintainability variation.

ABSTRACTAn internal audit engagement at a large bank revealed that legacy software code can represent significant risk to an organization. In this engagement, several instances of malicious COBOL source code were discovered through manual inspection and identification. The internal auditors were concerned that more instances of faulty code could be in the production environment, and that manually inspecting over 100 million lines of source code would be infeasible. Under their auspices, I developed the Retrospective Static Source Code Analysis Framework for automatically identifying source code files likely to contain source code faults. We implemented this audit analytic framework in a tool called COBOL Analyzer. Using the tool, the auditors discovered thousands of potential source code files with faults and, using a ranking method, audited the most suspicious ones. The tool was deemed a success and it is undergoing further development by the internal audit team.

Many previous studies have shown that open-source technologies help democratize information and foster collaborations to enable addressing global physical and societal challenges. The outbreak of the novel coronavirus has imposed unprecedented challenges to human society. It affects every aspect of livelihood, including health, environment, transportation, and economy. Open-source technologies provide a new ray of hope to collaboratively tackle the pandemic. The role of open source is not limited to sharing a source code. Rather open-source projects can be adopted as a software development approach to encourage collaboration among researchers. Open collaboration creates a positive impact in society and helps combat the pandemic effectively. Open-source technology integrated with geospatial information allows decision-makers to make strategic and informed decisions. It also assists them in determining the type of intervention needed based on geospatial information. The novelty of this paper is to standardize the open-source workflow for spatiotemporal research. The highlights of the open-source workflow include sharing data, analytical tools, spatiotemporal applications, and results and formalizing open-source software development. The workflow includes (i) developing open-source spatiotemporal applications, (ii) opening and sharing the spatiotemporal resources, and (iii) replicating the research in a plug and play fashion. Open data, open analytical tools and source code, and publicly accessible results form the foundation for this workflow. This paper also presents a case study with the open-source spatiotemporal application development for air quality analysis in California, USA. In addition to the application development, we shared the spatiotemporal data, source code, and research findings through the GitHub repository.

A traditional obstacle in the use of multiple representations is the need to maintain traceability among the representations in the face of evolution. The introduction of software architecture, and architecture-based development, has brought this need to architectural descriptions and corresponding source code. Specifically, the task is to relate versions of architectural elements to versions of source code configuration items, and to update those relations as new versions of the architecture and source code are produced. We present ArchTrace, a new approach that we developed to address this problem. ArchTrace distinguishes itself by continuously updating traceability relations from architectural elements to code elements through a policy-based extensible infrastructure that allows a group of developers to choose a set of traceability management policies that best match their situational needs and/or working styles. We introduce the high-level approach of ArchTrace, discuss its extensible infrastructure, and present our current set of ten pluggable traceability management policies. We conclude with a retrospective analysis of data collected from a twenty month period of development and maintenance of Odyssey, a component-based software development environment comprised of over 50,000 lines of code. This analysis shows that our approach is promising: with respect to the ideal set of traceability links, the policies applied resulted in a precision of 95% and recall of 89%.

Static and dynamic program analysis techniques are important research areas in software security. Static analysis helps us locate vulnerabilities in a software by looking at the source code. Dynamic analysis helps us reason about the behavior of the software from information gathered at run-time. In this thesis, we are focusing on data flow analysis and heap analysis which are key static and dynamic program analysis techniques respectively.
\n
\nIn the first part of this thesis, we aim at detecting vulnerabilities in Android applications which have capability leaks. The security of the Android platform relies mainly on sandboxing applications and restricting their capabilities such that no application, by default, can perform any operations that would adversely impact other applications, the operating system, or the user. However, a recent research reported that a genuine but vulnerable application may leak its capabilities. When being leveraged, other applications can gain extra capabilities which they are not granted originally. We present DroidChecker, an Android application analyzing tool which searches for the aforementioned vulnerability in Android applications. DroidChecker uses interprocedural control flow graph searching and static taint checking to detect exploitable data paths in an Android application. We analyzed more than 1100 Android applications using DroidChecker and found 6 previously unknown vulnerable applications including the renowned Adobe Photoshop Express application. We also developed a malicious application that exploits the previously unknown vulnerability found in the Adobe Photoshop Express application. We showed that the malicious application, which is not granted any permissions, can access contacts on the phone with just a few lines of code.
\n
\nIn the second part of this thesis, we explore the use of heap analysis to extract software birthmarks. There are techniques like code obfuscation and watermarking which can make the source code of a program difficult to understand by humans and prove the ownership of the program. However, code obfuscation cannot avoid the source code being copied and a watermark can be defaced. A birthmark is a group of unique characteristics a program possesses that can be used to identify the program. We propose two novel dynamic birthmark systems based on the run-time heap. A dynamic birthmark is one that is extracted when the program is executing. Since it is based on the run-time behavior of the program, semantics-preserving transformations of the code like obfuscation cannot defeat dynamic birthmarks. In this regard, dynamic birthmarks are more robust compared with static birthmarks.
\n
\nTo the best of our knowledge, these are the first birthmark systems using heap analysis as the underlying technique. The basic idea is to take snapshots of the heap while the program is running. From the snapshots, heap graphs are constructed to model the referencing structure between objects. After going through some filtering and referencing processes, they become the birthmarks. The two birthmark systems have been devised to extract birthmarks for Java programs and JavaScript programs respectively. While the underlying ideas of the two birthmark systems are similar, the differences in nature of the two programming languages led to different implementation designs.

Code clones represent a stumbling blocking the way of having a more readable, maintainable and less complicated source codes, free of bugs and errors. Many studies had been proposed for detecting and omitting the four types of cloned codes based on pattern matching, syntax parsing, tree parsing and refactoring which is the most commonly used technique to remove the code clones from software, while maintaining its original behavior. In this paper, we propose an automated refactoring technique and its correspondence algorithm to omit code clones of type 1 and type 2. The proposed technique performance was tested and evaluated using four open source Java projects JFreeChart, JRuby, JCommon and Apache ant. The performance of the source codes was indicated based on number of metrics as the lines of code, number of blank lines, method’s count and cyclomatic complexity before and after applying the proposed technique. The experimentation results indicated that the proposed technique had showed superiority over the state-of-the-art through omitting the cloned codes with the possibility of maintaining the stability and correctness of behavior of the source codes under consideration.

K-scope is a source code analysis tool with a graphical user interface for the performance tuning of Fortran programs. With K-scope, developers are able to visually understand the structures of their Fortran programs and estimate their performance. However, the original version of K-scope has two problems. First, it lacks the ability to integrate the results of source code analysis with performance profiling data. Second, it requires developers to install XcalableMP because K-scope utilizes the front-end of the XcalableMP compiler. However it is difficult to set up the XcalableMP environment because this requires installing and configuring several libraries and applications. A binary package of XcalableMP is only available for major Linux distributions, and developers thus have a hard time installing XcalableMP on other environments, e.g., Windows. In order to address these two problems, we extend K-scope with two mechanisms. The first visualizes performance profiling data and the second offloads the parsing of Fortran programs to a remote server. More specifically, the visualization mechanism enables users to readily identify performance bottlenecks in their programs by mapping performance profiling data to each line of the source code. With the offloading mechanism, developers no longer need to install XcalableMP. Instead, they can connect K-scope to a remote server on which XcalableMP is installed, and which generates the intermediate code used for analysis. For this purpose, we develop a tool named SSHconnect. To verify the effectiveness of our extended K-scope, we analyze the Nonhydrostatic Icosahedral Atmospheric Model (NICAM) code, an application for global climate simulation that consists of about 300,000 lines of Fortran code. We found that K-scope successfully identified performance bottlenecks in the NICAM code and translated the source code for several applications using its remote parsing mechanism.

This paper is a continuation of our previous work on solving source code authorship identification problems. The analysis of heterogeneous source code is a relevant issue for copyright protection in commercial software development. This is related to the specificity of development processes and the usage of collaborative development tools (version control systems). As a result, there are source codes written according to different programming standards by a team of programmers with different skill levels. Another application field is information security—in particular, identifying the author of computer viruses. We apply our technique based on a hybrid of Inception-v1 and Bidirectional Gated Recurrent Units architectures on heterogeneous source codes and consider the most common commercial development complex cases that negatively affect the authorship identification process. The paper is devoted to the possibilities and limitations of the author’s technique in various complex cases. For situations where a programmer was proficient in two programming languages, the average accuracy was 87%; for proficiency in three or more—76%. For the artificially generated source code case, the average accuracy was 81.5%. Finally, the average accuracy for source codes generated from commits was 84%. The comparison with state-of-the-art approaches showed that the proposed method has no full-functionality analogs covering actual practical cases.

A web-based Java programming learning assistant system (JPLAS) has been developed for novice students to study Java programming by themselves while enhancing code reading and code writing skills. One type of the implemented exercise problem is code writing problem (CWP), which asks students to create a source code that can pass the given test code. The correctness of this answer code is validated by running them on JUnit. In previous works, a Python-based answer code validation program was implemented to assist teachers. It automatically verifies the source codes from all the students for one test code, and reports the number of passed test cases by each code in the CSV file. While this program plays a crucial role in checking the correctness of code behaviors, it cannot detect code plagiarism that can often happen in programming courses. In this paper, we implement a code plagiarism checking function in the answer code validation program, and present its application results to a Java programming course at Okayama University, Japan. This function first removes the whitespace characters and the comments using the regular expressions. Next, it calculates the Levenshtein distance and similarity score for each pair of source codes from different students in the class. If the score is larger than a given threshold, they are regarded as plagiarism. Finally, it outputs the scores as a CSV file with the student IDs. For evaluations, we applied the proposed function to a total of 877 source codes for 45 CWP assignments submitted from 9 to 39 students and analyzed the results. It was found that (1) CWP assignments asking for shorter source codes generate higher scores than those for longer codes due to the use of test codes, (2) proper thresholds are different by assignments, and (3) some students often copied source codes from certain students.

Variability in Pattern of Mutational Signatures in Multiple Myeloma As a Function of Racial Origin

In this paper, we study two problems of providing reliable data transmission and developing aggregation techniques for correlated data in wireless sensor networks. A system with forward error correction (FEC) can provide an objective reliability while using less transmission power than a system without FEC. Because of the additional parity bits and encoding/decoding energy consumptions, we study the effect of FEC on energy efficiency. We propose to use LDPC codes for FEC. We show that wireless sensor networks using LDPC codes are almost 45% more energy efficient than those that use BCH codes, which were shown to be 15% more energy efficient than the best performing convolutional codes. Then we study the problem of providing aggregation for two and three correlated nodes in wireless sensor networks. We propose to use LDPC codes in wireless sensor networks for source and channel coding to obtain a two-fold energy savings. For two correlated nodes, we study both distributed source coding and joint source-channel coding. While distributed source coding using LDPC codes was studied before, joint source-channel coding using LDPC codes is introduced for the first time. The difference between our work in distributed source coding using LDPC codes and the previous work lies in the LDPC code design procedure. The simulation results show that our proposed design criteria improves the performance of the source coding. The convergence of the non-uniform LDPC code of our design technique is almost 60% closer to the Slepian-Wolf limit. For three correlated nodes, we study distributed source coding using LDPC codes. We simplified the problem of design procedure to randomly punctured LDPC codes. This is a new approach for designing LDPC codes and the simulation results for code of length 1000 shows that the convergence of the LDPC code is achieved at compression rate 0.3174 which is only 0.08 away from the Slepian-Wolf limit.

While recent neural sequence-to-sequence models have greatly improved the quality of speech synthesis, there has not been a system capable of fast training, fast inference and high-quality audio synthesis at the same time. We propose a student-teacher network capable of high-quality faster-than-real-time spectrogram synthesis, with low requirements on computational resources and fast training time. We show that self-attention layers are not necessary for generation of high quality audio. We utilize simple convolutional blocks with residual connections in both student and teacher networks and use only a single attention layer in the teacher model. Coupled with a MelGAN vocoder, our model's voice quality was rated significantly higher than Tacotron 2. Our model can be efficiently trained on a single GPU and can run in real time even on a CPU. We provide both our source code and audio samples in our GitHub repository.