Join us on:

Papers 1

Session Chair: Bernd Bruegge, Technische Universität München
Traditional Assignment Considered Harmful
Scott Pike, Texas A&M University
Wayne D. Heym, The Ohio State University
Bruce Adcock, The Ohio State University
Derek Bronish, The Ohio State University
Jason Kirschenbaum, The Ohio State University
Bruce W. Weide, The Ohio State University

Data movement in nearly all modern imperative languages is based on a single primitive: traditional assignment. (With traditional assignment, data are moved between variables by copying.) Unfortunately, traditional assignment poses many known software engineering drawbacks with respect to efficiency for value types, and with respect to modular reasoning for reference types. Moreover, its entrenched legacy has stifled serious regard of potentially superior data-movement primitives. Exploration of the complete design space for data-movement primitives supports the following conclusions: (1) traditional assignment is fundamentally flawed, and (2) any other data-movement primitive would be better.

Silhouette: Visual Language for Meaningful Shape
Clayton Myers, The Chinese University of Hong Kong
Elisa Baniassad, The Chinese University of Hong Kong

Programmers use many views of their code to assess its structure and behavior: call graphs, data-flow diagrams, structural diagrams, etc. The motivation for using such views is that the semantics of textual code is difficult to stand back and assess: If you step back from code, it just appears as a mass of unreadable text. However, the diagrams themselves are also of limited use: the shapes only summarize limited semantic information, so the visual presentation can be as disorganized and confusing as the original code. In this paper we propose Silhouette, a visual programming language and design tool that allows developers to capture the meaning of their program in the visual structure of their code. The shapes chosen by the developer represent abstractions of the underlying functionality or structure, and can be infinitely nested to allow different levels of abstraction. The goal is for programmers to build a correspondence between the shape of their program and its meaning. We believe that Silhouette gives programmers more flexibility in matching their high-level abstractions to code and enables a wide variety of design strategies.

Coherent Reaction
Jonathan Edwards, MIT

Side effects are both the essence and bane of imperative programming. The programmer must carefully coordinate actions to manage their side effects upon each other. Such coordination is complex, error-prone, and fragile. Coherent reaction is a new model of change-driven computation that coordinates effects automatically. State changes trigger events called reactions that in turn change other states. A coherent execution order is one in which each reaction executes before any others that are affected by its changes. A coherent order is discovered iteratively by detecting incoherencies as they occur and backtracking their effects. Unlike alternative solutions, much of the power of imperative programming is retained, as is the common sense notion of mutable state. Automatically coordinating actions lets the programmer express what to do, not when to do it.

Coherent reactions are embodied in the Coherence language, which is specialized for interactive applications like those common on the desktop and web. The fundamental building block of Coherence is the dynamically typed mutable tree. The fundamental abstraction mechanism is the virtual tree, whose value is lazily computed, and whose behavior is generated by coherent reactions.

π - a Pattern Language
Roman Knöll, TUD Technische Universität Darmstadt
Mira Mezini, TUD Technische Universität Darmstadt

Current programming languages and techniques realize many features which allow their users to extend these languages on a semantic basis: classes, functions, interfaces, aspects and other entities can be defined. However, there is a lack of modern programming languages which are both semantically and syntactically extensible from within the language itself, i.e., with no additional tool or meta-language. In this paper we present π as an approach that aims to overcome this lack. π provides an abstraction mechanism based on parameterized symbols which is capable of semantically and syntactically unifying programming concepts like variables, control-structures, procedures and functions into one concept: the pattern. We have evaluated the abstraction potential and the syntactic extensibility of π by successfully creating patterns for the aforementioned programming concepts. π could serve as a tool for designing new experimental languages and might generally influence the view we have on current programming concepts.

Please email any questions to . This e-mail address is being protected from spambots. You need JavaScript enabled to view it