By Topic

Source Code Analysis and Manipulation, 2005. Fifth IEEE International Workshop on

Date Sept. 30 2005-Oct. 1 2005

Filter Results

Displaying Results 1 - 25 of 28
  • Fifth IEEE International Workshop on Source Code Analysis and Manipulation - Cover

    Page(s): c1
    Save to Project icon | Request Permissions | PDF file iconPDF (383 KB)  
    Freely Available from IEEE
  • Fifth IEEE International Workshop on Source Code Analysis and Manipulation

    Save to Project icon | Request Permissions | PDF file iconPDF (54 KB)  
    Freely Available from IEEE
  • Fifth IEEE International Workshop on Source Code Analysis and Manipulation - Copyright

    Page(s): iv
    Save to Project icon | Request Permissions | PDF file iconPDF (33 KB)  
    Freely Available from IEEE
  • Fifth IEEE International Workshop on Source Code Analysis and Manipulation - Table of contents

    Page(s): v - vii
    Save to Project icon | Request Permissions | PDF file iconPDF (46 KB)  
    Freely Available from IEEE
  • Message from the Chairs

    Page(s): viii
    Save to Project icon | Request Permissions | PDF file iconPDF (27 KB)  
    Freely Available from IEEE
  • Conference organization

    Page(s): ix
    Save to Project icon | Request Permissions | PDF file iconPDF (29 KB)  
    Freely Available from IEEE
  • Program Committee

    Page(s): x
    Save to Project icon | Request Permissions | PDF file iconPDF (28 KB)  
    Freely Available from IEEE
  • list-reviewer

    Page(s): xi - xii
    Save to Project icon | Request Permissions | PDF file iconPDF (17 KB)  
    Freely Available from IEEE
  • Transformations for abstractions

    Page(s): 3 - 12
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (280 KB)  

    The transformation language Stratego provides high-level abstractions for implementation of a wide range of transformations. Our aim is to integrate transformation in the software development process and make it available to programmers. This requires the transformations provided by the programming environment to be extensible. This paper presents a case study in the implementation of extensible programming environments using Stratego, by developing a small collection of language extensions and several typical transformations for these languages. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Forward slices are smaller than backward slices

    Page(s): 15 - 24
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (472 KB) |  | HTML iconHTML  

    This paper presents evidence from two empirical studies which show that forward slices will tend to be smaller than backward slices and discusses the importance of this result for work on source code analysis and manipulation. The difference in forward and backward slice size distributions stems from the way in which control dependence and data dependence affect slice size. The paper explains this claim in detail and supports it with empirical evidence. The empirical evidence comes from a further study which uses a restricted form of slicing that isolates the effects due to control and data dependence. This study shows that it is the inherent difference between forward and backward control dependence that leads to the difference in slice size distributions for forward and backward slicing. The results from all three empirical studies are shown to be strongly statistically significant. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Abstract slicing: a new approach to program slicing based on abstract interpretation and model checking

    Page(s): 25 - 34
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (336 KB) |  | HTML iconHTML  

    This paper proposes a new approach to program slicing based on abstract interpretation and model checking. First, the notion of abstract slicing is introduced. Abstract slicing extends static slicing with predicates and constraints by using as the program model an abstract state graph, which is obtained by applying predicate abstraction to a program, rather than a flow graph. This leads to a program slice that is more precise and smaller than its static counterpart. Second, a method for performing abstract slicing is developed. It is shown that abstract slicing can be reduced to a least fixpoint computation over formulas in the branching time temporal logic CTL. This enables one to use symbolic model checkers for CTL as an efficient computation engine for abstract slicing. A prototype implementation and experimental results are reported demonstrating the feasibility of the approach. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Dynamic slicing of Java bytecode programs

    Page(s): 35 - 44
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (336 KB) |  | HTML iconHTML  

    A forward global method for obtaining backward dynamic slices of Java bytecode programs is presented. In contrast with existing published techniques that require either a customized Java compiler (which also implies access to the source code) or bytecode instrumentation and eventual manual dependency specifications, our approach was to produce an instrumented virtual machine for Java. This approach works with programs compiled with arbitrary third party compilers and does not require access to the source code during the slicing process. However, we still retain the ability to express the slicing criterion and the resulting slice in terms of source code locations using the supplemental information present in the compiled code. Our technique also handles advanced aspects of the Java environment, such as exception handling, multithreaded execution and, to a certain degree, the execution of native machine code linked with the Java classes. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Minimal slicing and the relationships between forms of slicing

    Page(s): 45 - 54
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (360 KB) |  | HTML iconHTML  

    The widespread interest in program slicing within the source code analysis and manipulation community has led to the introduction of a large number of different slicing techniques. Each preserves some aspect of a program's behaviour and simplifies the program to focus exclusively upon this behaviour. In order to understand the similarities and differences between slicing techniques, a formal mechanism is required. This paper establishes a formal mechanism for comparing slicing techniques using a theory of program projection. Sets of minimal slices, which form the ideal for any slicing algorithm, are used to reveal the ordering relationship between various static and dynamic slicing techniques. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Extending dynamic aspect mining with static information

    Page(s): 57 - 65
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (256 KB) |  | HTML iconHTML  

    Aspect mining tries to identify crosscutting concerns in legacy systems and thus supports the refactoring into an aspect-oriented design. We briefly introduce DynAMiT, a dynamic aspect mining tool that detects crosscutting concerns based on tracing method executions. While the approach is generally fairly precise, further analysis revealed that some false positives were systematically caused by dynamic binding. Furthermore, some aspect candidates were blurred or not detected due to not-sufficient tracing mechanisms of method executions when using AspectJ's execution pointcuts for the trace generation. We enhanced the mining capabilities of DynAMiT by taking additional static type information into account and generating the traces using call pointcuts instead. In an initial case study with AnChoVis, a 1300 LOC Java program, the number of mined aspect candidates increased by a factor of three, while the number of false positives remained zero. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Fine-grained analysis of change couplings

    Page(s): 66 - 74
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (328 KB) |  | HTML iconHTML  

    In software evolution analysis, many approaches analyze release history data available through versioning systems. The recent investigations of CVS data have shown that commonly committed files highlight their change couplings. However, CVS stores modifications on the basis of text but does not track structural changes, such as the insertion, removing, or modification of methods or classes. A detailed analysis whether change couplings are caused by source code couplings or by other textual modifications, such as updates in license terms, is not performed by current approaches. The focus of this paper is on adding structural change information to existing release history data. We present an approach that uses the structure compare services shipped with the Eclipse IDE to obtain the corresponding finegrained changes between two subsequent versions of any Java class. This information supports filtering those change couplings which result from structural changes. So we can distill the causes for change couplings along releases and filter out those that are structurally relevant. The first validation of our approach with a medium-sized open source software system showed that a reasonable amount of change couplings are not caused by source code changes. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Concept assignment as a debugging technique for code generators

    Page(s): 75 - 84
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (384 KB) |  | HTML iconHTML  

    Code generators are notoriously difficult to debug, yet their correctness is crucial. This paper demonstrates that concept assignment can be performed in an entirely syntax-directed manner for code generators and other highly structured program modules. Anomalies in this concept assignment indicate the possible existence of bugs. These insights enable the formulation of a new debugging technique for code generators. This paper describes the procedure, a practical implementation, and results from the application of this debugging technique to an experimental code generator. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Implementation and verification of implicit-invocation systems using source transformation

    Page(s): 87 - 96
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (400 KB) |  | HTML iconHTML  

    In this paper we present a source transformation-based framework to support uniform testing and model checking of implicit-invocation software systems. The framework includes a new domain-specific programming language, the Implicit-Invocation Language (IIL), explicitly designed for directly expressing implicit-invocation software systems, and a set of formal rule-based source transformation tools that allow automatic generation of both executable and formal verification artifacts. We provide details of these transformation tools, evaluate the framework in practice, and discuss the benefits of formal automatic transformation in this context. Our approach is designed not only to advance the state-of-the-art in validating implicit-invocation systems, but also to further explore the use of automated source transformation as a uniform vehicle to assist in the implementation, validation and verification of programming languages and software systems in general. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Specifying transformation sequences as computation on program fragments with an abstract attribute grammar

    Page(s): 97 - 106
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (344 KB) |  | HTML iconHTML  

    We present a grammar based approach for specifying a transformation as a sequence of transformation operations that operate on an intermediate representation. The transformation sequence is specified in the semantic actions of an abstract attribute grammar. The mapping between the object-oriented design of the intermediate representation and the abstract grammar directly reflects the object-oriented design in the structure of the grammar. It has properties that permit utilizing grammar based tools at arbitrary abstraction levels of the language representation. The program fragments can be both source strings and fragments of the intermediate representation that can be used interchangeably in the specification. We demonstrate the applicability of the approach by using available attribute grammar tools and the source-to-source infrastructure ROSE for specifying and performing transformations of C+ + programs. The results of data flow analysis tools using fixed point algorithms is integrated as available attributes that can be used for enabling or disabling transformation sequences. With the abstract attribute grammar the transformation is computed as an attribute value that represents a sequence of restructure operations. The composition of different transformation sequences permits the reuse of sub-transformation specifications. Eventually we discuss the correspondence to rewrite tools permitting a pattern based restructuring of the program representation. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Control flow graph reconstruction for assembly language programs with delayed instructions

    Page(s): 107 - 116
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (312 KB) |  | HTML iconHTML  

    Most software for embedded systems, including digital signal processing systems, is coded in assembly language. For both understanding the software and for reverse compiling it to a higher level language, we need to construct a control flow graph (CFG). However CFG construction is complicated by architectural features which include VLIW parallelism, predicated instructions and branches with delay slots. We describe an efficient algorithm for the construction of a CFG, where the parallelism has been eliminated, instructions are reordered and delay slots have been eliminated. The algorithm's effectiveness has been demonstrated by its use in a reverse compiler for the Texas Instruments C60 series of digital signal processors. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Static analysis for computing escapability and mutability for Java components

    Page(s): 119 - 128
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (288 KB) |  | HTML iconHTML  

    A common theme in information security is protection of trusted software components against unauthorized access by untrusted users. In the context of distributed object technologies, such as Enterprise Java Beans, this means preventing leaks of sensitive information to untrusted users, as well as preventing untrusted users from modifying sensitive information. In this paper, we propose an approach for identification and classification of potentially sensitive information that can leak out of trusted software components to untrusted parties. Unlike the current approaches to securing information flow by extending the type system, our technique is based on static points-to, data- and control-dependence, and object mutability analyses. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A fast analysis for thread-local garbage collection with dynamic class loading

    Page(s): 129 - 138
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (296 KB) |  | HTML iconHTML  

    Long-running, heavily multi-threaded, Java server applications make stringent demands of garbage collector (GC) performance. Synchronisation of all application threads before garbage collection is a significant bottleneck for JVMs that use native threads. We present a new static analysis and a novel GC framework designed to address this issue by allowing independent collection of thread-local heaps. In contrast to previous work, our solution safely classifies objects even in the presence of dynamic class loading, requires neither write-barriers that may do unbounded work, nor synchronisation, nor locks during thread-local collections; our analysis is sufficiently fast to permit its integration into a high-performance, production-quality virtual machine. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Pointer analysis for source-to-source transformations

    Page(s): 139 - 148
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (424 KB) |  | HTML iconHTML  

    We present a pointer analysis algorithm designed for source-to-source transformations. Existing techniques for pointer analysis apply a collection of inference rules to a dismantled intermediate form of the source program, making them difficult to apply to source-to-source tools that generally work on abstract syntax trees to preserve details of the source program. Our pointer analysis algorithm operates directly on the abstract syntax tree of a C program and uses a form of standard dataflow analysis to compute the desired points-to information. We have implemented our algorithm in a source-to-source translation framework and experimental results show that it is practical on real-world examples. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Measuring the impact of friends on the internal attributes of software systems

    Page(s): 151 - 160
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (296 KB) |  | HTML iconHTML  

    Differing views have been expressed on the appropriateness of the friend construct in the design and implementation of object-oriented software in C++. However, little empirical analysis of its usage in the development of systems has taken place. This paper describes an empirical study of the top 100 most downloaded open-source software systems from sourceforge.net, to assess the design implications of the use of the friend construct. On a larger cohort of systems our results provide further evidence that classes declared as friends are coupling hotspots. Our findings also indicate that class size does not seem to have the confounding effect on this relationship that has been suggested in previous research. In addition, there seems to be no indication that friendship is used as an alternative to inheritance although a small number of systems seem to use friendship as an alternative to multiple inheritance and vice versa. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Object-oriented cohesion as a surrogate of software comprehension: an empirical study

    Page(s): 161 - 169
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (224 KB) |  | HTML iconHTML  

    The concept of software cohesion in both the procedural and object-oriented paradigm is well known and documented. What is not so well known or documented is the perception of what empirically constitutes a cohesive 'unit' by software engineers. In this paper, we describe an empirical investigation using object-oriented (OO) classes as a basis. Twenty-four subjects (drawn from IT experienced and IT inexperienced groups) were asked to rate ten classes sampled from two industrial systems in terms of their overall cohesiveness; a class environment was used to carry out the study. Four key results were observed. Firstly, class size (when expressed in terms of number of methods) did not tend to influence the perception of cohesion by any subjects. Secondly, well-commented classes were rated most highly amongst both IT experienced and inexperienced subjects. Thirdly, the empirical study suggests that cohesion comprises a combination of various class factors including low coupling, small numbers of attributes and well-commented methods, rather than any single, individual class feature per se. Finally, the research supports the view that cohesion is a subjective concept reflecting a cognitive combination of class features; as such it is a surrogate for class comprehension. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Transforming embedded Java code into custom tags

    Page(s): 173 - 182
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (392 KB) |  | HTML iconHTML  

    When a new technology is introduced, the migration of existing applications to the new technology must be carefully considered. Automation can make some migrations feasible that otherwise may be too risky or expensive to be worth the advantages of the new technology. In this paper we describe a technique for migrating Web applications using embedded Java code into a custom tag implementation. The technique uses source code transformation techniques to analyze and separate the Java from the Web pages. The code is then automatically transformed to custom Java classes which are invoked from the modified Web pages containing custom tags. The result is a Web application with identical function and appearance, but where the business logic (the Java code) has been separated from the presentation (the Web pages). View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.