ICSE 2011 Workshops
33rd International Conference on Software Engineering
Powered by
Conference Publishing Consulting

First Workshop on Developing Tools as Plug-ins (TOPI 2011), May 28, 2011, Waikiki, Honolulu, HI, USA

TOPI 2011 – Proceedings

Contents - Abstracts - Authors

First Workshop on Developing Tools as Plug-ins (TOPI 2011)


Title Page

We would like to welcome you to this, the first workshop on Developing Tools as Plug-Ins (TOPI 2011). Plug-ins are the modern approach towards incrementally adding new tools into these rich environments. Proving for plug-ins is necessary because it is at best very hard to get programmers to try a new tool without integrating it into an existing environment. Indeed, our knowledge of how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a pre-existing development environment. This approach allows integration with existing elements such as compilers, debuggers, profilers, visualizers as well as numerous other development and, often, runtime tools. However, building tools as plug-ins can be challenging. How do they interact with the core environment? How do they interact with one another – especially since each developer may choose a different set of plug-ins? How can we share tools across different, and future, core development environments? These are all questions that will be addressed during TOPI 2011.

Full Papers

Supporting Plug-in Mashes to Ease Tool Integration
Leonardo Mariani and Fabrizio Pastore
(University of Milano Bicocca, Italy)
The majority of IDEs implement a concept of plug-in that nicely supports the integration of tools within the IDEs. Plug-ins dramatically simplify the structural integration of multiple tools, but provide little support to the design of the dynamic of the integration, which must be entirely coded by programmers from plug-ins' API. Manually integrating plug-ins is costly, complex and requires a deep understanding of the underlying environment. The implementation of tools as plug-ins and the integration of the results produced by different plug-ins are still difficult, expensive and error-prone activities. This paper presents the concepts of Task Based Plug-in (TB-plug-in) and workflow of TB-plug-ins. In our vision, IDE users must be able to execute plug-ins and integrate their results by designing workflows that can be persisted, executed and re-used in other workflows. We validated our idea by refactoring a set of Eclipse plug-ins for log-file analysis into TB-plug-ins, and designing several workflows that integrate plug-in tasks. We compared the effort necessary to implement these analyses from plug-ins with the effort necessary to design the workflows from TB-plug-ins. We discovered that workflows can be easily designed with little knowledge about the IDE and the plug-ins' API, save significant effort otherwise devoted to the implementation of additional plug-ins and glue-code, and produce analyses that can be quickly modified and reused.

Pest: From the Lab to the Classroom
Guido de Caso, Diego GarbervetskyORCID logo, and Daniel Gorin
(Universidad de Buenos Aires, Argentina)

Four Generic Issues for Tools-as-Plugins Illustrated by the Distributed Editor Saros
Lutz Prechelt and Karl Beecher
(Freie Universität Berlin, Germany)
Saros is an Eclipse plugin for multi-writer, real-time, distributed collaborative text editing that also includes VoIP, chat, whiteboard, and screen sharing functionality. We present four problematic issues we encountered in the development of Saros: Providing portability, choosing a metaphor, handling clashes in display markups, and attributing incompatibilities correctly to their source. These issues will apply to many other plugins similarly. For three of them, no generic solution approach yet exists but should be worked out.

Ginga-NCL Architecture for Plug-ins
Marcio Ferreira Moreno, Rafael Savignon Marinho, and Luiz Fernando Gomes Soares
(PUC-Rio, Brazil)
Ginga-NCL is the declarative environment of the Ginga middleware, an ITU-T Recommendation for IPTV services and ITU-R Recommendation for terrestrial digital TV. This paper discusses the two-way solution Ginga proposes for its plug-ins. Ginga defines an API that allows third party tools as NCL (the declarative language of Ginga) player’s plug-ins for specific media-object type exhibition that composes a DTV application presentation in its whole. As NCL allows nested NCL applications, an NCL application itself acts as a plug-in of another parent NCL application, therefore obeying the same plug-in API previously mentioned. In general, the same NCL plug-in API can be used to allow applications specified in other languages to be embedded in NCL applications, as well as to allow NCL applications to be embedded in other presentation environments, in particular the Ginga-NCL environment. This two-way bridge is exemplified in this paper between NCL and HTML applications.

Platform Support for Developing Testing and Analysis Plug-ins
Shauvik Roy Choudhary, Jeremy Duvall, Wei Jin, Dan Zhao, and Alessandro OrsoORCID logo
(Georgia Institute of Technology, USA)
Plug-ins have become an important part of today's integrated development environments (IDEs). They are useful for extending the functionality of these environments and customizing them for different types of projects. In this paper, we discuss some features that should be provided by IDEs to support the development of a specific kind of plug-ins---plug-ins that support program analysis and software testing techniques. To guide the discussion, we leverage our experience in building a plug-in for two different platforms and generalize from that experience.

Reconciling the 3-layer Architectural Style with the Eclipse Plug-in-based Architecture
David Ameller, Oriol Collell, and Xavier Franch
(Universistat Politècnica de Catalunya, Spain)
Software architecture construction is the result of a complex decision-making process, in which competing alternatives need to be compared. For example, deciding between a web-based application or a plug-in-based application has a significant impact on the architecture, therefore in order to make the right choice all possible tradeoffs between them must be considered. Decisions need to be made in all architectural views, from the logical view in which architectural styles are chosen, to the development view in which types of modules are decided, to the deployment view where physical allocation is determined. In this paper we analyze the interactions between a 3-layer architecture at the logical view, and a plug-in-based development view implemented in Eclipse, focusing on the difficulties we overcome in a research project in order to make it work.

AODVis: Leveraging Eclipse Plugins to Reverse Engineer and Visualize AspectJ/Java Source Code
Jeffrey Koch, Sunil Bohra, Rohit Goel, Sonali Pagade, and Kendra M. L. Cooper
(University of Texas at Dallas, USA)
AspectJ reverse engineering and visualization remains a challenge at the architectural and design levels, with fewer tools available for reverse engineers compared to other languages such as Java. As part of our AODVis (Aspect-Oriented Development Visualization) framework, we are developing Eclipse plugins to reverse-engineer and visualize AspectJ projects as 3D UML-based detailed design, architecture, and analysis level models.
The AODVis plugins leverage several existing Eclipse plugins to extract program facts, create and manipulate UML, transform program facts into models, and generate visualizations of the models. Although integration can be challenging, the broad range of plugins are invaluable in providing solutions for extending and integrating existing tools such as compilers and IDEs. The plugins and the Eclipse plugin architecture also allowed us to concentrate on our specific research problem instead of developing our own tool support from scratch.

RDB2RDF Plugin: Relational Databases to RDF Plugin for Eclipse
Percy E. Salas, Edgard Marx, Alexander Mera, and José Viterbo
(PUC-Rio, Brazil; Universidade Federal Fluminense, Brazil)
RDB2RDF is the process by which a relational database schema (RDB) is transformed into a set of RDF triples. A major step in this process is deciding how to represent database schema concepts in terms of RDF classes and properties. This correlation is described in the RDB2RDF mapping file, which is used as the base for the generation of RDF triples. Most RDB2RDF engines today provide support to the mechanical process of transforming RDB to RDF, each with its own mapping language. Due to this fact, the W3C RDB2RDF Working Group has been working to standardize a language to map relational data to RDF called R2RML. Part of their efforts is directed to fostering the development of methods, tools and techniques to support standard RDB2RDF mapping strategies. In this paper, we introduce an Eclipse plug-in that supports the standard RDB to RDF Mapping Language (R2RML) to produce Direct Mappings in RDF.

Application Management Plug-ins through Dynamically Pluggable Probes
Kiev Gama, Gabriel Pedraza, Thomas Lévêque, and Didier Donsez
(University of Grenoble, France; Mälardalen University, Sweden)
It is widely recognized that applications need to be administered remotely. In general, application management and monitoring is supported by textual management consoles while graphical user interfaces specialized for their tasks are preferred by average users. Defining what must be monitored and what are the admin actions one wants to perform on an application cannot be defined during the application development due to the fact that these needs evolve after the application deployment as we cannot completely predict the execution environment such as available devices. This paper presents an architecture and the corresponding infrastructure that allow administrators to define what they want to monitor and manage and automate the discovery and deployment of corresponding probes and related management console graphical plug-ins. This work has been validated on two different application domains.

SRP-Plugin: A Strategic Release Planning Plug-in for Visual Studio 2010
Jamshaid G. Mohebzada, Guenther Ruhe, and Armin Eberlein
(University of Calgary, Canada; American University of Sharjah, United Arab Emirates)
Strategic release planning (SRP) is a critical step in iterative software development. SRP involves the assignment of features or requirements to releases while considering hard and soft constraints, such as time, effort, quality or resources. ReleasePlanner™ is a web-based decision support tool that is based on a sound and rigorous formal strategic release planning model. In this paper we describe the integration of ReleasePlanner™ with Visual Studio in the form of a Visual Studio plug-in called SRP-Plugin. The SRP-Plugin is used to demonstrate our hypothesis that tools implemented as plug-ins for widely used development platform (such as Visual Studio) help to increase efficiency of the development process. The plug-in augments the rich Visual Studio environment with advanced release planning capabilities which result in better release planning quality, increased productivity and enhanced communication among project stakeholders. The added value of providing systematic release planning as part of a development is not limited to release planning alone. We have outlined the future work to extend SRP-Plugin to include proactive decision making features such as utilization of sensitivity analysis and machine learning techniques to provide recommendations for the project manager during the challenging task of deciding which sets of features should be offered to whom, when, and why.

IDE Support to Facilitate the Transition from Rapid Prototyping to Robust Software Production
Francisco Ortin and Anton Morant
(University of Oviedo, Spain; University of Oxford, UK)
Dynamic languages are becoming increasingly popular for different software development scenarios such as rapid prototyping because of the flexibility and agile interactive development they offer. The benefits of dynamic languages are, however, counteracted by many limitations produced by the lack of static typing. In order to obtain the benefits of both approaches, some programming languages offer a hybrid dynamic and static type system. The existing IDEs for these hybrid typing languages do not provide any type-based feature when dynamic typing is used, lacking important IDE facilities offered for statically typed code. We have implemented a constraint-based type inference system that gathers type information of dynamic references at compile time. Using this type information, we have extended a professional IDE to offer those type-based features missed for dynamically typed code. Following the Separation of Concerns principle, the IDE has also been customized to facilitate the conversion of dy-namically typed code into statically typed one, and vice versa.

Contractor.NET: Inferring Typestate Properties to Enrich Code Contracts
Edgardo Zoppi, Víctor Braberman, Guido de Caso, Diego GarbervetskyORCID logo, and Sebastián Uchitel
(Universidad de Buenos Aires, Argentina)
In this work we present Contractor.NET, a Visual Studio extension that supports the construction of contract specifications with typestate information which can be used for verification of client code. Contractor.NET uses and extends Code Contracts to provide stronger contract specifications. It features a two step process. First, a class source code is analyzed to extract a finite state behavior model (in the form of a typestate) that is amenable to human-in-the-loop validation and refinement. The second step is to augment the original contract specification for the input class with the inferred typestate information, therefore enabling the verification of client code. The inferred typestates are enabledness preserving: a level of abstraction that has been successfully used to validate software artifacts, assisting in the detection of a number of concerns in various case studies including specifications of Microsoft Server protocols.

Fishtail: From Task Context to Source Code Examples
Nicholas Sawadsky and Gail C. Murphy
(University of British Columbia, Canada)
Implementing software development tools as integrated development environment (IDE) plugins gives tools direct access to a range of useful representations of the program being created and can improve programmer efficiency. These benefits must be weighed against the effort to integrate the tool into the IDE, effort which may need to be repeated for each IDE targeted. In this paper, we introduce Fishtail, a prototype plugin for the Eclipse IDE, which assists programmers in discovering code examples and documentation on the web relevant to their current task. Fishtail uses a detailed history of programmer interactions with the source code to automatically determine relevant web resources. We describe the key factors that make it attractive to implement Fishtail as a plugin, and the requirements Fishtail imposes on the plugin/IDE interface. To reach a broader user base and understand how well our tool supports different programming styles and IDE architectures, we have recently begun investigating how to make a version of Fishtail available in the Visual Studio IDE. We outline some of the challenges we face in trying to reuse code from the original Eclipse plugin.

A Cloud-aware API for Semi-structured BLOB Databases Addressing Data Overflow
Jaumir V. da Silveira, Jr. and Karin K. Breitman
(PUC-Rio, Brazil)

Short Papers

Resource Usage Contracts for .NET
Jonathan Tapicer, Diego GarbervetskyORCID logo, and Martin Rouaux
(UBA, Argentina)
Code Contracts is a tool that allows the specification and verification of contracts (pre, post-condition, invariants) in all .NET based programming languages. Resource Contracts is an extension of this language to specify resource usage in .NET programs. The new annotations, initially focussed on dynamic memory, enable modular analysis of both memory consumption and lifetime properties. They are checked by relying on the own Code Contracts static verifier and a points-to analysis. This approach is implemented as a Visual Studio extension, providing facilities such us autocompletion and verification at build time.

Architecting a Plug-in Based Steam Turbine Design Tool
Stefanos Zachariadis and Tim Cianchi
(Zuhlke Engineering, UK)
At a leading manufacturer of equipment for power generation, the engineers currently design a steam turbine, a key component of a power plant, using a large number of disjoint legacy tools written mostly in Fortran; These tools encapsulate significant engineering know how and are vital to the successful operation of the company. Their age and state pose a number of challenges, including difficulty in adapting to new methods, maintenance costs and lack of integration; the cost of replacing them all in one go however, has been deemed to be prohibitively expensive. In this experience report we describe the Turbine Design Tool (TDT), our approach in developing a plug-in based design tool that encapsulates and integrates the legacy tools into a single, component-based, extendable environment that offers the advantages of an integrated solution while minimising the cost and disruption to the business and that allows for the gradual replacement of the tools.

Towards Subtyped Program Generation in F#
Baris Aktemur
(Özyeğin University, Turkey)
Program Generation is the technique of combining code fragments to construct a program. In this work we report on our progress to extend F# with program generation constructs. Our prototype implementation uses a translation that allows simulating program generators by regular programs. The translation enables fast implementation and experimentation. We state how a further extension with subtyping can be integrated by benefiting from the translation.

OthelloPlay– A Plug-in Based Tool for Requirement Formalization and Validation
Roberto Cavada, Alessandro Cimatti, Andrea Micheli, Marco Roveri, Angelo Susi ORCID logo, and Stefano Tonetta
(FBK, Italy)
Requirement engineering is one of the most important phases in the development process of software and systems. In safety-critical applications, it is important to support the validation of the requirements with formal techniques to identify and remove flaws. However, requirements are often written in textual documents and their formalization and validation is not trivial for non-experts in formal methods. The goal of the OthelloPlay tool is to support formalization of textual requirements and to simplify the use of formal techniques for requirements validation. The tool combines a formal verification engine and the Microsoft Word(R) editor in a single and consistent environment. A fundamental key in our design approach is a plug-in-based architecture, which uses the Python language in conjunction with a Microsoft Word(R) Add-In. The user can jump between textual requirements in the Microsoft Word(R) editor and the corresponding formal requirements model.

An OpenGL-based Eclipse Plug-in for Visual Debugging
André Riboira, Rui AbreuORCID logo, and Rui Rodrigues
(University of Porto, Portugal)
Locating components which are responsible for observed failures is the most expensive, error-prone phase in the software development life cycle. We present an Eclipse Plug-in that aims to fill some of the automatic debugging tools gaps: the lack of a visualization tool that provides intuitive feedback about the defect distribution over the code base, and easy access to the faulty locations.

eCLAIM - An Eclipse Plug-in for Mobile MAS Applications
Diego Salomone Bruno, Karin K. Breitman, and Amal El Fallah Seghrouchni
(PUC-RIO, Brazil; LIP6, France)
The eCLAIM plug-in provides a solid environement for design and implementation of Multi-Agent Systems (MAS). Based on the agent oriented language CLAIM [], it eases the development of software agents that are at the same time mobile and intelligent.

ICE: Circumventing Meltdown with an Advanced Binary Analysis Framework
Dean Pucsek, Jonah Wall, Celina Gibbs, Jennifer Baldwin, Martin Salois, and Yvonne Coady
(University of Victoria, Canada; Defence Research and Development, Canada)
In this paper we propose ICE, an Integrated Comprehension Environment, designed to facilitate advanced binary analysis through an extensible framework. ICE makes extensive use of modules and a flexible intermediate representation to enable seamless integration of instruction set architectures, platforms, and analysis techniques.

proc time: 1.18