Demonstrations

OOPSLA demonstrations provide an unique opportunity for companies and universities to show their latest work to an experienced audience. This can be work in progress, commercial applications, proof of concepts, results of academic research, tools, systems or any topic that has interesting object-oriented aspects. Demonstrations are not focused on selling a product but to highlight, explain and present the technical aspects of it. Demonstrators may actively solicit feedback from the usually very technically savvy audience.

Supporting Software Product Lines Development: FLiP - Product Line Derivation Tool

Abstract

Software Product Lines adoption demands tool support development. We present FLiP, a suite of tools consisted of: FLiPEx, a refactoring tool that extracts product variations; FLiPG, responsible for updating the feature model after refactorings; and FLiPC, responsible for building the final products. FLiP was implemented in a industrial-strength product line.

Quota Queue

Abstract

Quota Queue is a new type of queue data structure that provides quota based enqueue and prioritized, predictable, guaranteed and fair retrieval of items during dequeue. The demonstration contains a Microsoft .NET test bench application that demonstrates the properties of Quota Queue and its performance compared to Priority Queues.

Aspect Weaving for OSGi

Abstract

This will be a live demonstration of aspect weaving for OSGi. Attendees will see how aspects can be modularized into OSGi bundles using Equinox Aspects, a load-time weaving extension for Equinox. The demo features full OSGi dynamics for aspects at runtime and using Equinox Aspects together with Spring Dynamic Modules.

Refactoring Support for the Groovy-Eclipse Plug-in

Abstract

This demonstration and poster present our refactoring plug-in for the Groovy-Eclipse Plug-in. In the course of our bachelor thesis project we implemented six automated refactorings as well as a source code formatter for the Groovy-Eclipse plug-in. We also analyzed options for cross-language refactorings between Java and Groovy.

Automated Testing of Non-functional Requirements

Abstract

We will present an automated toolkit that tests non-functional requirements. The toolkit is based on extracting and composing metrics and logs from the system during controlled, but self-adjusting, usage scenarios. Our presentation will give a walk-through of the testing approach and an example implementation of the toolkit.

The Maxine Virtual Machine and Inspector

Abstract

The meta-circular, IDE-friendly research VM Maxine promotes agile managed runtime development. Our guided VM tour features the Maxine Inspector tool, which combines object browsing and multi-level debugging, taking a close look at prominent internal VM data structures and mechanisms. The Maxine VM and Inspector are available under GPLv2 at http://maxine.dev.java.net.

Tool Support for the Static Extraction of Sound Hierarchical Representations of Runtime Object Graphs

Abstract

Ownership domain annotations specify in code architectural intent related to object encapsulation and communication. These annotations also enable the static extraction of a sound hierarchical representation of the runtime object graph. The tool support consists of one Eclipse plugin to typecheck the annotations inserted as Java 1.5 annotations, and another to extract a representation of the runtime object graph abstracted by ownership hierarchy and by types.

Tool Support for Statically Checking the Structural Conformance of an Object-Oriented System to its Runtime Architecture

Abstract

Maintaining the conformance of an implementation to its architecture is difficult in practice since developers often make changes that degrade the architectural structure. We present tools for statically checking the structural conformance of a system to its runtime architecture.

eMoose - A Memory Aid for Software Developers

Abstract

eMoose is an Eclipse-based memory-aid for Java developers. It revolves around developer-provided lightweight subjective knowledge elements. These are interleaved with automatically-gathered objective activities to form a detailed "transcript" offering orientation and traceability. They are also "pushed" into contexts where they can be, increasing prospects of knowledge use.

JAxT and JDI -- The Simplicity of JUnit Applied to Axioms and Data Invariants

Abstract

Testing and instrumenting software are among the foremost techniques for ensuring software reliability. We present ongoing work on two Eclipse extensions that try to make the use of axioms and data invariants as convenient a part of the development process as unit tests.

Enforcing Reference and Object Immutability in Java

Abstract

Immutability information is useful in many software engineering, and undesired mutation or side-effect is hard to detect or debug. Yet, such information is usually undocumented or unspecified. We presented a language that expresses immutability constraints in Java, and built a tool to enforce those immutability constraints.

Compile-time Type-checking for Custom Type Qualifiers in Java

Abstract

We have created a system that enables programmers to add custom type qualifiers to the Java language in a backward-compatible way. The system allows programmers to write type qualifiers in their programs and to create compiler plug-ins that enforce the semantics of these qualifiers at compile time.

PEM: Experience Management Tool for Software Companies

Abstract

Process control and improvement are keys to successful businesses. A working Experience Factory helps to achieve them but it is not easy to implement. The PROM Experience Manager (PEM) is designed to facilitate such implementation with a flexible visual interface to an experience base populated of metrics collected non invasively.

Visualizing Software Evolution with Lagrein

Abstract

Lagrein is a tool that allows exploring how a software system has been developed. It supports visualization of multiple metrics, it links requirements to code expected to implement them and couples code with the effort spent in producing it. Moreover, it shows the system's evolution using animation and timing diagrams.

Interactive Exploration of Compacted Visualizations for Understanding Behavior in Complex Software

Abstract

In this demonstration we present Chrono, a tool that creates sequence diagram based visualizations. Since the diagrams produced by traditional sequence diagramming tools become large and unmanageable when dealing with complex code bases, Chrono focuses on removing less relevant information, condensing diagram components, and allowing for interactive exploration.

Understanding Code Architectures via Interactive Exploration and Layout of Layered Diagrams

Abstract

Visualization tools targeting helping developers understand software have typically had visual scalability limitations- requiring significant input before providing useful results. We present Strata, designed to actively help by providing layered diagrams. Defaults are used based on the package structure while allowing interactions for both overriding defaults and focusing on code.

Axiom-Based Testing for C++

Abstract

Axioms, known from program specification, allow program functionality to be described as rules or equations. The draft C++0x standard introduces axioms as part of the new concept feature. We will demonstrate a tool that uses these features for automated unit testing. Keywords: Mouldable Programming, Generative Programming, Program Transformation, Unit Testing, Test Generation, Axioms, Specifications, Concepts, C++, C++0x

SyQL: an Object Oriented, Fuzzy, Temporal Query Language for Repositories of Software Artifacts

Abstract

Data mining on software products and process metrics is hard. The relations between them are different and may varying. We present a data manipulation language called System Query Language, which partially overcomes the problems of other similar languages and allows the user to retrieve the needed information.

Using Testability Explorer refactoring existing code to make it more testable and influence developers to write more tests.

Abstract

Testability-explorer is a tool which analyzes java byte-codes and computes how difficult it will be to write unit-test. If used as a part of continuous-build it can be used to effect a change in an organization and get developers to refactor code for testability and to write more tests.