Peter Sommerlad

Automated support for software development with frameworks

This document presents some of the results of an industrial research project on automation of software development. The projects objective is to improve productivity and quality of software development. We see software development based on frameworks and libraries of prefabricated components as a step in this direction. An adequate development style consists of two complementary activities: the creation of frameworks and new components for functionality not available and the composition and configuration of existing components. Just providing adequate frameworks and components does not necessarily yield automation and efficiency of software development. We developed the concept of relations between software components as a foundation for abstraction, reuse and automatic code generation for component interrelationship. Furthermore we suggest to supplement frameworks with an active cookbook consisting of active recipes which guide the software developer in the use of framework elements. In this paper our concept of using relations among software components is presented and the active cookbook is illustrated as a means for developer guidance. We created a prototype to demonstrate these concepts.

Retaining comments when refactoring code

Todays software developer depends on automated refactoring tools. While implementing such refactoring tools based on the Eclipse platform for a variety of languages, we faced the problem that carefully crafted formatting and comments can disappear when refactoring source code. This is annoying. Therefore, a useful refactoring tool should keep comments and move them along with the source code they belong to. We present different approaches on how to retain comments when refactoring source code. Usually comments are not present in an abstract syntax tree (AST) used by an integrated development environment (IDE). We achieve comment retention by associating them with nodes in an AST. The different attempts on gathering comments and implementing that association are shown and evaluated. Details of comment handling in different refactoring plug-ins that we have implemented for Eclipse, are given as well as a brief comparison with comment handling when refactoring with the Eclipse Java Development Tools (JDT). We hope, that this paper enables others to implement comment-preserving refactoring tools for more languages and IDEs. Every programmer, language and IDE deserves good refactoring support or they might become endangered.

Refactoring support for the C++ development tooling

This article reveals our work on refactoring plug-ins for Eclipses C++ Development Tooling (CDT). With CDT a reliable open source IDE exists for C/C++ developers. Unfortunately it has been lacking of overarching refactoring support. There used to be just one single refactoring - Rename. But our plug-in provides several new refactorings which support a C++ developer in his everyday work.

Cross language refactoring for Eclipse plug-ins

This article presents our research on how a cross-language refactoring could be implemented in an Eclipse Plugin. A non-Java language running on the Java virtual machine JVM interacts with Java code. Refactorings in either language might break the code written in the other. To keep the code synchronized, cross-language Refactoring is needed. In this article we describe how such a cross-language feature can be implemented. Which parts of the Java Development Toolkit JDT of Eclipse you can use and what has to be written at your own. The examples are shown for the language Groovy for which we implemented refactoring support for the Eclipse Plug-in (GRE-Refactoring), but the basic architecture can also be used for others like Scala.

Experience report - Wiki for law firms

This paper shows the experiences of a law firm with adopting Wiki Webs for knowledge management and collaboration over the last two years. Wikis created a business advantage for the lawyers through better re-use of their know-how within the firm. In addition, external Wikis for clients created new revenue opportunities and higher client satisfaction. The law firm uses a very simple Wiki implementation that makes it very easy to establish new Wiki instances. For client collaboration the Wiki was secured and extended with a simple user management system.

CUTE: C++ unit testing easier

This article describes the design and use of the CUTE C++ testing framework and its integration into the Eclipse C++ Development Tooling. Unit testing supports code quality and is a corner stone of agile software development. CUTE and its Eclipse plug-in are an easy to use C++ testing framework.

Refactoring support for the groovy-eclipse plug-in

This article presents our refactoring plug-in for the Groovy-Eclipse Plug-in. Refactoring is a very important technique for every software engineer to ensure the healthiness of his code and a cornerstone of agile software development. In our project we introduce refactoring support for Groovy-Eclipse, with six automated refactorings as well as a source code formatter. Since Java and Groovy are that closely related we also analyzed and documented the options to introduce crosslanguage refactorings between Java and Groovy.

Ruby refactoring plug-in for eclipse

This article presents our refactoring plug-in for the Eclipse Ruby Development Tools IDE. Refactoring is a very important technique for every software engineer to ensure the healthiness of his code and a cornerstone of agile software development. We have implemented sixteen automated refactorings and three code generators, for example Rename Variable and Extract Method.

Enforcing Techniques and Transformation of C/C++ Source Code to Heterogeneous Hardware

Besides well-known CPU based architectures, the so-called accelerators (GPU, DSP, FPGA) are about to gain ground in everyday programming, computing tasks. However, programming such computation units is quite different from traditional programming for CPUs,, special skills are required from the developers. In this paper we present techniques, tooling support for the developers in the first step of re-engineering for parallelism in heterogeneous parallel platforms, namely to assure that the code to be offloaded to an accelerator conforms to its specific requirements by identifying the possible violations in the source code,, also by providing automatic code transformations for their elimination.

Scaps: type-directed API search for Scala

Type-directed API search, using queries composed of both keywords and type signatures to retrieve definitions from APIs, are popular in the functional programming community. This search technique allows programmers to easily navigate complex and large APIs in order to find the definitions they are interested in. While there exist some effective approaches to address type-directed API search for functional languages, we observed that none of these have been successfully adapted for use with statically-typed, object-oriented languages. The challenge here is incorporating large and unified inheritance hierarchies and the resulting prevalence of subtyping into an API retrieval model. We describe a new approach to API retrieval and provide an implementation thereof for the Scala language. Our evaluation with queries mined from Q&A websites shows that the model retrieves definitions from the Scala standard library with 94% of the relevant results in the top 10.