Lambda the Ultimate

A paper I just finished on live programming (and submitted to the normal place for publication), abstract:

Programming today involves code editing mixed with bouts of debugging to get feedback on code execution. For programming to be more fluid, editing and debugging should occur not only at the same time, but also in the same space to quickly make use of the resulting live execution feedback. This paper describes how live feedback can be woven into the editor by making places in code execution, not just in code, navigable so evaluation results can be probed directly within the code editor. A pane aside the editor also traces execution with entries that are similarly navigable, enabling quick problem diagnosis. Both probes and traces are refreshed continuously during editing, and are easily configured based on debugging needs. We demonstrate the usefulness of this live programming experience with a prototype.

I've also cut a couple of videos for the paper, though they might require reading up to Section 3 in the paper to make sense of them:

• Using LPX to write a square root function.
• Using LPX to write a Fibonacci function.

I promise to do better on the videos in the future :) Also, consider checking out the "It's Alive" paper, I'm surprised no one commented on it yet, but its been really slow on LtU lately! For historical reference, this is the main follow up to my previous live programming paper, but much of the thinking has changed significantly.

Edit2: a brief history of progress live programming as I see it now (note that this is controversial depending on how you define "live programming" or "progress"):

Liveness was applied to UI applications (VisiCalc) long before it was applied to programming. VisiProg might be the first language to explore liveness in programming (85), though I would argue that Sutherland's SketchPad (63), a more limited "language" to be sure, precedes it by about 30+ years, and is the first example of liveness applied to UI or programming. But VisiProg definitely gets the cake for being the first to clearly point out the property; while VisiProg, at least in its XED implementation, appears to be textual.

A bunch of visual languages afterwards support liveness without really calling it such; Tanimoto (91) coins the term liveness to describe what they are already basically doing. Maloney and Smith re-coin the term liveness a few years later (95), independently of Tanimoto, to describe basically the same property in Self's Morphic. Burnett elaborates on Tanimoto's liveness in a nice VPL paper (98). In the mean time, REPLs and fix-and-continue environments abound in the Lisp and Smalltalk communities, but these are hardly live in the sense used here (though they also focus on early feedback).

Hancock is the first to really put the pieces together in his dissertation (03), coining the term "live programming" for the first time and applying the concept to an almost non-visual language (Flogo II). He focuses on the nature of the feedback, going beyond just seeing the result evolve in real time through a mechanism he refers to as "live text". Edwards (04) coincidentally does something very similar with his example-centric programming environment, using different terminology, and a focus on continuously executing examples.

Recently, Bret Victor revived interest (well, at least mine) in this area starting with his Inventing on Principle talk ('12). Although he eschews labels, many of his examples focus on getting better more timely feedback about program modifications, and is quite similar to the goals of live programming. His Learnable Programming essay further elaborates on these topics.