ICSE 2013 - May 18-26, 2013, San Francisco, CA, USA
Powered by
Conference Publishing Consulting

2013 3rd International Workshop on Developing Tools as Plug-Ins (TOPI), May 21, 2013, San Francisco, CA, USA

TOPI 2013 – Proceedings

Contents - Abstracts - Authors

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

Title Page

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 pre-existing development environment that can provide integration with existing elements such as compilers, debuggers, profilers and visualizers. Some also exist beyond development time and work with the runtime. A further challenge is to develop tools that can span different — and future — development environments and runtimes. This workshop should of interest to all those interested in developing tools as plug-ins for IDEs, runtimes and browsers. We will examine the categories of problems that are best solved in this way, and look at the future challenges.
Developing a Domain-Specific Plug-In for a Modelling Platform: The Good, the Bad, the Ugly
Lionel Montrieux, Yijun Yu, and Michel Wermelinger
(Open University, UK)
Domain-Specific Modelling Languages (DSML) allow software engineers to use the techniques and tools of Model-Driven Engineering (MDE) to express, represent and analyse a particular domain. By defining DSMLs as UML profiles, i.e. domain-specific extensions of the UML metamodel, development time for DSMLs can be greatly reduced by extending existing UML tools. In this paper, we reflect on our own experience in building rbacUML, a DSML for Role-Based Access Control modelling and analysis, as a plugin for a UML modelling platform. We describe what motivated our choice, and discuss the advantages and drawbacks of using an existing platform to develop a DSML on top of UML and additional analysis tooling.
Article Search
ReFit: A Fit Test Maintenance Plug-In for the Eclipse Refactoring Plug-In
Michael Druk and Martin Kropp
(Sapiens Int., Israel; FHNW, Switzerland)
The Fit framework is a widely established tool for automated acceptance test-driven development (ATDD). Fit stores the test specification separate from the test fixture code in an easily human readable and editable tabular form in HTML format. Additional tools like the FitPro plugin or FitNesse support the writing of test specifications and test fixtures from within the Eclipse IDE or the Web. With the increasing popularity of agile test-driven software development, maintenance of the evolving and growing test base has become an important issue. However, there has been no support yet for automated refactoring of Fit test cases. In a recent research project, we developed the Eclipse plugin ReFit for automated refactoring of Fit test cases. Fit test refactoring can occur due to changing requirements or changing Java code, which in either case means a cross-language refactoring to keep test specification and test fixture in sync. In this paper the concept for the development of the ReFit Eclipse Plugin is described, which significantly reduces the effort for Fit test maintenance and makes refactoring less error prone. Besides a tight integration into the existing Eclipse refactoring plugin, major goals of the plugin were to make it easy extensible for additional refactorings, new fixture types and further test specification file formats. Challenges faced when adding new and modifying existing Eclipse refactoring behavior are described and are due to the strong dependency on the Eclipse JDK and LTK features, and the solutions developed are presented.
Article Search
Challenges in Developing a Software Architecture Evolution Tool as a Plug-In
Jeffrey M. Barnes and David Garlan
Recent research has developed a theoretical basis for providing software architects with better support for planning and carrying out major evolutions of software systems. However, these theoretical models have yet to be implemented in a complete, integrated tool. In this paper, we consider some of the challenges involved in developing such a tool as a plug-in to an existing architecture modeling framework. We present an experience report based on the development of a prototype architecture evolution tool as a plug-in to MagicDraw, a commercial UML tool. We find that there are many practical obstacles to developing tools for architecture evolution modeling as plug-ins, and we discuss some of the key factors that plug-in developers should weigh when considering frameworks.
Article Search
Towards Accessible Integration and Deployment of Formal Tools and Techniques
Andrei Lapets, Rick Skowyra, Azer Bestavros, and Assaf Kfoury
(Boston University, USA)
Computer science researchers in the programming languages and formal verification communities, among others, have produced a variety of automated assistance and verification tools and techniques for formal reasoning. While there have been notable successes in utilizing these tools on the development of safe and secure software and hardware, these leading-edge advances remain largely underutilized by large populations of potential users that may benefit from them. In particular, we consider researchers, instructors, students, and other end users that may benefit from instant feedback from lightweight modeling and verification capabilities when exploring system designs or formal arguments. We describe Aartifact, a supporting infrastructure that makes it possible to quickly and easily assemble interacting collections of small domain-specific languages, as well as translations between those languages and existing tools (e.g., Alloy, SPIN, Z3) and techniques (e.g., evaluation, type checking, congruence closure); the infrastructure also makes it possible to compile and deploy these translators in the form of a cloud-based web application with an interface that runs inside a standard browser. This makes more manageable the process of exposing a limited, domain-specific, and logistically accessible subset of the capabilities of existing tools and techniques to end users. This infrastructure can be viewed as a collection of modules for defining interfaces that turn third-party formal modeling and verification tools and techniques into plug-ins that can be integrated within web-based interactive formal reasoning environments.
Article Search
Integrating S6 Code Search and Code Bubbles
Steven P. Reiss
(Brown University, USA)
We wanted to provide a tool for doing code search over open source repositories as part of the Code Bubbles integrated development environment. Integrating code search as a plug-in to Code Bubbles required substantial changes to the S6 code search engine and the development of appropriate user interfaces in Code Bubbles. After briefly reviewing Code Bubbles and the S6 search engine, this paper describes the integration strategy, the front end for code search, the modifications to the code search engine to handle context-based search, and the user interface for handling the results of the search.
Article Search
A CPI Breakdown Model Plug-In for Optimizing Application Performance
Rodrigo Fraxino Araujo, Daniel Barboza, Rafael Sene, Rafael Teixeira, Renato João, and Wainer Santos Moschetta
(IBM, Brazil)
Effectiveness and quality are fundamental characteristics for the development of a product. In order to support them, one needs to ensure that an application optimization level is at its best. The most widely used metric for evaluating an application performance is the CPI (Cycles Per Instruction), i.e., the number of clock cycles that takes place when an instruction is executed. We have developed a CPI Breakdown Model Plug-in, that automates the profiling of an application in the Power architecture, breaking it down into several groups of CPI events and metrics in order to identify possible bottlenecks. When analyzing such events and metrics the user can become aware of which operations are causing the processor to stall, and consequently enhance the application source code. We have discussed the adaptation of some command-line tools to be used by our CPI plug-in, which is integrated into the IBM Software Development Toolkit for PowerLinux, an Eclipse based IDE comprising a set of mainstream C/C++ development tools along with several in-house IBM ones. A case study that shows the usefulness of our approach is presented and details on how to optimize an application are discussed.
Article Search
TerraME GIMS: An Eclipse Plug-In for Environmental Modeling
Tiago Lima, Tiago Carneiro, Sergio Faria, Pablo Silva, and Miguel Pessoa
(UFOP, Brazil; UFMG, Brazil)
TerraME is a platform for modeling and simulation of environmental systems that offers a conceptual basis and services to build environmental models through a high-level programming language called Terra Modeling Language. However, the use of a programming language is still a limiting factor since its main users are researchers with different backgrounds who usually lack basic knowledge of algorithms and programming techniques. So, this work presents the development of TerraME GIMS, an Eclipse plug-in for environmental systems modeling through visual metaphors that graphically represent the model
Article Search
A Visual Studio Plug-In for CProver
Mohamed Nassim Seghir and Daniel Kroening
(University of Oxford, UK)
In recent years, automatic software verification has emerged as a complementary approach to program testing for enhancing software quality. Finding bugs is the ultimate aim of software verification tools. How do we best support the programmer who has to diagnose and understand those bugs? Unfortunately, most of the existing tools do not offer enough support for error diagnosis. We have developed a plug-in which implements a graphical user interface for the CProver tools within the Visual Studio IDE. Our plug-in enables visual debugging and error trace simulating within C programs as well as co-debugging C programs in tandem with wave-form views of hardware designs. Another feature of our plug-in is background verification. Each time a program source is saved, the verification process is silently triggered in background. If an error is found, its location is highlighted in the program. The user interacts directly with the program source to obtain information about the error.
Article Search
A Rigorous Methodology for Analyzing and Designing Plug-Ins
Marieta V. Fasie, Anne E. Haxthausen, and Joseph R. Kiniry
(DTU, Denmark)
Today, GUI plug-ins development is typically done in a very ad-hoc way, where developers dive directly into implementation. Without any prior analysis and design, plug-ins are often flaky, unreliable, difficult to maintain and extend with new functionality, and have inconsistent user interfaces. This paper addresses these problems by describing a rigorous methodology for analyzing and designing plug-ins. The methodology is grounded in the Extended Business Object Notation (EBON) and covers informal analysis and design of features, GUI, actions, and scenarios, formal architecture design, including behavioral semantics, and validation. The methodology is illustrated via a case study whose focus is an Eclipse environment for the RAISE formal method's tool suite.
Article Search
Lightweight Tool Coordination: Path* - A Minimal Framework for Tool Coordination
Reid D. McKenzie and Dewayne E. Perry
(University of Texas at Austin, USA)
We present a lightweight tool for coordinating tool usage in a structured and unobtrusive manner allowing for the formal description and implementation of development cycles with minimal human intervention. This tool, here and after referred to as ``Path*'' seeks to provide a minimal yet powerful framework for tool coordination by scripting actions to be triggered on events such as disk writes to a project directory and version control system commits. These events execute user-defined scripts for the purpose of automating tasks such as partial rebuilds and style checking in an IDE and platform independent framework.
Article Search

proc time: 0.07