PLOMO: Customizable Tools and Infrastructure for Software Development and Maintenance

An INRIA Equipe Associee between RMOD and PLEIAD, named after cerro El Plomo, the highest peak (5424 meters) that is visible from Santiago. Foto by by Thiago "James".

Software maintenance is the process of maintaining a software system by removing bugs, fixing performance issues and adapting it to keep it useful and competitive in an ever-changing environment [Chik90a]. Performing effective software maintenance and development is best achieved with effective tool support, provided by a variety of tools, each one presenting a specific kinds of information supporting the task at hand [Deme02a].

The goal of Plomo is to develop new meta tools to improve and bring synergy in the existing infrastructure of Pharo (for software development) and the Moose software analysis platform (for maintenance). Plomo will

1. enhance the Opal open compiler infrastructure to support plugin definition,
2. offer an infrastructure for change and event tracking as well as model to compose and manipulate them,
3. work on a layered library of algorithms for the Mondrian visualization engine of Moose,
4. work on new ways of profiling applications.

All the efforts will be performed on Pharo http://www.pharo-project.org and Moose http://www.moosetechnology.org/ two platforms heavily used by the RMoD and Pleiad teams.

A number of results have been obtained during the first year of Plomo:

1. Roassal is an agile visualization engine. Roassal is used by the RMoD research group. Roassal is primarily developed in Pharo.
2. Roassal is used by the Moose software analysis platform and Synectique. Synectique is a new company based in Lille that offers solutions based on the Moose platform.
3. Enhance Opal to support type annotation. Opal is a library for bytecode manipulation developed and maintained by RMoD.
4. ObjectProfile is a new company based in Chile. Its business plan is essentially focused on Pharo and Roassal. Object Profile offered to Synectique a dedicated support of Roassal.

In the second year of execution of Plomo, work has focused on:

1. Rizel: a performance evolution monitor.
2. A book chapter on Roassal in the book Pharo By Example 2
3. Roassal also won the third place award in the ESUG 2012 innovation technology awards.
4. Integration of profiling techniques into Jenkins, the continuous integration server used for Pharo. We expect to have a massive amount of profiling information.
5. The Announcements framework to enable change and event tracking.
6. Spec: a Framework for the Specification and Reuse of UIs and their Models. It uses the Announcements framework to enable fine-grained UI refreshes. Roassal makes uses of Spec for its component
7. Athens, the graphic rendering engine developed by RMoD, is used by Roassal.
8. Work on the DIE domain-specific language and the definition of IDE plugins using it, as well as work on change prediction models are still ongoing.

1. Vanessa Peña, PhD student Universidad de Chile. She is working on test coverage and domain specific analyses
2. Juan Pablo Sandoval, PhD student Universidad de Chile.

1. Synectique is a company delivering dedicated software analysis. Synectique uses Roassal to visually report the analysis of customer source code.
2. ObjectProfile was founded in 2011 in Chile. Its business plan is essentially focused on Pharo and Roassal. Object Profile offers support of its products to RMoD and Synectique. A number of features of Roassal have been designed to meet Synectique's requirements (e.g., the navigation and scrolling options).

Plomo enables the participants RMoD (INRIA Lille Nord Europe) and Pleiad (the University of Chile) to collaborate by funding their trips.

• M. Denker from November 7th until November 28th, 2011
• M. Denker from January 18 until February 2nd, 2012 (2011 budget)

• Vanessa Peña and A. Bergel, Aug 15 until Aug 20, 2011. From Aug 20 until Aug 28 they attended http://www.esug.org/wiki/pier/Conferences/2011, a conference co-organized by RMoD. The topic of this research visit is test coverage and software visualization. Result of the research activity on software visualization and code profiling have been presented at ESUG.
• Romain Robbes from July 18 until July 24, 2011
• Esteban Allende from July 19 until October 2, 2011. Esteban's stay was partially funded by the French Embassy in Chile.

• M. Denker from November 1 until November 30, 2012
• D. Pollet from November 1 until November 30, 2012

• Johan Fabry from March 19th until March 23rd, 2012.
• Johan Fabry from August 17th until Sept 2nd, 2012. Completely self-funded.
• Juan Pablo Sandoval from 9 November until 2 December 2012. The topic of the research visit is monitoring of performance evolution.
• Alexandre Bergel from July 15 until July 31.

• Johan Fabry, Andy Kellens, Simon Denier and Stéphane Ducasse. AspectMaps: Extending Moose to Visualize AOP Software, In Elsevier Science of Computer Programming, special issue on Experimental Software Toolkits, 2012. (To Appear) http://dx.doi.org/10.1016/j.scico.2012.02.007
• Stephane Ducasse, Manuel Oriol, Alexandre Bergel, Challenges to support automated random testing for dynamically typed languages, In Proceedings of the 3rd International Workshop on Smalltalk Technologies (IWST'11), Collocated with ESUG, June 2011. ACM Digital Library http://dx.doi.org/10.1145/2166929.2166938
• Johan Fabry, Andy Kellens, and Stéphane Ducasse. AspectMaps: A Scalable Visualization of Join Point Shadows. In Proceedings of 19th IEEE International Conference on Program Comprehension (ICPC2011), pages 121–130. IEEE Computer Society Press, Jul 2011 http://dx.doi.org/10.1109/ICPC.2011.11.

• Benjamin Van Ryseghem, Stéphane Ducasse, Johan Fabry, Spec: a Framework for the Specification and Reuse of UIs and their Models In Proceedings of the 4th International Workshop on Smalltalk Technologies (IWST'12), Collocated with ESUG, August 2012. ACM Digital Library (To Appear)
• Benjamin Van Ryseghem, Stéphane Ducasse, Johan Fabry, Alain Plantec Seamless reuse of customizable user interfaces with Spec, Elsevier Science of Computer Programs, in preparation.
• Romain Robbes, Johan Fabry, Marcus Denker, DIE: A Domain Specific Aspect Language for IDE Events, In preparation.
• Romain Robbes, Damien Pollet, Michele Lanza, Improving change prediction by replaying fine-grained development histories, In preparation.
• Juan Pablo Sandoval, Alexandre Bergel, Marcus Denker, Stéphane Ducasse, “Performance Evolution Blueprint”. In preparation

Opal is a new, extensible and modular compiler framework. The front-end is based on the notion of dynamically composable parsers [Reng10c] and a high-level code representation based on an AST (abstract syntax tree) with code transformation support [Robe96a]. The backend is based on an intermediate representation of byte code. Such a high-level representation of byte code offers a good possibility to express advanced, on the fly, modification of methods at the byte code level. A flexible and extensible byte code level infrastructure is needed to introduce code for hooks and low level probes, as needed by advanced aspect oriented languages (AOP) or dynamic analysis tools like runtime profilers. The compiler framework was developed as a joint project between RMod and the SCG in Bern. Opal will act as the infrastructure behind several other work packages and needs to be enhanced to enable full support for those.

The goal of this task is to be able to replace the existing compiler infrastructure in place in Pharo by Opal, allowing the other tasks of this proposal to use Opal as a basis. Replacing the old Pharo compiler validates the compiler as practically usable.

Many development environment tools provide additional support to the fundamental edit-compile-run cycle of development and maintenance. These range from basic, state-of-the-practice tools such syntax highlighting, code autocompletion, or notification of changes, to experimental tools such as task context management [Kers06a] and code clone detection and clone management. These tools need to be integrated in the IDE in a fluid manner.

These additional tools hook into the core of the IDE, adding their notification system for the actions taking place inside of the IDE. The events that they track can differ, ranging from events produced by the IDE (changes to the code, navigation in the code, tool usage, copy/paste, etc.) to events produced by the program that is being developed at runtime, as generated by debugging or profiling tools. Currently, these additional tools contain an ad-hoc event handler, i.e., each tool implements its own event handlers and event generators. As a result, there is low reuse in that part of the construction of such additional support tools, and furthermore the different event handlers in the system may interfere in each others' operation. The various event generators have heterogeneous interfaces as well, so that a tool needing to handle several kinds of events is exposed to additional complexity.

The goal of this task is to develop a general event notification system for Pharo and building a set of suitable abstractions on top of this system. We plan to extend and refine the current Announcement system, and reify events at the level of abstraction that allows the additional support tools to express sequences of events of interest in a concise way. Conceptually this is a case of event-based Aspect Oriented Programming [Doue02b]. The IDE generates a stream of events which are join points, the abstraction level is obtained by a (higher-level) join point model, and the tools express their interest in a certain kind of stream of events by declaring a pointcut. Developing a Domain-Specific Aspect Language for IDE events will allow tool builders to declare event handlers in a concise and homogeneous way, allowing tools to express interest in different stream of events seamlessly.

Software visualization is an essential component of many reverse engineering and software analysis approaches. The first step for this research axis is to produce the necessary infrastructure for conducting analysis and experiments using software visualization. We envision a framework that is open and malleable for a broad range of visual representations. This work package is built on top of the Mondrian visualization framework. Mondrian has been successfully employed in numerous academic and industrial case studies. It has demonstrated its ability to produce useful and practical high level source code representations, helpful to identify bugs and anomalies in software programs [Lava09a,Berg10b,Berg10a]. Although expressive, Mondrian suffers from its built-in graph model to represent data. It is often a constraint since its restrict creativity and scalability (especially when low and high level of details are simultaneously displayed). As the result of this first work package,we plan to produce Mondrian2 (working title for the new version of Mondrian), an open-source framework for agile, flexible, scalable and open visualizations of both static as dynamic information. For the latter, Mondrian will be able to take advantage of the new event mechanism implemented in the second workpackage to allow for dynamic visualizations of behavioral/run-time information.

Application profiling can be realized for a variety of reasons (locating performance bottlenecks, assessing test coverage, to support feature location, etc.). Each use case requires different strategies to gather the necessary information, and has different performance requirements.

In this work package we will focus on providing the necessary infrastructure for profiling applications in such a variety of situations. There are several scientific challenges such as collecting, storing events in memory efficient manner.

Such a framework ought to be flexible and designed for rapid prototyping of profilers. The key asset of this framework is to be open for dynamic extension and refinement: profilers will be adjustable while acting on an executing software program. This ability, which we call agility, is essential to enable an effective profiling in a dynamic programming language and environment such as Pharo, the programming language we have chosen for conducting this work. To effectively exploit produced profilers, the framework has to be fully integrated with the IDE of Pharo. As an outcome, this work package will produce an agile and effective framework for designing and realizing program execution profilers.

[Chik90a] Elliot Chikofsky and James Cross II. Reverse Engineering and Design Recovery: A Taxonomy. In IEEE Software 7(1) p. 13-17, January 1990.

[Deme02a] Serge Demeyer, Stéphane Ducasse, and Oscar Nierstrasz. Object-Oriented Reengineering Patterns, Morgan Kaufmann, 2002.

[Reng10c] Lukas Renggli, Stéphane Ducasse, Tudor Girba, and Oscar Nierstrasz. Practical Dynamic Grammars for Dynamic Languages. In 4th Workshop on Dynamic Languages and Applications (DYLA 2010), Malaga, Spain, June 2010.

[Robe96a] Don Roberts, John Brant, Ralph E. Johnson, and Bill Opdyke. An Automated Refactoring Tool. In Proceedings of ICAST '96, Chicago, IL, April 1996.

[Lava09a] Jannik Laval, Alexandre Bergel, and Stéphane Ducasse. Matrice de dépendances enrichie. In Proceedings of Languages et Modéles á Objets (LMO 2009), Nancy, France, 2009.

[Berg10b] Julio Ariel Hurtado Alegria, Alejandro Lagos, Alexandre Bergel, and María Cecilia Bastarrica. Software Process Model Blueprints. In Proceedings of the International Conferences on Software Processes (ICSP'10), LNCS Springer Verlag, July 2010.

[Berg10a] Sébastien Mosser, Alexandre Bergel, and Mireille Blay-Fornarino. Visualizing and Assessing a Compositional Approach of Business Process Design. In Proceedings of 9th International Conference on Software Composition (SC'10), LNCS Springer Verlag, July 2010.