Andrei Chis, Tudor Girba and Oscar NierstraszAnswering 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: scg.unibe.ch/research/moldableinspector.
Vojin Jovanovic and Amir ShaikhhaDeeply 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.
Brahim HamidIn 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.
Sebastian Erdweg, Tijs van der Storm and Yi DaiProgram 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".
Nicholas CameronRust 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.