Source Code Analysis Research Articles

The need for software specific natural language techniques

For over two decades, software engineering (SE) researchers have been importing tools and techniques from information retrieval (IR). Initial results have been quite positive. For example, when applied to problems such as feature location or re-establishing traceability links, IR techniques work well on their own, and often even better in combination with more traditional source code analysis techniques such as static and dynamic analysis. However, recently there has been growing awareness among SE researchers that IR tools and techniques are designed to work under different assumptions than those that hold for a software system. Thus it may be beneficial to consider IR-inspired tools and techniques that are specifically designed to work with software. One aim of this work is to provide quantitative empirical evidence in support of this observation. To do so a new technique is introduced that captures the level of difficulty found in an information need, the true, often latent, information that a searcher desires to know. The new technique is used to compare two domains: Natural Language (NL) and SE. Analysis of the data leads to three significant findings. First, the variation in the distribution of difficulty of the SE information needs differs from that of the NL information needs; second, collection age plays a role in the differences between the NL collections; and finally, the retrieval model used has little impact on the results.

Why does the orientation change mess up my Android application? From GUI failures to code faults

SummaryThis paper investigates the failures exposed in mobile apps by the mobile‐specific event of changing the screen orientation. We focus on GUI failures resulting in unexpected GUI states that should be avoided to improve the apps quality and to ensure better user experience. We propose a classification framework that distinguishes 3 main classes of GUI failures due to orientation changes and exploit it in 2 studies that investigate the impact of such failures in Android apps. The studies involved both open‐source and apps from Google Play that were specifically tested exposing them to orientation change events. The results showed that more than 88% of these apps were affected by GUI failures, some classes of GUI failures were more common than others, and some GUI objects were more frequently involved. The app source code analysis allowed us to identify 6 classes of common faults causing specific GUI failures.

Query compilation in PostgreSQL by specialization of the DBMS source code

This paper describes the development of a query compiler for the PostgreSQL DBMS based on automatic code specialization methods; these methods allow one to avoid the development and support difficulties typical for classical query compilers by dividing the compiler development problem into two independent subproblems: reduction of overhead costs and implementation of algorithmic improvements. We assert that this decomposition facilitates the solution of both the subproblems: the cost reduction can be automated, while the algorithmic improvements can be implemented in the interpreter in the DBMS implementation language. This paper presents methods for online and offline specialization, considers specifics of specialization and binding-time analysis of the PostgreSQL source code, and describes the transition to a push model of execution.

Detecting the Behavior of Design Patterns through Model Checking and Dynamic Analysis

We present a method and tool (ePAD) for the detection of design pattern instances in source code. The approach combines static analysis, based on visual language parsing and model checking, and dynamic analysis, based on source code instrumentation. Visual language parsing and static source code analysis identify candidate instances satisfying the structural properties of design patterns. Successively, model checking statically verifies the behavioral aspects of the candidates recovered in the previous phase. We encode the sequence of messages characterizing the correct behaviour of a pattern as Linear Temporal Logic (LTL) formulae and the sequence diagram representing the possible interaction traces among the objects involved in the candidates as Promela specifications. The model checker SPIN verifies that candidates satisfy the LTL formulae. Dynamic analysis is then performed on the obtained candidates by instrumenting the source code and monitoring those instances at runtime through the execution of test cases automatically generated using a search-based approach. The effectiveness of ePAD has been evaluated by detecting instances of 12 creational and behavioral patterns from six publicly available systems. The results reveal that ePAD outperforms other approaches by recovering more actual instances. Furthermore, on average ePAD achieves better results in terms of correctness and completeness.

Source Code and Formal Analysis: A Reading of Passage

Analysis of the source code of video games is not an integrated part of the formal analysis. Rather, few scholars have investigated how an analysis of the source code can inform a hermeneutic reading of the game. In this paper I will present a reading of the source code of Passage (Rohrer, 2007), argue for why a traditional focus on authorial intention is unnecessary when investigating the symbolism and metaphors of a game, and illustrate how source code analysis can inform the formal analysis of the executed game. Finally, I shall discuss how the source code relates to the game as a ‘work’, and how it can be used for studies of symbolism and metaphors. Thus, I will conclude that it is indeed a valuable method for game studies, although further studies should expand on the textual relation between executed game and source code.

ICT 환경에서 프로그램보호를 위한 소스코드 분석 사례 연구

ICT 환경에서 프로그램보호를 위한 소스코드 분석 사례 연구

On Accelerating Source Code Analysis at Massive Scale

Encouraged by the success of data-driven software engineering (SE) techniques that have found numerous applications e.g., in defect prediction, specification inference, the demand for mining and analyzing source code repositories at scale has significantly increased. However, analyzing source code at scale remains expensive to the extent that data-driven solutions to certain SE problems are beyond our reach today. Extant techniques have focused on leveraging distributed computing to solve this problem, but with a concomitant increase in computational resource needs. This work proposes a technique that reduces the amount of computation performed by the ultra-large-scale source code mining task, especially those that make use of control and data flow analyses. Our key idea is to analyze the mining task to identify and remove the irrelevant portions of the source code, prior to running the mining task. We show a realization of our insight for mining and analyzing massive collections of control flow graphs of source codes. Our evaluation using 16 classical control-/data-flow analyses that are typical components of mining tasks and 7 Million CFGs shows that our technique can achieve on average a 40 percent reduction in the task computation time. Our case studies demonstrates the applicability of our technique to massive scale source code mining tasks.

Automatically classifying source code using tree-based approaches

Analyzing source code to solve software engineering problems such as fault prediction, cost, and effort estimation always receives attention of researchers as well as companies. The traditional approaches are based on machine learning, and software metrics obtained by computing standard measures of software projects. However, these methods have faced many challenges due to limitations of using software metrics which were not enough to capture the complexity of programs.To overcome the limitations, this paper aims to solve software engineering problems by exploring information of programs' abstract syntax trees (ASTs) instead of software metrics. We propose two combination models between a tree-based convolutional neural network (TBCNN) and k-Nearest Neighbors (kNN), support vector machines (SVMs) to exploit both structural and semantic ASTs' information. In addition, to deal with high-dimensional data of ASTs, we present several pruning tree techniques which not only reduce the complexity of data but also enhance the performance of classifiers in terms of computational time and accuracy.We survey many machine learning algorithms on different types of program representations including software metrics, sequences, and tree structures. The approaches are evaluated based on classifying 52000 programs written in C language into 104 target labels. The experiments show that the tree-based classifiers dramatically achieve high performance in comparison with those of metrics-based or sequences-based; and two proposed models TBCNN + SVM and TBCNN + kNN rank as the top and the second classifiers. Pruning redundant AST branches leads to not only a substantial reduction in execution time but also an increase in accuracy.

Source code analysis and manipulation

Source code analysis and manipulation

VTrace-A Tool for Visualizing Traceability Links among Software Artefacts for an Evolving System

Traceability Management plays a key role in tracing the life of a requirement through all the specifications produced during the development phase of a software project. A lack of traceability information not only hinders the understanding of the system but also will prove to be a bottleneck in the future maintenance of the system. Projects that maintain traceability information during the development stages somehow fail to upgrade their artefacts or maintain traceability among the different versions of the artefacts that are produced during the maintenance phase. As a result the software artefacts lose the trustworthiness and engineers mostly work from the source code for impact analysis. The goal of our research is on understanding the impact of visualizing traceability links on change management tasks for an evolving system. As part of our research we have implemented a Traceability Visualization Tool-VTrace that manages software artefacts and also enables the visualization of traceability links. The results of our controlled experiment show that subjects who used the tool were more accurate and faster on change management tasks than subjects that didn’t use the tool.

A Framework and Implementation for Detecting Source Code Faults in COBOL Code

Common Business-Oriented Language (COBOL) is a nearly 60-year-old programming language that resides on the majority of mainframe computers that service key industries, such as the banking, healthcare, and insurance industries. Due to its important function in running much of the digital economy, at least one major bank is turning its attention to detecting aberrations in COBOL code. In this paper, we discuss the strengths and weaknesses of the current COBOL/mainframe environment. This brings to bear the critical role COBOL plays in mainframe information technology infrastructure and the risks associated with running decades-old code. We explore various source code analysis techniques and develop a framework for applying one technique to analyze COBOL code for source code faults (SCFs). We implement the framework, test our tool in a real-world banking environment, and are able to detect SCFs in the bank’s COBOL code. According to the internal audit team at the bank, there are many benefits to using the tool. We conclude the paper with a proposal for a modified framework that would allow for more advanced predictive analytics over time.

크로스커팅 개념을 이용한 시스템 최적화 기법

시스템 최적화는 소스코드의 변경 없이 중복된 모듈을 추출하고, 추출된 모듈의 재사용을 위하여 프로그램의 구조를 변경하는 기법이다. 구조지향 개발과 객체지향 개발은 크로스커팅 영역의 모듈화에는 효율적이나 크로스커팅 개념을 모듈화 할 수 없다. 기존 시스템에서 크로스커팅 개념을 적용하기 위해, 각 시스템 내에 분산되어 있는 시스템 최적화 대상 모듈을 크로스커팅 영역으로 추출하는 기술이 필요하다. 본 논문에서는 개발이 완료된 시스템에서 중복 모듈을 추출하기 위한 방법을 제안한다. 제안하는 방법은 소스코드 분석을 통해 데이터 의존관계와 제어 의존관계를 분석하여 중복되는 요소를 추출한다. 추출된 중복된 요소는 시스템 최적화를 위하여 프로그램 의존 관계 분석에 사용될 수 있다. 중복된 의존관계 분석 결과는 제어 흐름 그래프로 변환되며, 이를 활용하여 최소 크로스커팅 모듈을 생성할 수 있다. 의존 관계 분석을 통해 추출된 요소는 크로스커팅 영역 모듈로 설정함으로써 시스템 내 중복된 코드를 최소화 할 수 있는 시스템 최적화 방법을 제시한다. The system optimization is a technique that changes the structure of the program in order to extract the duplicated modules without changing the source code, reuse of the extracted module. Structure-oriented development and object-oriented development are efficient at crosscutting concern modular, however can't be modular of crosscutting concept. To apply the crosscutting concept in an existing system, there is a need to a extracting technique for distributed system optimization module within the system. This paper proposes a method for extracting the redundant modules in the completed system. The proposed method extracts elements that overlap over a source code analysis to analyze the data dependency and control dependency. The extracted redundant element is used to program dependency analysis for the system optimization. Duplicated dependency analysis result is converted into a control flow graph, it is possible to produce a minimum crosscutting module. The element extracted by dependency analysis proposes a system optimization method which minimizes the duplicated code within system by setting the crosscutting concern module.

Program analysis with risk-based classification of dynamic invariants for logical error detection

The logical errors in programs causing deviations from the intended functionality cannot be detected by automated source code analysis, which mainly focuses on known defects and code vulnerabilities. To this end, we introduce a combination of analysis techniques implemented in a proof-of-concept prototype called PLATO. First, a set of dynamic invariants is inferred from the source code that represents the program's logic. The code is instrumented with assertions from the invariants, which are subsequently valuated through the program's symbolic execution. The findings are ranked using a fuzzy logic system with two scales characterizing their impact: (i) a Severity scale for the execution paths' characteristics and their Information Gain, (ii) a Reliability scale based on the measured Computational Density. Real, as well as synthetic applications with at least four different types of logical errors were analyzed. The method's effectiveness was assessed based on a dataset from 25 experiments. Albeit not without restrictions, the proposed automated analysis seems able to detect a wide variety of logical errors, while it filters out the false positives.

Machine learning aided Android malware classification

The widespread adoption of Android devices and their capability to access significant private and confidential information have resulted in these devices being targeted by malware developers. Existing Android malware analysis techniques can be broadly categorized into static and dynamic analysis. In this paper, we present two machine learning aided approaches for static analysis of Android malware. The first approach is based on permissions and the other is based on source code analysis utilizing a bag-of-words representation model. Our permission-based model is computationally inexpensive, and is implemented as the feature of OWASP Seraphimdroid Android app that can be obtained from Google Play Store. Our evaluations of both approaches indicate an F-score of 95.1% and F-measure of 89% for the source code-based classification and permission-based classification models, respectively.

Multilingual Source Code Analysis: A Systematic Literature Review

Contemporary software applications are developed using cross-language artifacts, which are interdependent with each other. The source code analysis of these applications requires the extraction and examination of artifacts, which are build using multiple programming languages along with their dependencies. A large number of studies presented on multilingual source code analysis and its applications in the last one and half decade. The objective of this systematic literature review (SLR) is to summarize state of the art and prominent areas for future research. This SLR is based on different techniques, tools, and methodologies to analyze multilingual source code applications. We finalized 56 multi-discipline published papers relevant to multilingual source code analysis and its applications out of 3820 papers, filtered through multi-stage search criterion. Based on our findings, we highlight research gaps and challenges in the field of multilingual applications. The research findings are presented in the form of research problems, research contributions, challenges, and future prospects. We identified 46 research issues and requirements for analyzing multilingual applications and grouped them in 13 different software engineering domains. We examined the research contributions and mapped them with individual research problems. We presented the research contributions in the form of tools techniques and approaches that are presented in the form of research models, platforms, frameworks, prototype models, and case studies. Every research has its limitations or prospects for future research. We highlighted the limitations and future perspectives and grouped them in various software engineering domains. Most of the research trends and potential research areas are identified in static source code analysis, program comprehension, refactoring, reverse engineering, detection, and traceability of cross-language links, code coverage, security analysis, cross-language parsing, and abstraction of source code models.

Current Trends in Source Code Analysis, Plagiarism Detection and Issues of Analysis Big Datasets

In this work, we analyze the state of the art in source code analysis area with a focus on plagiarism detection and provide a proposal for a future work in this area. Detection of plagiarism combines the detection of clones and methods for determining similarity. Nowadays, there are several approaches that can be divided into three levels. The first one is text based and uses plain text as an input. The second level is token based. The top level is model based and uses models to represent source code. These advanced algorithms (token and model based) can’t work with large datasets. We believe the future belongs to the algorithms that will be able to handle large amount of source code. These algorithms should use one of model-based representations. They can be used for formation of large-scale anti-plagiarism systems. They can be used also in the area of source code optimization.

Detection of J2EE Patterns based on Customizable Features

Design patterns support extraction of design information for better program understanding, reusability and reengineering. With the advent of contemporary applications, the extraction of design information has become quite complex and challenging. These applications are multilingual in nature i.e. their design information is spread across various language components that are interlinked with each other. At present, no approach is available that is capable to extract design information of multilingual applications by using design patterns. This paper lays foundation for the analysis of multilingual source code for the detection of J2EE Patterns. J2EE Patterns provide design solutions for effective enterprise applications. A novel approach is presented for the detection of J2EE Patterns from multilingual source code of J2EE applications. For this purpose, customizable and reusable feature types are presented as definitions of J2EE Patterns catalogue. A prototype implementation is evaluated on a corpus that contains the repository of multilingual source code of J2EE Patterns. Additionally, the tool is tested on open source applications. The accuracy of the tool is validated by successfully recognizing J2EE Patterns from the multilingual source code. The results demonstrate the significance of customizable definitions of J2EE Pattern’s catalogue and capability of prototype.

Agent-Based Modelling of Social-Ecological Systems: Achievements, Challenges, and a Way Forward

Understanding social-ecological systems (SES) is crucial to supporting the sustainable management of resources. Agent-based modelling is a valuable tool to achieve this because it can represent the behaviour and interactions of organisms, human actors and institutions. Agent-based models (ABMs) have therefore already been widely used to study SES. However, ABMs of SES are by their very nature complex. They are therefore difficult to parameterize and analyse, which can limit their usefulness. It is time to critically reflect upon the current state-of-the-art to evaluate to what degree the potential of agent-based modelling for gaining general insights and supporting specific decision-making has already been utilized. We reviewed achievements and challenges by building upon developments in good modelling practice in the field of ecological modelling with its longer history. As a reference, we used the TRACE framework, which encompasses elements of model development, testing and analysis. We firstly reviewed achievements and challenges with regard to the elements of the TRACE framework addressed in reviews and method papers of social-ecological ABMs. Secondly, in a mini-review, we evaluated whether and to what degree the elements of the TRACE framework were addressed in publications on specific ABMs. We identified substantial gaps with regard to (1) communicating whether the models represented real systems well enough for their intended purpose and (2) analysing the models in a systematic and transparent way so that model output is not only observed but also understood. To fill these gaps, a joint effort of the modelling community is needed to foster the advancement and use of strategies such as participatory approaches, standard protocols for communication, sharing of source code, and tools and strategies for model design and analysis. Throughout our analyses, we provide specific recommendations and references for improving the state-of-the-art. We thereby hope to contribute to the establishment of a new advanced culture of agent-based modelling of SES that will allow us to better develop general theory and practical solutions.

Software Evolution-based Aspect Mining: A Novel Approach

Aspect mining is the search of candidate aspects in existing systems and isolates them from the system into separately described aspects. The cross-cutting concerns are candidate aspects. The aspect-mining techniques that have been proposed in literature perform static or dynamic analysis of source code to identify the candidate aspect. The data-mining techniques such as clustering and association rule mining have also been applied on execution traces or in combination with source code metrics. History-based aspect mining is based on mining methods calls that have been inserted during the evolution of software. It assumes that cross-cutting concerns do not exist from beginning but are introduced over time. However, the cross-cutting concerns may exist in the system from the beginning. We have been investigating an approach to mine frequent patterns from the version histories of legacy system to recommend candidate aspects. A novel approach, Software Evolution based Aspect Mining (SEAM) software evolution-based aspect mining for mining candidate aspects from version history files is proposed in the paper. In the proposed approach, while mining aspects from legacy code, the source files that have been changed frequently and set of source code files that have been changed together frequently during the evolution of system are mined. Mined frequent change patterns are then visualised for structural relationship. On the basis of the structural relationship between the files, candidate aspects are recommended for the pattern. Two types of candidate aspects are reported – simple candidate aspects and complex candidate aspects. In this paper, algorithms are proposed for mining simple and complex candidate aspects. Overall, the paper presents a novel approach to accurately identify aspects based on co-changing files existing in version history. The identification of aspects not only gives the opportunity to rewrite the code but also has potential to enhance maintainability and reliability of system.

Automatic Calculation of Process Metrics and their Bug Prediction Capabilities

Identifying fault-prone code parts is useful for the developers to help reduce the time required for locating bugs. It is usually done by characterizing the already known bugs with certain kinds of metrics and building a predictive model from the data. For the characterization of bugs, software product and process metrics are the most popular ones. The calculation of product metrics is supported by many free and commercial software products. However, tools that are capable of computing process metrics are quite rare. In this study, we present a method of computing software process metrics in a graph database. We describe the schema of the database created and we present a way to readily get the process metrics from it. With this technique, process metrics can be calculated at the file, class and method levels. We used GitHub as the source of the change history and we selected 5 open-source Java projects for processing. To retrieve positional information about the classes and methods, we used SourceMeter, a static source code analyzer tool. We used Neo4j as the graph database engine, and its query language - cypher - to get the process metrics. We published the tools we created as open-source projects on GitHub. To demonstrate the utility of our tools, we selected 25 release versions of the 5 Java projects and calculated the process metrics for all of the source code elements (files, classes and methods) in these versions. Using our previous published bug database, we built bug databases for the selected projects that contain the computed process metrics and the corresponding bug numbers for files and classes. (We published these databases as an online appendix.) Then we applied 13 machine learning algorithms on the database we created to find out if it is feasible for bug prediction purposes. We achieved F-measure values on average of around 0.7 at the class level, and slightly better values of between 0.7 and 0.75 at the file level. The best performing algorithm was the RandomForest method for both cases.