Code Analysis and Manipulation
- As shown by a number of studies, on average, software systems tend to be rewritten from scratch approximately every seven years.
- Over time, the internal quality of a piece of software steadily decreases, such that at a certain moment it becomes impossible to further maintain the software, and a complete rewrite of the system becomes inevitable. This degradation of the software can have various causes. For example, a poor initial modularization, the lack of proper coding guidelines, inherent restrictions in the used programming language and so on can all contribute to software that is difficult to maintain, adapt and understand.
- Adding to this is the constant time pressure under which developers have to work to cope with ever changing requirements, resulting that only minimal effort can be devoted to improve the software's structure, and the consistency and quality of the source code.
Goals
We strive to support the development of sustainable software systems, devised from the start to be used and maintained over an extended period of time, through dedicated tooling and novel language constructs.
To this end, our research aims to provide a solid foundation for the validation, transformation and understanding of software systems:
- We support validation by identifying bug patterns and violations of architectural regularities in code.
- We apply software transformations to the problems of API migration, automatic parallelization and multi-language refactoring.
- Finally, we provide support for the understanding of version repositories through advanced visualizations and dedicated query languages.
We specifically advance the state of the art along three main axes:
- The first axis considers multi-language systems. Analyses need to consider the impact that annotations as well as embedded domain-specific languages have on the semantics of the host program.
- The second axis considers the analysis of highly dynamic languages such as Javascript and Scheme. Here, the semantics of higher-order procedures with side-effects have to be taken into account.
- The third axis considers multiple versions of code in an analysis. Here, the state of the art is challenged by the scale of version repositories and the complexity of the temporal relations between versions.
Members
Professor
Post-docs
Pre-docs
CAMP Intranet
Artifacts
JIPDA
JIPDA (JavaScript Interprocedural Dependence Analysis) is a generic abstract interpreter for JavaScript, written in JavaScript. JIPDA is highly parameterized and provides many hooks and callbacks, making it an easily customizable foundation for JavaScript program analysis. Instead of keeping track of giant state spaces by default, JIPDA employs events to notify interested parties of what is happening during an abstract interpretation run. JIPDA's combination of flexible design, extensibility, and coverage of the JavaScript specification (ECMA-262 5.1 targeted for now) makes it a unique and versatile program analysis tool.
Ekeko
Ekeko enables querying and manipulating an Eclipse workspace using applicative logic programs. Its libraries provide support for answering program queries (e.g., “is my code bug free?” or “does my code follow the prescribed design?”) as well as transforming programs (e.g., “patch my code as follows”) in a declarative manner. Ekeko is the successor to SOUL.
Torch
Torch is a software visualization tool to support integrators getting an overview and understanding of proposed changes in the context of object-oriented programming. It characterizes changes based on structural information, authors and symbolic information. Torch mixes text-based diffs with visual representation and metrics characterizing the changes.
IntensiVE
The Intensional Views Environment (IntensiVE) empowers software architects and developers with tools and techniques to monitor the internal quality of software development projects. IntensiVE verifies a wide range of good practices, detects bad code smells and, most importantly, verifies application-specific architectural rules and constraints in your application's source code.
SOUL
The Smalltalk Open Unification Language (SOUL) is a language integrated into Smalltalk environments and is designed for declarative meta programming. Declarative meta programming is the use of a declarative language for meta programming. SOUL falls in the class of logic-based declarative languages and is similar to Prolog, but includes some specialized features for meta programming.
Padus is an aspect-oriented extension to BPEL, which allows modularizing crosscutting concerns in separate aspects.
Unify is a framework for uniform modularization of all workflow concerns, be they regular or crosscutting.
JAsCo
A new AOP language that is tailored for CBSD.
StrongAspectJ
An AspectJ language extension to support flexible and safe pointcut/advice bindings.
WSML
Enabling client-side management of Web Services using Dynamic AOSD.
FuseJ
A new AOP approach aiming at integrating aspect and components.
PacoSuite
Enhancing viusal component based software development. Integrates AOSD into CBSD design level.
CoBro
A Smalltalk environment empowering developers to build extensible and documented software (based on the Concept-Centric Coding approach).
Dynamic Annotations
An extension to Java annotations that allows developers to include dynamic conditions on the activation of annotations.
