Practitioners Reports

ChairsOlaf Zimmermann
IBM Research GmbH
Nadyne Mielke

Practitioner reports focus on software and development in actual practice. These reports come from practitioners reporting on their experiences, and from researchers presenting case studies relating to practice. Reports may concern software systems themselves, or the development process and related issues. Approaches of perennial interest include how new concepts are actually used in real projects, and how practice requires coming up with novel ideas. This year, we particularly encouraged reports focusing on architecture and integration of application software, particularly those which address key requirements, design, and implementation aspects pertaining to the entire software development lifecycle.

Development Program

Refactoring and Method Agility

Agile Architecture Methodology: Long Term Strategy Interleaved with Short Term Tactics

Room: 205Date: Oct 21, 2008Time: 15:30 - 16:15
Ethan Hadar
CA Inc.
Gabriel M. Silberman
CA Inc.


Tactical agile development and strategic architectural evolution are viewed as opposite ends of the development spectrum, with the long-term value of applying an architecture-centric approach seemingly at odds with rapid development, featuring its informal documentation activities. The value of a long-term vision, or architecture, is particularly high in the context of product integration and research. However, there is also benefit in rapid and early feedback on incremental deliverables, as featured in agile development. To extract the main benefits of both worlds we introduce the CA Agile Architecture (C3A) method, targeted for the architecture and design phases of the development life cycle. Its foundation is the Reference and Implementation Architecture, which features a lean one-page per component contract, as well as several abstraction levels. The C3A artifacts are governed by a cyclic process of architectural evaluation and evolution, with accompanying coaching and training activities. This work-in-progress is being prototyped with three product teams, varying in team size, product maturity and complexity, and geographical location. C3A features a common tactical-focused agenda for the functional and system architectures, with minimally overlapping strategic views.

Retaining Comments when Refactoring Code

Room: 205Date: Oct 21, 2008Time: 16:15 - 17:00
Peter Sommerlad
IFS Institute for Software at HSR Rapperswil
Guido Zgraggen
IFS Institute for Software at HSR Rapperswil
Thomas Corbat
IFS Institute for Software at HSR Rapperswil
Lukas Felber
IFS Institute for Software at HSR Rapperswil


Today's 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.

State-of-the-Art Architectures for Transportation and Astronomy

Decentralized Control of Automatic Guided Vehicles: Applying Multi-Agent Systems in Practice

Room: 205Date: Oct 22, 2008Time: 15:30 - 16:15
Danny Weyns
Katholieke Universiteit Leuven


An automatic guided vehicle (AGV) transportation system is a fully automated system that provides logistic services in an industrial environment such as a warehouse or a factory. Traditionally, the AGVs that execute the transportation tasks are controlled by a central server via wireless communication. In a joint effort between Egemin, an industrial manufacturer of AGV transportation systems, and DistriNet Labs research at the Katholieke Universiteit Leuven, we developed an innovative decentralized architecture for controlling AGVs. The driving motivations behind decentralizing the control of AGVs were new and future quality requirements such as flexibility and openness. At the software architectural level, the AGV control system is structured as a multi-agent system; the detailed design and implementation is object-oriented. In this paper, we report our experiences with developing the agent-based control system for AGVs. Starting from system requirements, we give an overview of the software architecture and we zoom in on a number of concrete functionalities. We reflect on our experiences and report lessons learned from applying multi-agent systems for real-world AGV control.

NOAO Imaging Meta Data Quality Improvement - A Case Study of the Evolution of a Service Oriented System

Room: 205Date: Oct 22, 2008Time: 16:15 - 17:00
Sonya J. Lowry
National Optical Astronomy Observatory


Due to the natures of legacy astronomical imaging meta data acquisition and storage technologies and techniques at the National Optical Astronomy Observatory, the challenge of methodically improving the quality of such information has been insurmountable until now. The diversity of the sources and lack of cohesive effort along with technologies that enable silo style efforts have contributed to the current, disorganized state of the collection of astronomical imaging information. By meeting these issues with a solution that combines policy and technology support for implementing master data management, use of transformations that enable continued improvements and a history of changes made, and a modular architecture based upon services that are federated over a flexible, robust communications architecture, the NOAO Archive System can assure improvements in the quality of the imaging meta data now and into the future.

Overcoming Non-Functional Challenges in Development and Integration

Performance Pitfalls in Large-Scale Java Applications Translated from COBOL

Room: 205Date: Oct 23, 2008Time: 15:30 - 16:00
Toshio Suganuma
IBM Tokyo Research Laboratory
Toshiaki Yasue
IBM Tokyo Research Laboratory
Tamiya Onodera
IBM Tokyo Research Laboratory
Toshio Nakatani
IBM Tokyo Research Laboratory


There is a growing need to translate large-scale legacy mainframe applications from COBOL to Java. This is to transform the applications into modern Web-based services, without sacrificing the original programming investments. Most often, COBOL-to-Java translators are used first for the base program transformations, and then corrections and fine tuning are applied by hand to the resulting code. However, there are many serious performance problems that frequently appear in those Java programs translated from COBOL, and it is particularly difficult to identify problems hidden deeply in large-scale middleware applications. This paper describes the details of some performance pitfalls that easily slip into large-scale Java applications translated from COBOL using a translator, and that are primarily due to the impedance mismatch between the two languages. We classified those problems into four categories: eager object allocations, exceptions in normal control flows, reflections in common paths, and inappropriate use of the Java class library. Using large-scale production middleware, we present detailed evaluation results, showing how much overhead these problems can cause, both independently and collectively, in real-world scenarios. The work should be a step forward toward understanding the problems and building tools to generate Java programs that have comparable performance with corresponding COBOL programs.

Processing Heterogeneous Abstract Syntax Trees with the Mutable Class Pattern

Room: 205Date: Oct 23, 2008Time: 16:00 - 16:30
Nikolay Malitsky
Brookhaven National Laboratory


The Mutable Class Pattern is an alternative extensible solution to the Visitor pattern for building configurable associations of heterogeneous structures with diverse algorithms. Initially it was introduced in the framework of the Unified Accelerator Libraries. The scope of the Mutable Class however appears to not be limited to the modeling applications due to the optimal combination of several approaches. This paper presents the application of the Mutable Class pattern to the traversal of heterogeneous abstract syntax trees. The application is based on the JastAdd configurable metacompiler construction system.

A Workload Model for Topic-based Publish/Subscribe Systems

Room: 205Date: Oct 23, 2008Time: 16:30 - 17:00
Zafar U. Singhera
Oracle Corporation


Publish/Subscribe is an asynchronous messaging paradigm that has been an integral part of modern Message Oriented Middle-ware (MOM) frameworks. However, recent initiatives to enhance usability and friendliness of modern web-based clients have ex-tended the use of publish/subscribe schemes beyond middleware. Some of the recent protocols, like Bayeux [6], use topic-based publish/subscribe scheme to exchange messages between front-end web-based clients and back-end servers. This paper shares our experience in designing a load-generation framework for benchmarking of an HTTP-based publish/subscribe module for an enterprise Java application server. The paper starts with an introduction to topic-based publish/subscribe paradigm by describing the major entities, along with their roles and relation-ships. Major issues related to modeling and benchmarking sys-tems in a topic-based publish/subscribe paradigm are highlighted. We propose an abstract model that is helpful in workload genera-tion, data collection, and benchmarking of such systems. We also share our experience in designing and using a framework for per-formance engineering and improvements of a publish/subscribe system. This framework uses our proposed model. The paper con-cludes with sharing short-comings of the proposed model and framework, and our plans to extend this work for other asynchro-nous and synchronous messaging paradigms.