The Java system dependence graph

The Program Dependence Graph was introduced by Ottenstein and Ottenstein in 1984 [14]. It was suggested to be a suitable internal program representation for monolithic programs, for the purpose of carrying out certain software engineering operations such as slicing and the computation of program metrics. Since then, Horwitz et al. have introduced the multi-procedural equivalent System Dependence Graph [9]. Many authors have proposed object-oriented dependence graph construction approaches [11, 10, 20, 12]. Every approach provides its own benefits, some of which are language specific. This paper is based on Java and combines the most important benefits from a range of approaches. The result is a Java System Dependence Graph, which summarises the key benefits offered by different approaches and adapts them (if necessary) to the Java language

Pembuatan Kakas Pendeteksi Unused Method Pada Kode Program PHP Dengan Framework CodeIgniter Menggunakan Call Graph

Proses evolusi dan perawatan dari sebuah sistem merupakan proses yang sangat penting dalam rekayasa perangkat lunak tidak terkecuali pada aplikasi web. Pada proses ini kebanyakan pengembang tidak lagi berpatokan pada rancangan sistem. Hal ini menyebabkan munculnya unused method. Bagian-bagian program ini tidak lagi terpakai namun masih berada dalam sistem. Keadaan ini meningkatkan kompleksitas dan mengurangi tingkat understandability sistem. Guna mendeteksi adanya unused method pada progam diperlukan teknik untuk melakukan code analysis. Teknik static analysis yang digunakan memanfaatkan call graph yang dibangun dari kode program untuk mengetahui adanya unused method. Call graph dibangun berdasarkan pemanggilan antar method. Aplikasi ini mendeteksi unused method pada kode program PHP yang dibangun menggunakan framework CodeIgniter. Kode program sebagai inputan diurai kedalam bentuk Abstract Syntax Tree (AST) yang kemudian dimanfaatkan untuk melakukan analisis terhadap kode program. Proses analisis tersebut kemudian menghasilkan sebuah call graph. Dari call graph yang dihasilkan dapat dideteksi method-method mana saja yang tidak berhasil ditelusuri dan tergolong kedalam unused method. Kakas telah diuji coba pada 5 aplikasi PHP dengan hasil rata-rata nilai presisi sistem sebesar 0.749 dan recall sebesar 1

A model of software component interactions using the call graph technique

Interaction information that is related to operations between components is important, especially when the program needs to be modified and maintained. Therefore, the affected components must be identified and matched based on the requirement of the system. This information can be obtained through performing the code review technique, which requires an analyst to search for specific information from the source code, which is a very time consuming process. This research proposed a model for representing software component interactions where this information was automatically extracted from the source code in order to provide an effective display for the software components interaction representation. The objective was achieved through applying a research design methodology, which consists of five phases: awareness of the problem, suggestion, development, evaluation, and conclusion. The development phase was conducted by automatically extracting the components‘ interaction information using appropriate reverse engineering tools and supporting programs that were developed in this research. These tools were used to extract software information, extract the information of component interactions in software programs, and transform this information into the proposed model, which was in the form of a call graph. The produced model was evaluated using a visualization tool and by expert review. The visualization tool was used to display the call graph from a text format into a graphical view. The processed model evaluation was conducted through an expert review technique. The findings from the model evaluation show that the produced model can be used and manipulated to visualize the component interactions. It provides a process that allows a visualization display for analysts to view the interaction of software components in order to comprehend the components integrations that are involved. This information can be manipulated and improved the program comprehension, especially for other software maintenance purposes

Towards a Complete Static Analyser for Java: an Abstract Interpretation Framework and its Implementation

AbstractWe present an abstract interpretation framework for a subset of Java (without concurrency). The framework uses a structural abstract domain whose concretization function is parameterized on a relation between abstract and concrete locations. When structurally incomptatible objects may be referred to by the same variable at a given program point, structural information is discarded and replaced by an approximated information about the objects (our presentation concentrates on type information). Plain structural information allows precise intra-procedural analysis but is quickly lost when returning from a method call. To overcome this limitation, relational structural information is introduced, which enables a precise inter-procedural analysis without resorting to inlining.The paper contains an overview of the work. We describe parts of the standard and abstract semantics; then, we briefly explain the fixpoint algorithms used by our implementation; lastly, we provide experimental results for small programs

Using control flow analysis to improve the effectiveness of incremental mutation testing

Incremental Mutation Testing attempts to make mutation testing less expensive by applying it incrementally to a system as it evolves. This approach fits current trends of iterative software development with the main idea being that by carrying out mutation analysis in frequent bite-sized chunks focused on areas of the code which have changed, one can build confidence in the adequacy of a test suite incrementally. Yet this depends on how precisely one can characterise the effects of a change to a program. The original technique uses a naïve approach whereby changes are characterised only by syntactic changes. In this paper we propose bolstering incremental mutation testing by using control flow analysis to identify semantic repercussions which a syntactic change will have on a system. Our initial results based on two case studies demonstrate that numerous relevant mutants which would have otherwise not been considered using the naïve approach, are now being generated. However, the cost of identifying these mutants is significant when compared to the naïve approach, although it remains advantageous when compared to traditional mutation testing so long as the increment is sufficiently small.peer-reviewe

Efficiency implications of open source commonality and reuse

This paper analyzes the reuse choices made by open source developers and relates them to cost efficiency. We make a distinction between the commonality among applications and the actual reuse of code. The former represents the similarity between the requirements of different applications and, consequently, the functionalities that they provide. The latter represents the actual reuse of code. No application can be maintained for ever. A fundamental reason for the need for periodical replacement of code is the exponential growth of costs with the number of maintenance interventions. Intuitively, this is due to the increasing complexity of software that grows in both size and coupling among different modules. The paper measures commonality, reuse and development costs of 26 open-source projects for a total of 171 application versions. Results show that reuse choices in open-source contexts are not cost efficient. Developers tend to reuse code from the most recent version of applications, even if their requirements are closer to previous versions. Furthermore, the latest version of an application is always the one that has incurred the highest number of maintenance interventions. Accordingly, the development cost per new line of code is found to grow with reuse

Control-Flow Analysis and Representation for Aspect-Oriented Programs

Aspect-oriented programming (AOP) has been proposed as a technique for improving the separation of concerns in software design and implementation. The field of AOP has, so far, focused primarily on problem analysis, lan-guage design, and implementation. Even though the im-portance of program comprehension and software main-tenance is known, it has received little attention in the aspect-oriented paradigm. However, as the software sys-tems coded in AOP languages are accumulated, the devel-opment of techniques and tools to support program compre-hension and software maintenance tasks for aspect-oriented software will become important. In order to understand and maintain aspect-oriented programs, abstract models for representing these programs are needed. In this paper, we present techniques to construct control-flow representa-tions for aspect-oriented programs, and discuss some appli-cations of the representations in a program comprehension and maintenance environment.

Collapsible Tabular Visualization of Aspects in Object Oriented Programming

Due to its implicit invocation nature ofAspect Oriented Programming (AOP), locating a jointpoint for executing aspect is extremely difficult. Hence,it becomes difficult to understand the application’sflow and behavior. Current AOP visualization tools havelimitations such as high dependency on other tools,confusing and excessive use of color to represent aspectsand using an outdated version of AspectJ. In thispaper, we propose a new approach collapsibletabular visualization tool to visualize and represent AOPfeatures to aid the programmers in betterunderstanding AOP applications. We have come outof traditional color-based aspect visualization and developeda web based tool: AspectViz that visualizes the aspects ina simple collapsible table. A questionnaire containingfour different questions related to aspects visualizationwas developed to compare AspectViz with currentvisualization tools. 20 graduate students andprofessional software developers were invited to participatein the test experiment as well as the survey. We havecompared its performance with existing AOPvisualization tools i.e. the AJDT and the AspectMaps andshowed how it outperformed in many cases, which is nocolor confusion, simple tabular visualization of aspects, nodependency on third-party software, easy to understand andthe time it took to find a particular aspect was less etc.Collapsible tabular visualization enhanced the usability andperformance of aspect locating in aspect-orientedprogramming