For the last 15 years, those involved in building interactive program development environments (IDEs) have been searching for the ideal program representation. Such a representation must allow for the incorporation of both new tools (which present views to the programmer), and new services (which make information about the program available to the tools). The ideal representation will provide equal, straightforward access to both “core” information about the program, and information derived from an analysis of the code, such as inferred types. In this way, services can build on one another, and services and tools programmed for a language in which certain information is explicit can be retargeted to other languages in which the same information is implicit. The purpose of this workshop is to enable those involved in building plugins and tools for IDEs and those involved in developing program analyses and program restructuring tools to come together to discuss their common needs and how best to meet them. The thesis of the workshop is that no single, pre-defined representation can possibly be adequate for all of the uses may emerge; instead, we focus on extensible representations.
IDEs such as Eclipse have become the dominant platform for developing Object-oriented applications. This is because of the recognition that refactoring plays a vital role in the evolution of code, and that machine-assisted refactoring is both faster and less error-prone than manual refactoring. However, there remains a belief that there is some sort of “silver bullet” representation for each programming language, and that if we could only find it, tool development would become much easier. This workshop takes the position that there is no silver bullet: however complete a program representation may appear today, tomorrow a tool or a program analysis will be developed that will not work with that representation. Instead, what we need is an open, extensible representation. This workshop focusses on such extensible representations, and aims to provide a forum both for the presentation of new extension patterns and for the testing of existing patterns against selected “challenge problems”.
The Back Story
During Summer 2004, Andrew Black and Daniel Vainsencher were struggling to find a way to integrate a conceptually simple but computationally intensive code analysis (the Required Methods analysis) into the Smalltalk code model. Previously, this analysis had been incorporated into a specific tool, and was thus not reusable by other tools. Their efforts developed into a set of patterns, which were much revised and eventually presented at PLoP 2006 (see http://hillside.net/plop/2006/). At PLoP, others expressed interest in the problem and in the patterns as a putative solution, and suggested that a workshop would be a good forum to further explore these ideas.
The current version of the Patterns paper is at http://web.cecs.pdx.edu/ ... elExtensions.pdf