ICSE 2012 Workshops
2012 34th International Conference on Software Engineering (ICSE)
Powered by
Conference Publishing Consulting

2012 Second International Workshop on Developing Tools as Plug-Ins (TOPI), June 3, 2012, Zurich, Switzerland

TOPI 2012 – Proceedings

Contents - Abstracts - Authors

Second International Workshop on Developing Tools as Plug-Ins (TOPI)


Title Page

We would like to take this opportunity to welcome you all to the second edition of the International Workshop on Developing Tools as Plug-Ins (TOPI 2012).
The main goal of this workshop is understanding the opportunities and challenges of developing tools as plug-ins. In particular, we would like to discuss the characteristics of good plug-ins, understand interoperability requirements to making tools available across platforms, identify recent successful tools as plug-ins and specify the medium and long-term challenges of tools as plug-ins.
We received a total of 32 submissions with authors from 18 different countries. Each paper was reviewed by at least 3 members of the TOPI 2012 program committee. We have accepted 14 works as full papers and 4 as short papers.
The program comprises position papers including new proposals for plug-in architectures as well as their interaction with development environments and run-times and papers discussing the implementation of different kind of tools as plug-ins.
The TOPI 2012 workshop will provide an interesting forum for researchers interested in developing software engineering tools and plugins. We hope that TOPI will encourage other researchers to participate in this discussion. Your attendance here today shapes the future conversations we will have, and we look forward to seeing you all, alongside any and all newcomers, in the workshops to come.

Full Papers

Playing Cupid: The IDE as a Matchmaker for Plug-Ins
Todd W. Schiller and Brandon Lucia
(University of Washington, USA)
We describe a composable, data-driven, plug-in ecosystem for IDEs. Inspired by Unix's and Windows PowerShell's pipeline communication models, each plug-in declares data-driven capabilities. Developers can then seamlessly mix, match, and combine plug-in capabilities to produce new insight, without modifying the plug-ins.
We formalize the architecture using the polymorphic lambda calculus, with special types for source and source locations; the type system prevents nonsensical plug-in combinations, and helps to inform the design of new tools and plug-ins. To illustrate the power of the formalism, we describe several synergies between existing plug-ins (and tools) made possible by the ecosystem.

Simplicity Principles for Plug-In Development: The jABC Approach
Stefan Naujokat, Anna-Lena Lamprecht, Bernhard Steffen, Sven Jörges, and Tiziana Margaria
(TU Dortmund, Germany; University of Potsdam, Germany)
In this paper we present our experiences from a decade of plug-in development in the jABC framework, that is characterized by rigorous application of simplicity principles in two dimensions. First, the scope of the plug-in development is clearly defined: The jABC readily provides a sophisticated graphical user interface, which has been tailored to working with all kinds of directed graphs. Within this scope, plug-in development can deliberately focus on the actual functionality, like providing semantics to graphs, without having to deal with tedious but semantically irrelevant issues like user interfaces. Second, plug-in functionality can be itself conveniently modeled as a workflow within the jABC. We illustrate our approach by means of two mature plug-ins: Genesys, a plug-in that adds arbitrary code generator functionality to the jABC, and PROPHETS, a plug-in that eases user-level definition of workflows by completing model sketches by means of synthesis capabilities, so that they become complete and executable. We summarize our experience so far and derive general design principles for ”lightweight plug-in development”, that we are going to realize in the next generation of the jABC, which will be implemented itself as a collection of Eclipse plug-ins.

An Architectural Blueprint for a Pluggable Version Control System for Software (Evolution) Analysis
Giacomo Ghezzi, Michael Würsch, Emanuel Giger, and Harald C. GallORCID logo
(University of Zurich, Switzerland)
Current version control systems are not built to be systematically analyzed. They have greatly evolved since their first appearance, but their focus has always been towards supporting developers in forward engineering activities. Supporting the analysis of the development history has so far been neglected. A plethora of third party applications have been built to fill this gap. To extract the data needed, they use interfaces that were not built for that. Drawing from our experience in mining and analyzing version control repositories, we propose an architectural blueprint for a plug-in based version control system in which analyses can be directly plugged into it in a flexible and lightweight way, to support both developers and analysts. We show the potential of this approach in three usage scenarios and we also give some examples for these analysis plug-ins.

A Reference Architecture for Integrated Development and Run-Time Environments
Hossein Tajalli and Nenad Medvidović ORCID logo
(University of Southern California, USA)
The need to support different stages of a software system's life-cycle in a software development environment has resulted in the emergence of plug-ins that can monitor and adapt the resulting system's run-time environment. In several recent self-adaptive systems, the existence of these plug-ins has resulted in the integration of the development and run-time environments. We introduce a novel reference architecture that captures the architectures of disparate development environments-from those, such as traditional development environments, that have no run-time plug-ins, to the ones, such as the recently emerging development environments, that are fully integrated with the run-time environments. This reference architecture aids the study and understanding of development environments. More importantly, adherence to the architecture improves the run-time availability of certain critical system facilities while reducing the resource consumption of the integrated development and run-time environments.

XML Development with Plug-Ins as a Service
Siim Karus
(University of Tartu, Estonia)
XML has quickly become a mainstream language in software development. Not only is it used for message and document interchange, it is also used to define application logic and interfaces. However, modern general purpose integrated development environments have rather limited support for XML development. The wide variety of XML based languages makes it a challenge to build tools for comprehensive support of XML development. In this paper, we present a library exposed as an add-in for Microsoft Visual Studio and a command line tool to improve the experience of editing XML files by providing access to subscribable service-based pluggable helper tools. The tools offer developers new means to check their XML against good and bad practices and possibly even automatically fix errors in XML or improve the files conformance with development guidelines.

IDEs Need Become Open Data Platforms (As Need Languages and VMs)
Adrian Kuhn
(University of British Columbia, Canada)
Development environments have put quite some effort into being open platforms, however rewriting our own tools as plug-ins we found that while host platform and other plug-ins are open for addition of feature they are typically closed to accessing data. We report from our own experience rewriting the Codemap tool as an Eclipse plug-in as well as from maintaining the Moose platform and argue why IDEs need to adopt an Open Data paradigm to become valuable targets for development of novel tools. We propose that data created by plug-ins need to default to being openly shared with other plug-ins through uniform data structures. Adding appropriate meta-information to this setup will allow other plug-ins to even make use of this data in unanticipated ways. We further argue that opening up data should not stop at the development platform but that programing languages and even virtual machines should also open up their internal data for the greater benefit of development tool and API designers.

TacoPlug: An Eclipse Plug-In for TACO
Marcos Chicote and Juan Pablo Galeotti
(University of Buenos Aires, Argentina; CONICET, Argentina)
In this work we present TacoPlug, an Eclipse plug-in that lets users explore error traces output by the bounded verifier TACO. TacoPlug uses and extends TACO to provide a better debugging experience. TacoPlug interface allows the user to verify an annotated software using the TACO verifier . If TACO finds a violation to the specification, TacoPlug presents it in terms of the annotated source code. TacoPlug features several views of the error trace to facilitate fault understanding. It resembles any software debugger, but the debugging occurs statically without executing the program. We show the usability of our tool by means of a motivational example taken from a real-life software error.

Integrating a Set of Contract Checking Tools into Visual Studio
Manuel Fähndrich, Michael Barnett, Daan LeijenORCID logo, and Francesco Logozzo
(Microsoft Research, USA)

The EventB2Dafny Rodin Plug-In
Néstor Cataño, K. Rustan M. Leino, and Víctor Rivera
(University of Madeira, Portugal; Microsoft Research, USA)
This paper presents a translation of Rodin proof-obligations into the input language of Dafny, and the implementation of the translation as the EventB2Dafny Rodin plug-in. Rodin is a platform that provides support for Event-B. The paper uses a simplified Event-B model for social-networking to illustrate the translation and to describe the generated Dafny model. EventB2Dafny supports the full Event-B syntax and its full source code is available online.

Plugging In and Into Code Bubbles
Steven P. ReissORCID logo
(Brown University, USA)
Automatically building programs has been a research goal for over 40 years. Code search technology, particularly code search combined with directed program transformations and validation, has the potential to address many of the problems related to automatic programming. In this position paper we outline an approach to using code search as a tool for generating moderate sized programs, define three problems that will need to be addressed, and describe our first steps toward solving those problems.

SSELab: A Plug-In-Based Framework for Web-Based Project Portals
Christoph Herrmann, Thomas Kurpick, and Bernhard RumpeORCID logo
(RWTH Aachen University, Germany)
Tools are an essential part of every software engineering project. But the number of tools that are used in all phases of the software development life-cycle and their complexity is growing continually. Consequently, the setup and maintenance of current tool chains and development environments requires much effort and consumes a lot of time. One approach to counter this, is to employ web-based systems for development tasks, because centralized systems simplify the administration and the deployment of new features. But desktop IDEs play an important role in software development projects today, and will not be replaced entirely by web-based environments in the near future. Therefore, supporting a mixture of hosted tools and tools integrated into desktop IDEs is a sensible approach.
In this paper, we present the SSELab, a framework for web-based project portals that attempts to migrate more software development tools from desktop to server environments, but still allows their integration into modern desktop IDEs. It supports the deployment of tools as hosted services using plug-in systems on the server-side. Additionally, it provides access to these tools by a set of clients that can be used in different contexts, either from the command line, from within IDEs such as Eclipse, or from web pages. In the paper, we discuss the architecture and the extensibility of the SSELab framework. Furthermore, we share our experiences with creating an instance of the framework and integrating various tools for our own software development projects.

SAML Goes Eclipse - Combining Model-Based Safety Analysis and High-Level Editor Support
Michael Lipaczewski, Simon Struck, and Frank Ortmeier ORCID logo
(University of Magdeburg, Germany)
Software-intensive systems become more and more important in safety critical applications, mainly because of the rising number and complexity of embedded system. Many traditional safety analysis techniques where developed decades ago and thus cannot cope with the complexity of modern systems. Model based analysis techniques where developed to deal with the complexity of software-intensive systems. However, due to the lack of tool support these techniques are currently limited to highly skilled experts. Thus model-based analysis is rarely used by system engineers.
Based on the safety analysis modeling language (SAML) framework we propose the S³E, which integrates a complete safety analysis environment into the eclipse platform. S³E covers the whole safety analysis work flow. This implies a powerful editor for model creation, a seamless integration of model-analysis tools and presentation as well as evaluation of the analysis results into one environment. In this paper we present the current state of S³E and first experiences with the eclipse plug-in development.

Surfacing Scientific and Financial Data with the Xcel2RDF Plug-In
Marcia Lucas Pesce, Karin K. Breitman, and Marco Antonio Casanova
(PUC-Rio, Brazil; Fundação Getúlio Vargas, Brazil)
Given the astounding amount of data stored in spreadsheets and relational databases, a critical requirement for the evolution of the Semantic Web (SW) is the ability to convert data to SW compatible formats, such as RDF and OWL. The process by which data is transformed into RDF is known as triplification. This paper introduces Xcel2RDF, an MS Excel plug-in to support the triplification of spreadsheets, which minimizes the learning curve, as it is integrated into a widely used spreadsheet software tool. The plug-in is user-friendly, does not depend on the installation of additional software and does not require the user to leave his familiar environment, thereby avoiding problems reported as the major drawbacks of existing spreadsheet to RDF conversion tools. Finally, as a proof of concept, the paper illustrates how to use the tool to triplify statistical data.

OLAP2DataCube: An Ontowiki Plug-In for Statistical Data Publishing
Percy E. Rivera Salas, Michael Martin, Fernando Maia Da Mota, Sören Auer, Karin K. Breitman, and Marco Antonio Casanova
(PUC-Rio, Brazil; Globo.com, Brazil; University of Leipzig, Germany)
Statistical data is one of the most important sources of information, relevant for large numbers of stakeholders in the governmental, scientific and business domains alike. In this article, we introduce an Ontowiki plugin that extracts and publishes statistical data in RDF. We illustrate the plugin with a comprehensive use case reporting on the extraction and publishing on the Web of statistical data about 10 years of Brazilian government.

Short Papers

Developing a Plug-In Tool to Make OneNote an E-Textbook
Joseph G. Tront and John Cristy
(Virginia Tech, USA)
E-textbooks encourage the user to perform all of the operations typically performed with a hardcopy text in addition to some functions not possible with paper books. This project works to implement an e-textbook with as much capability as possible using software tools that are already in place. Because Microsoft OneNote already implements some of the desired functions of e-textbooks, it is a suitable software foundation for this work. This paper will detail the implementation of the e-textbook plug-in for OneNote and Windows. Specifically, it will discuss the methods of harnessing the built-in capabilities of OneNote such as page content creation and modification, specialized controls creation, and interaction with other programs.

IBM Software Development Kit for PowerLinux
Rodrigo Fraxino Araujo, Daniel Henrique Barboza, Otávio Busatto Pontes, Rafael Medeiros Teixeira, Renato Stoffalette João, Wainer Santos Moschetta, and Vinicius H. S. Durelli
(IBM, Brazil; University of São Paulo, Brazil)
Over the years, many software engineering activities have relied on the automated support afforded by tools. In order to maximize the benefits provided by tools, they are often retrofitted to pre-existing development environments that enable them to capitalize on facilities provided by compilers, debuggers, and profilers. Integrated Development Environments (IDEs), for instance, comprise a myriad of tightly-knit tools (i.e., plugins) designed to boost programmer productivity. Due to the advantages that such integrated environments have brought to the mainstream, they have become a de facto standard to implement complex software systems. Eclipse is one of the most widely used contemporary IDEs. In order to integrate a set of mainstream C/C++ development tools along with several in-house IBM tools, we have used Eclipse a as basis to bring together a SDK comprising the necessary tools to assist in the development and analysis of C/C++ programs for Power Architecture, namely, the IBM Software Development Kit for PowerLinux. In this paper, we describe the approach we used to port such tools into plugins, the main technical hurdles we ran into during the porting, the workarounds we used to deal with such issues, and some quirks of the target platform (i.e., Power machines).

Rumadai: A Plug-In to Record and Replay Client-Side Events of Web Sites with Dynamic Content
Asım Yıldız, Barış Aktemur, and Hasan Sözer
(Özyeğin University, Turkey)
Reproducing user events when testing web pages is challenging because of the dynamic nature of the web content and potential dependency on third party content providers. We present Rumadai, a Visual Studio plug-in, that helps web programmers test web pages by recording and replaying client-side events. Rumadai injects code into web pages to be deployed at servers. The injected code, written in JavaScript, records user events as well as client-side dynamic content requests (e.g. via Ajax or Jsonp) and their responses. Recorded events and responses are then sent to a remote database via HTTP POST. Web page developers can query the saved client data, again using Rumadai seamlessly from Visual Studio, to replay all or a subset of events on a browser.

A Modular Environment for Software Development and Re-engineering
Salvatore Campana, Andrea Poli, Luca Spalazzi, and Francesco Spegni
(Computer VAR ITT, Italy; Università Politecnica delle Marche, Italy)
Traditional software development processes are designed to deal with the construction of new software systems. We believe the software development methodologies should include from the beginning the possibility of a re-engineering phase. With our work we identify the main characteristics that make software (re)engineering tools useful and usable Developing them in a modular architecture allows for a better integration with the developer’s working habits.

proc time: 0.84