|
CS619
|
Program Comprehension MSc. in
Computer Science, 2009-2010
|
Background information
The purpose of this graduate-level course is to introduce the
techniques used in the analysis of programs. Such techniques
provide the foundation for a wide range of tools used in software
engineering; examples include tools that:
- reverse-engineer a class diagram from some source code
- examine source code to see if it adheres to particular coding
guidelines
- apply software metrics to code, to measure its design quality
- instrument the code, for example, to measure statement or branch
coverage at run-time
- transform the code into a different format (e.g. to another
programming language)
- ..... and many others
Many of the techniques to perform these tasks have a basis in the
theory of compiler design, which you may have covered as an
undergraduate. Unlike a typical undergraduate compilers course, we'll
be taking a specifically software-engineering view of program
analysis.
The course is practically-based, concentrating on
static and dynamic analysis of Java programs, but also dealing with
the more complex issues arising in pointer-based languages such as
C++.
The overall emphasis is on contributing to research in the area,
rather than tool-building, and strategies for evaluating research work
in the area are discussed. As such, the course reviews current
work from relevant conferences such as the IEEE International Workshop
on Program Comprehension, the IEEE Working Conference on Reverse
Engineering and the ACM Symposium on Software Visualization.
Module Objective
|
"To provide the necessary background for students interested in
conducting research into program comprehension, reverse engineering
and source code analysis."
|
Module Content
- Static analysis
Brief overview of the phases of a compiler;
lexical analysis and parsing;
preprocessors, ambiguity and other problems;
issues in parsing C++.
- Inside the Java Virtual Machine
Structure of the JVM, JVM internals - method area, constant pool,
JVM stack and heap; class loading and linking; the JVM instruction
set; disassembling class files and reading bytecode
instructions; bytecode analysis using BCEL.
- Principles of Program Analysis
Control flow analysis, basic blocks, dominators and reducible flow
graphs; Data flow analysis, gen and kill sets, iterative solutions
to data flow equations; data flow problems: liveness, reaching
definitions, available expressions and upward exposed uses.
- Inter-procedural Analysis
Call graphs and
inter-procedural control-flow graphs; class hierarchy analysis and
rapid type analysis; devirtualisation of methods calls; heap
analysis and garbage collection; formal approaches to shape
analysis.
- Reverse Engineering
Reverse engineering - basic definitions and terminology; reverse
engineering of UML class diagrams; reverse engineering of UML
sequence diagrams, including loop identification and object naming;
Software visualisation - basic terminology and taxonomy; visualising
objects on the JVM heap.
Timetable
This course is currently scheduled to take place in semester 2. If
you've any queries about the course in
advance of this, please don't hesitate to contact me.
