JavaPDG: A New Platform for Program Dependence Analysis

Program slicing is a technique to decompose programs depending on control flow and data flow amongst several lines of code in a program. Conditioned slicing is a generalization of static slicing and dynamic slicing. A variable, the desired program point, and a condition of interest form a slicing criterion for conditioned slicing. This paper proposes an approach to calculate conditioned slices for programs containing multiple procedures. The approach is termed Node-Marking Conditioned Slicing (NMCS) algorithm. In this approach, first and foremost step is to build an intermediate symbolization of a given program code and the next step is to develop an algorithm for finding out conditioned slices. The dependence graph, termed System Dependence Graph (SDG), is used to symbolize intermediate presentation. After constructing SDG, the NMCS algorithm chooses nodes that satisfy a given condition by the process of marking and unmarking. The algorithm also finds out conditioned slices for every variable at every statement during the process. NMCS algorithm employs a stack to save call context of a method. Few edges in SDG are labeled to identify the statement that calls a method. The proposed algorithm is implemented, and its performance is tested with several case study projects.

Graph models have been useful abstraction for examining the programmer's perspective of the static structure of imperative programs. A number of Graph models referring to control flow and data dependencies have appeared in the literature. The primary objective of this research is to develop a more general graph-theoretic model for describing programs written in arbitrary imperative languages and to compute a structural measure based on this abstraction. The proposed model is a synthesis of the control flow graph and the data dependency graph. This new unified abstraction, called the Generalized Program Graph (GPG), is structurally equivalent to the string from of a program. However, because of its graph structure, the new model is better suited for structural analysis of a program than original string form.

A dynamic slicing algorithm is proposed in this paper along with its implementation which is dynamic for concurrent Component-oriented programs carrying multiple threads. As a part of representing the concurrent COP (CCOP) effectively, an intermediate graph is developed called Concurrent Component Dependency Graph (CCmDG). The system dependence graph (SDG) for individual components and interfaces are integrated to represent the above intermediate graph. It also consists of some new dependence edges which have been triggered for connecting the individual dependence graph of each component with the interface. Based on the graph created for the CCOP, a dynamic slicing algorithm is proposed, which sets the resultant by making the executed nodes marked during run time in Concurrent Components Dynamic Slicing (CCmDS) appropriately. For checking the competence of our algorithm, five case studies have been considered and also compared with an existing technique. From the study, we found that our algorithm results in smaller and precise size slice compared to the existing algorithm in less time.

Software maintenance is one of the most expensive phases of software development and understanding a program is one of the most important tasks of software maintenance. Before making the change to the program, software engineers need to find the location, or locations, where the changes will be made, they need to understand the program. Real applications are huge, sometimes old, were written by other person and it is difficult to find the location of the instructions related to a specific problem domain concept. There are various techniques to find these locations minimizing the time spent, but this stage of software development continues to be one of the most expensive and longer. The concept location is a crucial task for program understanding. This paper presents a project whose main objective is to explore and combine two Program Comprehension techniques: visualization of the system dependency graph and concept location over source code comments. The idea is to merge both features in order to perform concept location in system dependency graphs. More than locate a set of hot instructions (based on the associated comments) it will allow to detect the other instructions (the whole method).

Conventional software testing is time consuming and expensive task. The techniques for automated test case generation of software is very important as it can reduce the time and cost of this process. Search based test data generation received lot of attention in last two decades for solving this problem. The well known metaheuristic search technique genetic algorithm is used to obtain a specific coverage in software testing. This technique automatically generates test data in order to obtain branch coverage in software testing. The authors first use a technique to identify the unique paths from a control flow graph and then apply genetic algorithm for test case generation. This paper defines the basic research issues of genetic algorithm like chromosome, fitness function, crossing over, mutation in this problem domain and uses a case study to illustrate it.

Many data-driven software engineering tasks such as discovering programming patterns, mining API specifications, etc., perform source code analysis over control flow graphs (CFGs) at scale. Analyzing millions of CFGs can be expensive and performance of the analysis heavily depends on the underlying CFG traversal strategy. State-of-the-art analysis frameworks use a fixed traversal strategy. We argue that a single traversal strategy does not fit all kinds of analyses and CFGs and propose bespoke control flow analysis (BCFA). Given a control flow analysis (CFA) and a large number of CFGs, BCFA selects the most efficient traversal strategy for each CFG. BCFA extracts a set of properties of the CFA by analyzing the code of the CFA and combines it with properties of the CFG, such as branching factor and cyclicity, for selecting the optimal traversal strategy. We have implemented BCFA in Boa, and evaluated BCFA using a set of representative static analyses that mainly involve traversing CFGs and two large datasets containing 287 thousand and 162 million CFGs. Our results show that BCFA can speedup the large scale analyses by 1%-28%. Further, BCFA has low overheads; less than 0.2%, and low misprediction rate; less than 0.01%.

Impact analysis (IA) is a critical software maintenance task that identifies the effects of a given set of code changes on a larger software project with the intention of avoiding potential adverse effects. IA is a cognitively challenging task that involves reasoning about the abstract relationships between various code constructs. Given its difficulty, researchers have worked to automate IA with approaches that primarily use coupling metrics as a measure of the “connectedness” of different parts of a software project. Many of these coupling metrics rely on static, dynamic, or evolutionary information and are based on heuristics that tend to be brittle, require expensive execution analysis, or large histories of co-changes to accurately estimate impact sets. In this paper, we introduce a novel IA approach, called Athena , that combines a software system’s dependence graph information with a conceptual coupling approach that uses advances in deep representation learning for code without the need for change histories and execution information. Previous IA benchmarks are small, containing less than ten software projects, and suffer from tangled commits, making it difficult to measure accurate results. Therefore, we constructed a large-scale IA benchmark, from 25 open-source software projects, that utilizes fine-grained commit information from bug fixes. On this new benchmark, our best performing approach configuration achieves an mRR, mAP, and HIT@10 score of 60.32%, 35.19%, and 81.48%, respectively. Through various ablations and qualitative analyses, we show that Athena ’s novel combination of program dependence graphs and conceptual coupling information leads it to outperform a simpler baseline by 10.34%, 9.55%, and 11.68% with statistical significance.

Development and validation of a high throughput direct radioimmunoassay for the quantitative determination of serum and plasma melatonin (N-acetyl-5-methoxytryptamine) in mice

This paper describes a set of tools for the reengineering of computer-based systems, in particular software. The toolset is based on an abstract intermediate representation (IR) which incorporates the system software architecture at five level of granularity: program level, task level, package/object instance level, subprogram level and statement level. The toolset provides a graphical user interface that allows various views of a software architecture, including call graph, rendezvous graph, call-rendezvous graph, call-data-rendezvous graph, control flow graph and dependence graphs. The information captured by the toolset is useful in software structure, flow and interaction analysis, tasks commonly performed manually during maintenance and reengineering. This information is also helpful for understanding the software design to guide software transformation, and for porting software to distributed platforms.

On the impact of multiple source code representations on software engineering tasks — An empirical study

This paper examines long-standing female work roles in Greek cities through a study of the provincial town of Nafplio from 1920 to 1940. Values restricting women's social interaction are found not to have prohibited a wide range of labor for most Nafpliote women during this period. They did both family maintenance work and work directed toward the extrafamilial economy, something which contrasts with those urban Greek women today who restrict themselves at marriage only to the former. This conclusion indicates the relevance of theories of female marginalization even to cultures with long-standing values restricting women's activities. Recent research on women's roles in various cultural settings has revealed a changeability in them quite deserving of ethnohistorical investigation. Assumptions of long-standing and universal female domesticity have given way to the studied documentation of other patterns. A remarkably widespread historical development has been identified by such efforts: women in many societies have recently witnessed a truncation of their economic activities, rather than the popularly assumed expansion. The range of work they do has narrowed. Certain well-known features of modern Greek gender roles have not encouraged scholars to seek this pattern there, however. The social restrictions long placed on Greek women made it unlikely they had done much variety of work in the past, while the current loosening of such restrictions seemed to indicate an augmentation of female roles on all fronts. Closer scrutiny reveals the situation to be otherwise. Values of social seclusion for urban Green women of the recent past in fact allowed a wider scope of work than that done by certain, seemingly freer, urban women today. This paper presents ethnohistorical data supporting this conclusion and showing a work role reduction to have indeed occurred for a segment of Greek women. 'That this segment are those Greek women most directly involved in industrial capitalism both alerts us where to look for this pattern in other underdeveloped nations and reinforces the general theories universally linking the rise of such economic structures to a contraction of female work roles. Three steps lead to these conclusions: first, a discussion of current thinking on such work role reduction elsewhere and its possible relevance to Greece; second, presentation of ethnohistorical data on a provincial Greek city to demonstrate a wide range of female work in the past; and third, a comparison of this situation to that of certain urban Greek women today who pursue a narrower range.

The software development process often requires the use of tools that the developers did not write themselves, such as a compiler. Additionally, when security researchers perform tasks such as binary analysis and reverse engineering disassembly and decompiler tools may be used which the researchers did not develop themselves. Yet in all of these cases, there is inherent trust placed in the tools that are being used for these tasks without thought to whether or not that trust is valid. In this work, we provide an overview of what has already been done in the realms of verification and establishment of this trust as well as show our contribution to this area. Our approach is taken through an algorithm that allows us to validate or invalidate that trust by comparing the control flow graphs (CFGs) for a piece of source code to the corresponding CFG for the disassembled binary. This is done by putting the source CFG through a series of program functionality preserving transforms that implement different control structure compiler optimizations. Then we are able to make use of a graph isomorphism algorithm to determine whether or not the two CFGs are isomorphic and determine if the trust is valid. We evaluate the effectiveness of this algorithm against the XINU codebase and report our results.

Software testing is the process of validating and verifying the computer program, application or product works according to its requirements. Computers have become an integral part of today’s society in all the aspects; therefore, it is important that there exist no errors that could compromise safety, security or even financial investment. This chapter, focus on basis path testing as a part of white-box testing to provide code with a level of test coverage by generating all the independent paths for the given code by using its control flow graph. These paths are generated by applying a hybrid algorithm of existing Cuckoo Search Algorithm and Bat Algorithm. The main focus of this chapter is designing of this hybrid algorithm in which basic egg-laying property of cuckoo and echolocation and loudness property of bat is made use of.

Software Testing is one of the integral parts of software development lifecycle. Exhaustive testing on software is impossible to achieve as the testing is a continuous process. Using this as a constraint, software testing is performed in a way that requires reducing the testing effort but should provide high quality software that can yield comparable results. To accomplish this optimized testing, a software test case optimization technique based on artificial bee colony algorithm is proposed here. Based on intelligent behavior of honey bee, this method generates optimal number of test cases to be executed on software under test (SUT). This approach is qualified by self-organization, robustness and focuses on generation of paths derived from cyclomatic complexity. The resulting solution guarantees full path coverage.KeywordsSoftware TestingABC (Artificial Bee Colony Optimization)Test-CaseAgentsPath-Coverageoptimal pathcyclomatic complexityCFG (Control Flow Graph)test data

Bug localization plays an important role in software maintenance. Traditional works treat the source code from the lexical perspective, while some recent researches indicate that exploiting the program structure is beneficial for improving bug localization. Control flow graph (CFG) is a widely used graph representation, which essentially represents the program structure. Although using graph neural network for feature learning is a straightforward way and has been proven effective in various software mining problems, this approach is inappropriate since adjacent nodes in the CFG could be totally unrelated in semantics. On the other hand, previous statements may affect the semantics of subsequent statements along the execution path, which we call the flowing nature of control flow graph. In this paper, we claim that the flowing nature should be explicitly considered and propose a novel model named cFlow for bug localization, which employs a particular designed flow-based GRU for feature learning from the CFG. The flow-based GRU exploits the program structure represented by the CFG to transmit the semantics of statements along the execution path, which reflects the flowing nature. Experimental results on widely-used real-world software projects show that cFlow significantly outperforms the state-of-the-art bug localization methods, indicating that exploiting the program structure from the CFG with respect to the flowing nature is beneficial for improving bug localization.