Future Programming Workshop 2014 final videos
Francisco Sant’Anna “Dynamic Organisms
We propose a new abstraction mechanism for a synchronous reactive
programming language: Organisms reconcile objects and
threads into a single concept.
We enforce lexical scope for dynamic instances and also restrict the
use of explicit references to organisms.
This way, we can eliminate typical issues in dynamic allocation,
such as memory leaks, danging pointers, and garbage collection.
Toby Schachman “Shadershop”
Shadershop is an interface for programming GPU shaders in the
mode of a direct manipulation image editor like Photoshop.
Whereas today's programming tools (coding) leverage the programmer's
symbolic reasoning, Shadershop leverages the programmer's spatial
Yair Chuchem & Eyal Lotem “Lamdu - towards a next
Lamdu is a structural code editor which mimics the convenience of
textual code editing while leveraging its understanding of the code to
offer intelligent type-aware completions and significantly simplify
complier feedback and type errors.
Jonathan Edwards “Two-way Dataflow”
Subtext is an experiment to radically simplify application programming.
The goal is to combine the power of frameworks like Rails and iOS with
the simplicity of a spreadsheet.
The standard MVC architecture of such frameworks makes execution order
hard to understand, a problem colloquially called callback hell.
I propose a new approach called two-way dataflow, which breaks the
program into cyclic output and input phases. Output is handled with
traditional one-way dataflow, which is realized here as a form of
pure lazy functional programming. Input is governed by a new semantics
called one-way action which is a highly restricted form of event-driven
imperative programming. These restrictions statically order event
execution to avoid callback hell.
Two-way dataflow has been designed not only to simplify the
semantics of application programming but also to support a
presentation that, like a spreadsheet, provides a fully WYSIWYG
Patrick Dubroy “Moonchild”
Moonchild is a toolkit for experimenting with new kinds of
programming interfaces, based on a text editor written in HTML and
presentation of the source code based on the contents of the AST.
Plugins can also be interactive widgets that modify the original
source code. For example, a state machine in the code could be edited
with a drag-and-drop graph editor.
The Moonchild parser also supports a form of metadata embedded in
comments in the source code. Metadata is attached to AST nodes, so it
can be read and written by the plugins. This allows plugins to operate
on structure beyond what is stored in the raw AST. For example, this
allows a function to be cross-referenced with its tests, and a plugin
can re-run the tests every time the function is edited.
I started this project in order to explore a few different things.
First, I'm interested in exploring interfaces for programming in
augmented text. This has been done in the past, but I think it's worth
further exploration. There are also interesting UX questions around
how to combine free-form text editing with more structured graphical
widgets. Finally, I'd like to explore programming languages that are
designed around a rich, interactive environment like this, rather
than plain text.
Christopher Schuster “Traveling through Time and Code:
Omniscient Debugging and Beyond”
Traditional debugging visualizes the execution state at a certain
point in time. With omniscient debugging, it is possible to
navigate and inspect the execution at different points in time.
This demo present a prototype of a live coding environment that makes
it easy to navigate the execution and extends omniscient debugging with
an additional dimension in order to navigate to different versions of
the code. While the implementation is still at an early state, the
basic idea is promising for future research in debugging and programming.
Joel Galenson “CodeHint: Dynamic and Interactive Synthesis for
There are many tools that help programmers find code fragments,
but most are inexpressive and rely on static information.
We present a new technique for synthesizing code that is dynamic,
easy-to-use, and interactive. Our implementation, which we call
CodeHint, generates and evaluates code at runtime and hence can
synthesize real-world Java code that involves I/O, reflection,
native calls, and other advanced language features.
Bill Birch “Genyris”
Inspired by the Semantic Web, Genyris presents a new
programming paradigm. Genyris uses SemWeb concepts internally.
Symbol have RDF prefixes, object classes are assigned to objects
after construction and objects can belong to multiple classes.
Whilst being a function language derived from Lisp, Genyris uses
indentation to reduce the need for parenthesis.
Genyris supports an input-classify-use pattern.
Mark Mahoney “Version Control Optimized for Teaching and
Modern version control systems are optimized to be disk efficient.
In the twenty first century, this seems like the wrong variable to
optimize for. Instead, version control systems should focus on
making it easier for developers to teach and learn from each other.
This video demonstrates a prototype tool, Storyteller, that acts as a
version control system that captures very fine grained information
about the development process. With this information, developers can
animate the changes in their code, and more importantly, create
narratives about how and why their code evolves. I believe that
these “stories” will allow less skilled developers to become better
by watching and consuming stories from more skilled ones and that
maintainers will learn about their systems with less effort.
David Broderick “Kaya: Declarative Reactive”
Kaya is declarative like SQL, but reactive like a spreadsheet.
In fact, the spreadsheet metaphor pervades the prototype-based language.
Code is not written in a text editor, but instead you compose
applications in a spreadsheet-like editor.
The language contains powerful, expressive data structures whose
contextual nature ameliorates some of the typical need for
programmatic control structures, and leads to a (hopefully) more
natural way to compose applications.
Bill Burdick “Leisure overview”
This is Leisure, a document-based computing environment that runs on
the web, so it doesn't require any installation or even your own
Leisure tries to make programming fun and let kids (and grownups)
open the hood to see what's going on inside. Data, code, and views are
all editable and update dynamically as you make changes.
Each document is a multiuser virtual machine, containing live
content as well as editable code, and data. Leisure automatically
shares changes to code and data and provides structures to support
multiuser apps. Code can be in any of several supported languages
(and mixed within a document).
Although Leisure presents documents as if they are files,
they are actually databases, so they can potentially scale up to
very large amounts of data. Leisure also explores new programming
tools, like AST viewers and embedded test cases, as well as a new,
dynamically typed, pure functional language.
Nikolai Suslov “Virtual World Framework & OMeta: collaborative
programming of distributed objects with user defined languages”
The Virtual World Framework (VWF) provides a synchronized
collaborative 3D environment for the web browser.
Continuing the OpenCroquet research effort, VWF allows easy
application creation, and provides a simple interface to allow
multiple users to interact with the state of the application that is
synchronized across clients, using the notion of virtual time.
A VWF application is made up of prototype components,
behaviours used in distributed computation, to be modified at runtime.
OMeta is a new object-oriented language for pattern matching.
It is based on a variant of Parsing Expression Grammars (PEGs) which
have been extended to handle arbitrary data types.
OMeta's general-purpose pattern matching facilities provide a
natural and convenient way for programmers to implement tokenizers,
parsers, visitors, and tree transformers.
The integration will allow to define on any VWF component it's own
language grammar and replicate it through the application instances,
then have a running scripts based on that shared grammar for that
component. For example, one could have all the languages down from
Logo (Turtle graphics) to Smalltalk available for scripting the virtual
world just in the Web browser.
The talk contains examples of collaborative programming of
distributed objects with user defined grammars. These objects could
exist alongside with each other in the same replicated virtual world,
being programmed on quite different languages, but holding the same