Developing tools as plug-ins: TOPI 2012 special issue

Authors


SUMMARY

Our knowledge as to how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a preexisting development that can provide integration with existing elements such as compilers, debuggers, profilers, and visualizers as well as numerous other development and, often, runtime tools. However, building tools as plug-ins can be challenging and raise many questions: How do they interact with the core environment? How do they interact with other existing plug-ins, especially as each developer may choose a different set of plug-ins. How can we share tools across different and future core development environments? How do we evaluate the usefulness of the tools? The series of workshops on Developing Tools as Plug-ins (TOPI) tries to address these questions. Researchers are invited to present position papers spotting the medium-term and long-term challenges of developing tools as plug-ins as well as research contributions identifying recent successful tools as plug-ins, characteristics of good plug-ins and reports of the main difficulties in implementing plug-ins in current platforms. This issue includes extended versions of the best papers presented at TOPI 2012. Copyright © 2014 John Wiley & Sons, Ltd.

1 ABOUT THIS SPECIAL ISSUE

The International Workshop on Developing Tools as Plug-Ins (TOPI) is a venue for researchers and practitioners interested in plug-in development. The main interest is understanding the opportunities and challenges of developing tools as plug-ins, and thus, we seek for discussions regarding the characteristics of good plug-ins, interoperability requirements to making tools available across platforms, recent successful tools as plug-ins, and foreseen medium-term and long-term challenges of tools as plug-ins.

The 2nd Workshop on Tools as Plug-ins (TOPI 2012) [1] was held in Zurich, Switzerland on June 3, 2012. We received 32 submissions from authors of 17 different countries. These papers were reviewed by at least three members of our program committee, composed by 13 experts from academia and industry. After the reviewing process, we ended up accepting 14 submissions as full papers and four as short papers. The short papers had to present their work during a demo session.

In addition, the authors of accepted full papers who presented concrete plug-ins or tools were also invited to showcase them during the demo session. The final program comprised position papers, including new proposals for plug-in-aware architectures, discussions about plug-in ecosystems, and interaction with their development environments and runtimes. We also accepted papers explaining the design and implementation of different kind of tools as plug-ins.

The program committee selected the best papers, and the authors of these papers were invited later to submit their extended version to be included in a special issue. After the review process, five of those papers were accepted and appear in this special issue.

This a brief description of the main contributions of each paper.

Reiss et al. [2] introduced Code Bubbles, which is a new integrated development environment (IDE) front-end that, instead of displaying programs as large chunks of text, relies on displaying information in context inside connected smaller windows called bubbles. Implementing such a new IDE on top of another existing IDE like Eclipse is challenging. The authors explained how they overcame the difficulties of integrating Code Bubbles on top of Eclipse. They also described the plug-in architecture supported by Code Bubbles that uses message passing as a means to communicate between plug-ins with the core IDE system. They also showed how the resultant architecture is flexible enough to support collaboration, different back-ends, and a cloud-based environment.

Naujokat et al. [3] discussed the advantages of using the jABC framework for plug-in development. The jABC, which is a graph-drawing plug-in framework, has been evolving during the last 10 years. According to the authors, using this framework plug-in, developers 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. Within the jABC, the intended plug-in functionality can be conveniently modeled in terms of graphical workflows, which can then fully automatically be translated to a running code using jABC's integrated code generation framework Genesys in order to enhance the semantics and the feature diversity of the jABC. The authors illustrated the idea with a series of examples and presented some new extensions.

Tajali et al. [4] presented a classification of software development environments, especially those designed for self-adaptive systems, by rationalizing their architecture. Self-adaptive life cycle environments are tightly integrated with runtime environments, and understanding its architecture and expected quality attributes led authors to propose iDARE, a reference architecture for such systems. iDARE was used to reason about some potential shortcomings of existing systems. Then, the authors described how adherence to iDARE improves quality attributes such as availability, adaptability, and robustness.

Chicote et al. [5] introduced an interesting Eclipse plug-in for a static verifier. Using the plug-in, it is possible to explore JML/JFSL annotations, trace errors based on the annotations, evaluate JML/JFSL expressions in any point of the trace, and visualize the heap in any point of the trace. Often, formal tools, including a static verifier, do not provide a practical interface, but their plug-in provides a similar interface to existing debugging tools so that it will provide a better debugging experience.

XML is widely used as part of software development, but many developers still edit XML files using simple text or minimal XML editors. Karus [6] proposed an IDE support for XML development that can check and detect errors in XML files using good and bad practices. In addition, it can automatically fix errors or improve XML files based on given development guidelines.

ACKNOWLEDGEMENTS

We would like to thank the program committee of TOPI 2012 and the additional reviewers mentioned who are named in the Workshop Editorial.

Ancillary