FPW 2015 – Proceedings

Rethinking the Human-Readability Infrastructure
Christopher Hall
(University of California at Santa Barbara, USA)
Character encodings and text editing widgets and applications together form the current human-readability infrastructure. We outline an alternative human-readability infrastructure that is simultaneously appropriate for textual formats and binary runtime data structures. Our approach consists of a binary metaformat and corresponding language-independent structure editor. Here we describe our prototype editor, its suitability to supersede text editors, and several case studies that explore its immediate and repeat benefit to various content domains.

Video

Medic: Metaprogramming and Trace-Oriented Debugging
Xiangqi Li and Matthew Flatt
(University of Utah, USA)
Modern programmers enjoy a wealth of high-level and graphical tools for understanding and debugging programs. Nevertheless, programmers often resort to the simple and the time-honored technique of inserting print statements into programs to reveal progress and to expose intermediate values. This trace debugging (a.k.a. printf debugging) technique persists because it has many advantages. Traditional trace debugging also has several drawbacks, including the need to modify the source program and the need for additional tools when trace output becomes too voluminous. Medic, our new debugging and program-exploration tool for Racket, augments the traditional examination of control and state with output processing, metaprogramming, and visualization features. Medic allows programmers to leverage the benefits of trace debugging while addressing many of its drawbacks.

Lively Groups: Shared Behavior in a World of Objects without Classes or Prototypes
Tim Felgentreff, Jens Lincke, Robert Hirschfeld, and Lauritz Thamsen
(HPI, Germany; TU Berlin, Germany)
Development environments which aim to provide short feedback loops to developers must strike a balance between immediacy and the ability to abstract and reuse behavioral modules. The Lively Kernel, a self-supporting, browser-based environment for explorative development supports standard object-oriented programming with classes or prototypes, but also a more immediate, object-centric approach for modifying and programming visible objects directly. This allows users to quickly create graphical prototypes with concrete objects. However, when developing with the object-centric approach, sharing behavior between similar objects becomes cumbersome. Developers must choose to either abstract behavior into classes, scatter code across collaborating objects, or to manually copy code between multiple objects. That is, they must choose between less concrete development, reduced maintainability, or code duplication. In this paper, we propose Lively Groups, an extension to the object-centric development tools of Lively to work on multiple concrete objects. In our approach, developers may dynamically group live objects that share behavior using tags. They can then modify and program such groups as if they were single objects. Our approach scales the Lively Kernel’s explorative development approach from one to many objects, while preserving the maintainability of abstractions and the immediacy of concrete objects.