Live 2018 [Bootleg Edition]

If I were there, I'd volunteer to sit in the front row, hold my iPhone up and capture the whole thing. Maybe someone in attendance feels similarly? — Ivan Reese (@spiralganglion) November 5, 2018

Contents

Against The Current: What We Learned From Eve

Chris Granger

Talk Part 1 & Talk Part 2 (both have audio sync issues, so I’d reccomend this transcript annotated with slides), Q&A, Slides

From Debugging Towards Live Tuning of Reactive Applications

Talk, Pre-print

Ragnar Mogk Technische Universität Darmstadt, Pascal Weisenburger Technische Universität Darmstadt, Julian Haas Technische Universität Darmstadt, David Richter Technische Universität Darmstadt, Guido Salvaneschi Technische Universität Darmstadt, Mira Mezini Technische Universität Darmstadt

Directly visualizing the effect of changes to applications improves developers productivity as they gain immediate insights on the resulting application behavior. Yet, immediate feedback requires a representation of the dataflow in the application to correctly propagate and apply the effect of the changes.

Reactive programming is a programming paradigm which directly expresses applications dataflow in a declarative way. Recently, researchers developed dedicated debugging techniques for reactive programming that use the dataflow graph to enable inspections and visualization.

In this paper, we adopt reactive debugging as a basis for live modifications and tuning of reactive applications. To this end we extend the debugger to allow live modifications to the dataflow graph in a structured manner to change the application behavior. We also suggest how developers of reactive applications can use such extension to enable flexible tuning of applications at run time. Our early experience shows that the combination of reactive programming and live programming allows modifications and tuning of applications while ensuring safety and consistency guarantees.

Margin Notes: Automatic code documentation with recorded examples from runtime

Talk, Pre-print

Geoffrey Litt

Programmers working on large codebases frequently need to understand APIs for existing code. Manual documentation is helpful, but takes time to maintain and often doesn’t include enough examples.

Margin Notes automatically generates code documentation by recording example data from function calls as a program executes and displaying those examples in an interactive UI next to the code. This allows programmers to quickly view many examples from past executions as they read the code, helping them efficiently gain insight into the behavior of the program.

PANE: Programming with visible data

Project page, Talk

Joshua Horowitz

To understand what a data-processing program is doing, a programmer needs to understand the data being processed at each step. However, most programming environments hide all data by default, affording only high-latency views through narrow slits. We present PANE, a prototype live, functional programming environment built around data-visibility. In PANE, the process of constructing a program centers around seeing and acting on concrete data values, all of which are visible by default.

Realtime Annotations & Visualizations in Live Coding Environments

Talk, Project website, Pre-print

Charles Roberts Worcester Polytechnic Institute

In this web essay we present research on dynamically injecting realtime annotations and visualizations into a programming environment for live coding performance. The techniques we describe enable both performers and audiences to gain greater insight into discrete events, continuous signals, and the algorithmic transformation of musical pattern. We catalog the various techniques and enable readers to interactively experiment with each of them, and conclude by describing challenges and future directions for our research.

Espalier: a structured spreadsheet tool for end-user development of organizational applications

Talk, Submission video

Matt McCutchen MIT, Shachar Itzhaky Technion, Israel, Daniel Jackson MIT, Willow Jarvis MIT

Nearly every organization is responsible for processes that involve collection and manipulation of structured data subject to certain rules. A significant portion of the work of these processes cries out for automation by what we call an organizational application, but such applications still seem unreasonably difficult for non-expert programmers to build, even after years of work on “low-code” application building tools. With the Espalier tool, we seek to overcome both the ease-of-use and expressiveness deficits of previous tools by making a more serious effort than before to integrate structured data manipulation into the popular and successful spreadsheet paradigm. At Espalier’s core is a spreadsheet interface that allows lists of items (which may be nested) to be displayed either vertically or horizontally by repeating a template of cells for each item, so the layout automatically adjusts as items are added and removed. By defining formulas in item templates and allowing them to traverse the structure of the sheet, we achieve SQL-like expressive power. To the base spreadsheet system, we add ephemeral “view sheets” generated on demand from templates based on supplied parameters, a customizable view-update mechanism, and styling support, and we find that view sheets are flexible enough to serve as custom user interfaces. Espalier proves the concept of end-user development of organizational applications based on a true integration of structured data into the spreadsheet paradigm, and we hope that future work will ultimately validate the usability and utility of the approach.

Hazel: Live and Direct Functional Programming with Holes

Talk, Pre-print, Project website

Cyrus Omar University of Chicago, Ian Voysey Carnegie Mellon University, Matthew Hammer University of Colorado, Boulder, Ravi Chugh University of Chicago

Live programming environments aim to provide programmers (and sometimes audiences) with continuous feedback about a program’s behavior as it is being edited. The problem is that programming languages typically assign meaning only to programs that are complete, i.e. syntactically well-formed and free of type and binding errors. Consequently, the live feedback presented to the programmer suffers from temporal or perceptive gaps.

The Hazel live functional programming environment addresses this “gap problem” from first principles: Hazel assigns rich static and dynamic meaning to every incomplete program that the programmer can construct using Hazel’s language of structured edit actions. An incomplete program is represented as an expression with holes, where empty holes stand for missing expressions or types, and non-empty holes operate as membranes around type inconsistencies. Rather than aborting evaluation when encountering a hole instance, our approach records the environment around the hole instance – forming a hole closure – and then evaluates “around” it. These hole closures enable a fill-and-resume operation that avoids the need to restart evaluation after edits that amount to hole filling. Furthermore, various editor services can report information from hole closures to help the programmer decide how to fill the corresponding holes; we describe two such examples in this paper. First, we discuss Hazel’s live context inspector, which allows the programmer to explore values from relevant hole closures when the cursor is on a hole in the program. Second, we discuss early work on live palettes – user interfaces, which can themselves contain holes, that the programmer can directly manipulate to fill an expression hole. A live palette can use the closures associated with the hole being filled to provide specialized, concrete feedback about the dynamic consequences of the programmer’s choices. Taken together, the result is a substantially more live and direct typed functional programming experience.

REPLugger: a pleasant and scalable live coding editor

Talk, Submission video

Glen Chiacchieri

Today, programmers type code into text editors and are forced to re-construct program behavior in their heads, an arduous task that limits accessibility for beginners and feels unpleasant for experts. Is it possible to create user interfaces that provide useful feedback about program behavior in support of programmer experience?

REPLugger (REPL + debugger) is a research prototype code editor attempting to provide this kind of immediate feedback. REPLugger integrates the liveliness of a REPL and the comprehensiveness of a debugger directly into the code-editing experiencing. By constructing a sample program environment, REPLugger allows programmers to examine the effects of their code as-they-type. Additionally, REPLugger supports the easy creation and saving of what-if scenarios, allowing programmers to quickly test and validate hypotheses about program behavior in complex systems. The result is a surprisingly fluid and pleasant editing experience that can work with programs of many thousands of lines.

Scaling the REPL Experience

Talk, Project website

Yair Chuchem, Eyal Lotem

The REPL (Read-eval-print loop) is an invaluable tool used by many programmers to great satisfaction. It shines best for programming in the small, but when programming in the large, developers rarely use it, with systems languages such as Go and Rust not even offering a REPL.

We have identified three reasons for why the REPL doesn’t currently suit programming in the large:

“Bandwidth”: For each expression evaluated in the REPL, it only produces its final result. The size of REPL’s output bears no resemblance to the size of input program.

“Liveness”: When the input program changes, the REPL’s results still reflect its previous states, requiring the programmer to remember when each result was computed, increasing the mental burden and potentially causing confusion. IDEs that solve this with live-reloading risk executing incomplete effectful programs, which may have undesirable, and in some cases even dangerous side-effects.

“Availability”: The programmer cannot use incomplete modules in the REPL (modules containing syntax errors, type errors, etc), but these are usually the states when the REPL’s feedback would be most valuable.

Lamdu is a live-programming projectional IDE with a statically typed purely functional programming language, which we are developing. We describe how it embodies these solutions to the problems listed above:

Bandwidth is improved with value annotations under all evaluated sub-expressions, both in the REPL line and in the used functions themselves.

Liveness is achieved by using a distinction between pure computations and effectful code, and using live-reloading only for the computations, while requiring an explicit user action to execute effectful code.

Availabilty is enabled by localizing type errors and by using projectional editing. Instead of the user freely editing text which the compiler then has to interpret, the code always has a valid structure, even when it is incomplete. While traditionally projectional editors had unintuitive user interfaces with steep learning curves, Lamdu’s interface is designed to retain the intuitive interface of text editing according to the WYTIWIS principle: What You Type Is What You See.

SVG Programming by Direct Manipulation of Intermediates

Talk. Submission video, Project page

Brian Hempel University of Chicago, Ravi Chugh University of Chicago

Could text-based programming be augmented to allow creating programs just by directly manipulating output?

Prior work on Sketch-n-Sketch, a bimodal program editor, has demonstrated the viability of this approach for programs that produce vector graphics. In addition to standard text editing, in Sketch-n-Sketch the programmer may use the mouse to draw, move, align, group, and abstract shapes on the program’s output canvas, allowing some programs to be created entirely by direct manipulation.

Seeking to scale up this approach, our work extends Sketch-n-Sketch with features for constructing larger programs. First, we show intermediate execution products (rather than only the final output) and expose them for direct manipulation. Second, to better control the effects of program transformations (rather than making changes mostly at the top-level), we let the programmer selectively narrow the editing focus to a single function call; interactions are limited to those intermediates and outputs in focus. Finally, we improve and add tools to offer additional meaningful program transformations.

To present our approach, we walk through the step-by-step construction of a program that draws a von Koch curve fractal. By manipulating the visually rendered intermediates, we build the non-trivial recursive program directly and entirely on the output canvas, without resorting to traditional text-editing.

Chalktalk : A Visualization and Communication Language – As a Tool in the Domain of Computer Science Education

Talk. Project github

Ken Perlin NYU, Zhenyi He NYU, Karl Rosenberg NYU

In the context of a classroom lesson, concepts must be visualized and organized in many ways depending on the needs of the teacher and students. Traditional presentation media such as the blackboard or electronic whiteboard allow for static hand-drawn images, and slideshow software may be used to generate linear sequences of text and pre-animated images. However, none of these media support the creation of dynamic visualizations that can be manipulated, combined, or re-animated in real-time, and so demonstrating new concepts or adapting to changes in the requirements of a presentation is a challenge. Thus, we propose Chalktalk as a solution. Chalktalk is an open-source presentation and visualization tool in which the user’s drawings are recognized as animated and interactive “sketches,” which the user controls via mouse gestures. Sketches help users demonstrate and experiment with complex ideas (e.g. computer graphics, procedural animation, logic) during a live presentation without needing to create and structure all content ahead of time. Because sketches can interoperate and be programmed to represent underlying data in multiple ways, Chalktalk presents the opportunity to visualize key concepts in computer science: especially data structures, whose data and form change over time due to the variety of interactions within a computer system. To show Chalktalk’s capabilities, we have prototyped sketch implementations for binary search tree (BST) and stack (LIFO) data structures, which take advantage of sketches’ ability to interact and change at run-time. We discuss these prototypes and conclude with considerations for future research using the Chalktalk platform.

Chairs