Future Programming Workshop 2014 final videos

Francisco Sant’Anna “Dynamic Organisms in Céu” [video] [home page]

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” [home page]

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

Yair Chuchem & Eyal Lotem “Lamdu - towards a next generation IDE” [video]

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” [video] [home page]

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

Patrick Dubroy “Moonchild” [video]

Moonchild is a toolkit for experimenting with new kinds of programming interfaces, based on a text editor written in HTML and JavaScript. The editor supports plugins which can extend the 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” [video]

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 Modern IDEs” [video]

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” [video]

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 Learning” [video]

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” [video]

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” [video]

This is Leisure, a document-based computing environment that runs on the web, so it doesn't require any installation or even your own computer.

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” [video] [home page]

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, which are programmed in JavaScript, that allows a shared code and 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 simulation.