ECOOP / Demos and Tutorial

European Conference on Object-Oriented Programming



Demo: The GTInspector: A moldable object inspector


Demo: Yin-Yang: Concealing the Deep Embedding of DSLs


Demo: An MDE Tool-Chain for Pattern-Based S&D Embedded System Engineering



Demo: Automated and Sound Variable Renaming to Avoid Variable Capture in Generated Code


Tutorial: Rust - bare metal programming without the sharp edges

The GTInspector: A moldable object inspector


Andrei Chis, Tudor Girba and Oscar Nierstrasz

Answering run-time questions in object-oriented systems involves reasoning about and exploring connections between multiple objects. Traditional object inspectors favor a generic view that focuses on the low level details of the state of single objects. However, different developer questions exercise different aspects of an object and require different kinds of interactions depending on the development context. The GTInspector is a novel moldable object inspector that allows developers to look at objects using multiple interchangeable presentations. These presentations are arranged in a workflow in which multiple levels of connecting objects can be seen together. In this tool demo we show how the GTInspector improves the inspection process by applying it to several use-cases, such as interacting with the file system or inspecting results from a database query. We also show how the inspector can be extended with new presentations. More information about the GTInspector can be found at:

Yin-Yang: Concealing the Deep Embedding of DSLs


Vojin Jovanovic and Amir Shaikhha

Deeply embedded domain-specific languages (EDSLs) inherently compromise programmer experience for improved program performance. Shallow EDSLs complement them by trading program performance for good programmer experience. We present Yin-Yang, a framework for DSL embedding that uses Scala reflection to reliably translate shallow EDSL programs to the corresponding deep EDSL programs. The translation allows program prototyping and debugging in the user friendly shallow embedding, while the corresponding deep embedding is used in production--where performance is important. The reliability of the translation completely conceals the deep embedding from the DSL user. For the DSL author, Yin-Yang generates the deep DSL embeddings from their shallow counterparts by reusing the core translation. This obviates the need for code duplication and assures that the implementations of the two embeddings are always synchronised.

An MDE Tool-Chain for Pattern-Based S&D Embedded System Engineering


Brahim Hamid

In our work, we promote a new discipline for system engineering using a pattern as its first class citizen: Pattern-Based System Engineering (PBSE). This video tutorial presents the SEMCO MDE Tool Suite called TERESA to support PBSE in the domain of assistance to the secure and dependable embedded system engineering. We provide guidelines on how to use it to build and to store reusable artifacts (S&D patterns and property models) into a model-based repository. Once the repository is available, it serves an underlying trust engineering process. We propose a Connected Data Objects (CDO) based implementation of the repository of patterns and a set of EMF tree-based editors to create patterns and the required libraries.

Automated and Sound Variable Renaming to Avoid Variable Capture in Generated Code


Sebastian Erdweg, Tijs van der Storm and Yi Dai

Program transformations in terms of abstract syntax trees compromise referential integrity by introducing variable capture. Variable capture occurs when in the generated program a variable declaration accidentally shadows the intended target of a variable reference. Existing transformation systems either do not guarantee the avoidance of variable capture or impair the implementation of transformations. We present an algorithm called name-fix that automatically eliminates variable capture from a generated program by systematically renaming variables. name-fix is guided by a graph representation of the binding structure of a program, and requires name-resolution algorithms for the source language and the target language of a transformation. name-fix is generic and works for arbitrary transformations in any transformation system that supports origin tracking for names. We verify the correctness of name-fix and identify an interesting class of transformations for which name-fix provides hygiene. We demonstrate the applicability of name-fix for implementing capture-avoiding substitution, inlining, lambda lifting, and compilers for two domain-specific languages. This demonstration accompanies our ECOOP'14 paper "Capture-Avoiding and Hygienic Program Transformations".

Rust – bare metal programming without the sharp edges


Nicholas Cameron

Rust is a new language for bare metal (systems and low-level) programming. It provides strong guarantees about memory safety without the overhead or unpredictability of garbage collection. It is designed to support concurrency and parallelism in building platforms that take full advantage of modern hardware. Rust combines powerful and flexible modern programming constructs with explicit control of memory. This control is balanced with the absolute requirement of safety: Rust's type system and runtime guarantee the absence of data races, buffer overflow, stack overflow, or access to uninitialized or deallocated memory. In this tutorial we'll work through a series of examples showing how Rust allows for safer and more efficient programming in the systems domain. We'll see how Rust uses affine and region types to avoid memory leaks and dangling pointers; type parameterisation and type classes for a flexible and performant object system, and how techniques from the functional paradigm can be used in a systems language.


Diamond Sponsors

Gold Sponsors


Silver Sponsors


Bronze Sponsors



In Cooperation With