Future Programming Workshop
SPLASH Oct 26-27, 2015

An end-user programming environment that's cell-based, copy/paste friendly, with a flat and forward execution model
Jake Sandlund (Braintree) [homepage]

This (unnamed) programming environment takes the cell-based editing of a spreadsheet, collapses it into one dimension, replaces the declarative dependency-tracking execution with a reactive, flat, forward-only one, and then adds cell abstraction. There are no function calls, no for loops, no if statements, no identifiers, but there is procedural abstraction, repetition, conditional code, and linking values via clicking. Code is copied when autocompleting functions or doing the equivalent of a for loop. The programming structures are built on permanent selections: make a function by dragging over some cells. Another item that is explored is applying the “spreadsheet value rule” (limited functional programming: https://en.wikipedia.org/wiki/Spreadsheet) to graphics.

Medic: Metaprogramming and Trace-Oriented Debugging
Xiangqi Li, Matthew Flatt (University of Utah) [web essay]

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.

Living Computation: Robust-first programming in ULAM
Dave Ackley (UNM Computer Science) [video]

Rethinking the Human-Readability Infrastructure
Christopher Hall (UC Santa Barbara) [video]

Character encodings and text editing widgets and applications together form the current human-readability infrastructure. We outline an alternative human-readability infrastructure appropriate for both, highly free-form textual formats, and highly structured binary data formats. Our approach consists of a metaformat and structure editor. We describe our prototypes, which aim to supersede the domains of text and text editors respectively.

Lively Groups: Shared Behavior in a World of Objects without Classes or Prototypes
Tim Felgentreff, Jens Lincke, Robert Hirschfeld (Hasso Plattner Institute), Lauritz Thamsen (Technische Universität Berlin) [video]

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 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.

BayesDB: Query the Probable Implications of Data
Feras Saad, Marco Cusumano-Towner (MIT) [video]

Statistics and machine learning are part of many new systems, but have been described as the “high interest credit card of technical debt.” Is it possible to make statistical inference broadly accessible to non-statistician programmers without sacrificing mathematical rigor or inference quality? BayesDB is a system that enables users to query the probably implications of their data as directly as SQL enables them to query the data itself. This presentation focuses on BQL, an SQL-like query managed for Bayesian data analysis that answers queries by averaging over an implicit space of probabilistic models. The demonstration focuses on analysis of a public database of Earth satellites.

The Gamma: Programming tools for data journalism
Tomas Petricek (University of Cambridge) [video]

Computer programming may not be the new literacy, but it is finding its way into many areas of modern society. In this submission, we look at data journalism, which is a discipline combining programming, data analysis and traditional journalism. In short, data journalism turns articles from a mix of text and images into something that is much closer to a computer program.

Most data journalists today use a wide range of tools that involve a number of manual steps. This makes the analysis error prone and hard to reproduce. In this video, we explore the idea of treating a data driven article as an executable program. We look how ideas from programming language research can be used to provide better tools for writing (or programming) such articles, but also to enable novel interactive experience for the reader.

The project also makes data journalism more accountable and reproducible. We let the reader verify how exactly are the visualizations generated, what are the data sources and how are they combined together.

Coordinating extensibility with CoLingua
Dann Toliver [video]

We present a system for coordinating code within extensible applications. Applications are composed of spaces, which serve as sandboxes, state encapsulators and units of functionality. Spaces can be nested, and all I/O happens in the application's outermost space.

By default all communication is fire and forget message passing, and we're currently working on the semantics of synchronous communication in this system, and in particular when it should block concurrent activity in the same space. This is difficult not just from a technical perspective of balancing performance and safety, but also because one of our main goals is to enable inexperienced programmers to make valuable contributions, so the system should raise questions like “should this block?” as infrequently as possible.

We're also working toward full projectional editing: the bytecode, together with some supplementary decorations, can be projected back up into the original code, but could also be projected into a visual editing mode, where changes in one mode affect the other. We're finding that some aspects of development in this system are easier to reason about with boxes and arrows, and other parts are easier to reason about as code, and having both options on our toolbelt is better than either one alone.

We're striving for a system that is simple, with few sharp corners and a gradual revelation of power. We hope to give end users the ability to easily customize the applications they use on the web, and developers the ability to build extensible applications as easily as they now build static ones. There are a number of projects that will be using this system in production next year, so now is an ideal time for feedback on the core system components.