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)
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)
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)
Rethinking the Human-Readability Infrastructure
Christopher Hall (UC Santa Barbara)
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
Tim Felgentreff, Jens Lincke, Robert Hirschfeld (Hasso Plattner
Lauritz Thamsen (Technische Universität Berlin)
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
BayesDB: Query the Probable Implications of Data
Feras Saad, Marco Cusumano-Towner (MIT)
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)
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
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
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