Powered by
2012 Second International Workshop on Developing Tools as Plug-Ins (TOPI),
June 3, 2012,
Zurich, Switzerland
Second International Workshop on Developing Tools as Plug-Ins (TOPI)
Preface
Foreword
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.
@InProceedings{TOPI12p1,
author = {Todd W. Schiller and Brandon Lucia},
title = {Playing Cupid: The IDE as a Matchmaker for Plug-Ins},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {1--6},
doi = {},
year = {2012},
}
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.
@InProceedings{TOPI12p7,
author = {Stefan Naujokat and Anna-Lena Lamprecht and Bernhard Steffen and Sven Jörges and Tiziana Margaria},
title = {Simplicity Principles for Plug-In Development: The jABC Approach},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {7--12},
doi = {},
year = {2012},
}
An Architectural Blueprint for a Pluggable Version Control System for Software (Evolution) Analysis
Giacomo Ghezzi,
Michael Würsch,
Emanuel Giger, and
Harald C. Gall
(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.
@InProceedings{TOPI12p13,
author = {Giacomo Ghezzi and Michael Würsch and Emanuel Giger and Harald C. Gall},
title = {An Architectural Blueprint for a Pluggable Version Control System for Software (Evolution) Analysis},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {13--18},
doi = {},
year = {2012},
}
A Reference Architecture for Integrated Development and Run-Time Environments
Hossein Tajalli and
Nenad Medvidović
(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.
@InProceedings{TOPI12p19,
author = {Hossein Tajalli and Nenad Medvidović},
title = {A Reference Architecture for Integrated Development and Run-Time Environments},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {19--24},
doi = {},
year = {2012},
}
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.
@InProceedings{TOPI12p25,
author = {Siim Karus},
title = {XML Development with Plug-Ins as a Service},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {25--30},
doi = {},
year = {2012},
}
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.
@InProceedings{TOPI12p31,
author = {Adrian Kuhn},
title = {IDEs Need Become Open Data Platforms (As Need Languages and VMs)},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {31--36},
doi = {},
year = {2012},
}
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.
@InProceedings{TOPI12p37,
author = {Marcos Chicote and Juan Pablo Galeotti},
title = {TacoPlug: An Eclipse Plug-In for TACO},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {37--42},
doi = {},
year = {2012},
}
Integrating a Set of Contract Checking Tools into Visual Studio
Manuel Fähndrich,
Michael Barnett,
Daan Leijen, and
Francesco Logozzo
(Microsoft Research, USA)
@InProceedings{TOPI12p43,
author = {Manuel Fähndrich and Michael Barnett and Daan Leijen and Francesco Logozzo},
title = {Integrating a Set of Contract Checking Tools into Visual Studio},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {43--42},
doi = {},
year = {2012},
}
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.
@InProceedings{TOPI12p49,
author = {Néstor Cataño and K. Rustan M. Leino and Víctor Rivera},
title = {The EventB2Dafny Rodin Plug-In},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {49--54},
doi = {},
year = {2012},
}
Plugging In and Into Code Bubbles
Steven P. Reiss
(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.
@InProceedings{TOPI12p55,
author = {Steven P. Reiss},
title = {Plugging In and Into Code Bubbles},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {55--60},
doi = {},
year = {2012},
}
SSELab: A Plug-In-Based Framework for Web-Based Project Portals
Christoph Herrmann,
Thomas Kurpick, and
Bernhard Rumpe
(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.
@InProceedings{TOPI12p61,
author = {Christoph Herrmann and Thomas Kurpick and Bernhard Rumpe},
title = {SSELab: A Plug-In-Based Framework for Web-Based Project Portals},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {61--66},
doi = {},
year = {2012},
}
SAML Goes Eclipse - Combining Model-Based Safety Analysis and High-Level Editor Support
Michael Lipaczewski,
Simon Struck, and
Frank Ortmeier
(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.
@InProceedings{TOPI12p67,
author = {Michael Lipaczewski and Simon Struck and Frank Ortmeier},
title = {SAML Goes Eclipse - Combining Model-Based Safety Analysis and High-Level Editor Support},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {67--72},
doi = {},
year = {2012},
}
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.
@InProceedings{TOPI12p73,
author = {Marcia Lucas Pesce and Karin K. Breitman and Marco Antonio Casanova},
title = {Surfacing Scientific and Financial Data with the Xcel2RDF Plug-In},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {73--78},
doi = {},
year = {2012},
}
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.
@InProceedings{TOPI12p79,
author = {Percy E. Rivera Salas and Michael Martin and Fernando Maia Da Mota and Sören Auer and Karin K. Breitman and Marco Antonio Casanova},
title = {OLAP2DataCube: An Ontowiki Plug-In for Statistical Data Publishing},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {79--83},
doi = {},
year = {2012},
}
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.
@InProceedings{TOPI12p84,
author = {Joseph G. Tront and John Cristy},
title = {Developing a Plug-In Tool to Make OneNote an E-Textbook},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {84--85},
doi = {},
year = {2012},
}
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).
@InProceedings{TOPI12p86,
author = {Rodrigo Fraxino Araujo and Daniel Henrique Barboza and Otávio Busatto Pontes and Rafael Medeiros Teixeira and Renato Stoffalette João and Wainer Santos Moschetta and Vinicius H. S. Durelli},
title = {IBM Software Development Kit for PowerLinux},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {86--87},
doi = {},
year = {2012},
}
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.
@InProceedings{TOPI12p88,
author = {Asım Yıldız and Barış Aktemur and Hasan Sözer},
title = {Rumadai: A Plug-In to Record and Replay Client-Side Events of Web Sites with Dynamic Content},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {88--89},
doi = {},
year = {2012},
}
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.
@InProceedings{TOPI12p90,
author = {Salvatore Campana and Andrea Poli and Luca Spalazzi and Francesco Spegni},
title = {A Modular Environment for Software Development and Re-engineering},
booktitle = {Proc.\ TOPI},
publisher = {IEEE},
pages = {90--91},
doi = {},
year = {2012},
}
proc time: 0.1