ICSE 2013 Workshops
2013 35th International Conference on Software Engineering (ICSE)
Powered by
Conference Publishing Consulting

2013 1st International Workshop on Live Programming (LIVE), May 19, 2013, San Francisco, CA, USA

LIVE 2013 – Proceedings

Contents - Abstracts - Authors

1st International Workshop on Live Programming (LIVE)

Title Page

The term live programming is a recent catchphrase for programming systems that abandon the traditional edit-compile-run cycle in favor of a more instantaneous user experience with live feedback on a program's runtime behavior. The goal of this workshop is to focus on exploring notions and degrees of live programming as they relate to software development, creative activities, learning, and performance. We are interested in techniques, tools, demos, infrastructures, languages design insights, and questions that stimulate interest and understanding in live programming concepts. We aim to bringing together researchers and practitioners interested in live programming. The workshop will be in the format of an unconference, with topics decided by the interests of the attendees.

Live Mashup Tools: Challenges and Opportunities
Saeed Aghaee and Cesare Pautasso
(University of Lugano, Switzerland)
Live programming is a programming style in which the repetitive task of compiling and running the software being programmed is managed automatically. This style can be a helpful practice in End-User Development (EUD) where the non-professional end-users are to be supported through techniques and tools that empower them to create or modify software artifacts. Mashups -- a form of lightweight Web applications composing reusable content and functionalities available on the Web -- are a popular target for EUD activities on the Web. EUD for mashups is enabled by intuitive composition environments, called mashup tools. In this paper, we introduce live mashup tools, a new class of mashup tools based on the live programming style. We give a comprehensive definition and classification of live mashup tools, giving examples of how well existing tools fit in this category and discuss open research challenges and opportunities.

Article Search
Introducing Circa: A Dataflow-Based Language for Live Coding
Andrew Fischer
(Shutterfly, USA)
In a live programming environment, the state of the running program is available during the editing process. An ideal live programming system should be able to harness the live program to offer improved abilities for code creation and manipulation. We introduce Circa, a language and platform designed to address this need. We argue in favor of a dataflow-based model of computation, and we show how this format enables useful methods of code inspection and manipulation. We present a framework based on the backpropogation algorithm that allows the user to manipulate their program by expressing a desire against the programs result. We discuss how these code editing abilities can combine to produce a highly effective environment.

Article Search
Co-evolution as the Key for Live Programming
Remo Lemma and Michele Lanza
(University of Lugano, Switzerland)
The promise of live programming is to shorten or even break the infamous edit-compile-run cycle, providing live feedback on a program’s envisioned behavior while it is being written. Several live programming languages and environments exist, from venerable examples (Smalltalk, LISP) to more recent efforts like Ruby. In most cases either the IDE comes as an afterthought, after the language is designed, or novel languages are made to fit into existing IDEs. We pursue a middle ground by co-evolving both a language and its IDE: we are developing a novel live programming language, called Moon, from scratch, and are concurrently building its IDE. We illustrate our efforts so far and discuss our overall vision.

Article Search
SOMETHINGit : A Prototyping Library for Live and Sound Improvisation
Tomohiro Oda, Kumiyo Nakakoji, and Yasuhiro Yamamoto
(Software Research Associates, Japan; Tokyo Institute of Technology, Japan)
Live programming can be considered an interaction with incomplete code. Dynamic languages embrace the similar style of programming, such as pair programming and prototyping in a review session. Static languages require a certain degree of completeness of code, such as type safety and namespace resolution. SOMETHINGit is a Smalltalk library that combines dynamic Smalltalk and static Haskell and VDM-SL. SOMETHINGit enables programmers to write incomplete but yet partially mathematically sound programs by five levels of bridging mechanisms.

Article Search
Euclase: A Live Development Environment with Constraints and FSMs
Stephen Oney, Brad A. Myers, and Joel Brandt
(CMU, USA; Adobe Research, USA)
Euclase is a live development environment focused on creating interactive web applications. It uses a programming model that combines constraints and finite state machines to specify interactive behaviors. Euclase is live in the sense that while the user is developing code, their program is always executing. Changes made to the source of the program are reflected immediately in the running program. We identify some of the implementation and design challenges of making our development environment live, including performance issues, ensuring predictability, dealing with errors in the source, and handling edge cases such as the removal of code that is currently running. We also discuss how Euclases use of finite state machines and constraints can help alleviate these difficulties.

Article Search
Live Logic Programming
Spencer Rugaber, Zef Hemel, and Kurt Stirewalt
(LogicBlox, USA)
Logic programming languages are today used to build applications accessing large database systems. This raises the possibility of building live development environments for them. Of particular interest is how specific language features such as level of abstraction, transactions, etc. affect the design of such an environment. In this paper, we explore this question for a specific logic language, Datalog, contrast traditional and live approaches for its tooling and discuss issues that arise.

Article Search
Live Feedback on Behavioral Changes
Gustavo Soares, Emerson Murphy-Hill, and Rohit Gheyi
(UFCG, Brazil; North Carolina State University, USA)
The costs to find and fix bugs grows over time, to the point where fixing a bug after release may cost as much as 100 times more than before release. To help programmers find bugs as soon as they are introduced, we sketch a plugin for an integrated development environment that provides live feedback about behavioral changes to Java programs by continuously generating tests, running the tests on the current and previous versions of the program, and comparing the results. Such a tool would allow programmers to better understand how their changes affect the behavior of their programs. As a proof of concept, we developed a prototype that found a bug that remained undetected by pair programmers working on JHotDraw in a previous study. Had the programmers performed this change with our plugin, they would have been notified about the bug as soon as they introduced it.

Article Search
Visual Code Annotations for Cyberphysical Programming
Ben Swift, Andrew Sorensen, Henry Gardner, and John Hosking
(Australian National University, Australia; QUT, Australia)
User interfaces for source code editing are a crucial component in any software development environment, and in many editors visual annotations (overlaid on the textual source code) are used to provide important contextual information to the programmer. This paper focuses on the real-time programming activity of 'cyberphysical' programming, and considers the type of visual annotations which may be helpful in this programming context.

Article Search
A Perspective on the Evolution of Live Programming
Steven L. Tanimoto
(University of Washington, USA)
Liveness in programming environments generally refers to the ability to modify a running program. Liveness is one form of a more general class of behaviors by a programming environment that provide information to programmers about what they are constructing. This paper gives a brief historical perspective on liveness and proposes an extension of a hierarchy given in 1990, to now account for even more powerful execution-oriented tools for programmers. In addition, while liveness concerns the timeliness of execution feedback, considering a broader array of forms of feedback is helpful both in better understanding liveness and in designing ever more powerful development tools.

Article Search
Semantic Deltas for Live DSL Environments
Tijs van der Storm
(CWI, Netherlands)
Domain-specific languages (DSLs) require IDE support, just like ordinary programming languages. This paper introduces semantic deltas as a foundation for building live DSL environments to bridge the "gulf of evaluation" between DSL code and the running application. Semantic deltas are distinguished from textual or structural deltas in two ways. First, they have meaning in the application domain captured by the DSL. Second, they can be interpreted at runtime so that the behavior of the running system adapts to the evolved DSL code. Semantic deltas have the potential to support back-in-time debugging, application state persistence, version control, retroactive updates and exploring what-if scenarios. I present early experiences in building a live DSL environment and identify areas for future research.

Article Search

proc time: 0.27