Top page
TextAlive
Griffith
Songle Sync
f3.js
Live TuningExpanding Live Programming Benefits to Non-Programmers
Abstract
Live Programming allows programmers to gain information about the program continuously during its development. While it has been implemented in various integrated development environments (IDEs) for programmers, its interaction techniques such as slider widgets for continuous parameter tuning are comprehensible for people without any prior knowledge of programming and have been widely used for a long time.
In this paper, we aim to introduce prior work on Live Programming research from the interaction point of view and relate it to Human-Computer Interaction research. We then name the subset of Live Programming interaction that only involves changes in constant values "Live Tuning." Our example IDEs that implement both Live Programming and Live Tuning interactions are showcased, followed by the discussion on the possible future direction of programming experience (PX) research.
Live Programming
- Interaction design for programmers, typically built in development environments
- Prior knowledge of programming is required.
- The entire programs are always live and editable.
- The programmer has full control and is responsible for every aspect of program details.
Live Tuning
- Interaction design for end-users, built in ordinary runtime environments
- Prior knowledge of programming is not required.
- Only a certain number of variables are editable.
- The programmer and end-user are separating their roles of specifying program details.
Motivation
Because programmers are tired
- There are more and more data-intensive programs such as animation design, IoT application development, machine learning, etc.
- The amount and variations of data far surpass what programmers alone can manage and edit. Intensive parameter tunings might be needed per user.
Because users are demanding
- Live Programming (changing program behaviors without losing context) can benefit end-users. In particular, they can comprehend parameter tuning interfaces and customize programs to match their needs.
- They typically do not have access to development environments since they lack prior knowledge of programming.
Example "Live Tuning" IDEs
TextAlive
TextAlive is an Integrated Design Environment for authoring Kinetic Typography videos.
For programmers: it allows development of algorithms to animate lyrics text in synchrony with music. The timing information of the lyrics text is automatically estimated and can be interactively corrected in the timeline interface. Changes to the animation algorithms update the resulting video in real time.
For end-users: it allows authoring Kinetic Typography videos just as other general video authoring tools. Each phrase, word, and character can be assigned an animation template with appropriate parameter values such as animation speed and font size.
f3.js: Form Follows Function()
f3.js is an Integrated Development Environment for developing IoT applications.
For programmers: It allows to write a single JavaScript codebase that defines not only the behavior of microcontrollers, sensors, and actuators but also the layout of their enclosures. The layout preview is updated in response to every edit in the source code, enabling live programming experience.
For end-users: it allows customizing and creating IoT applications without prior knowledge of programming nor soldering. Each IoT application has parameters to customize its behavior and layout, such as whether to add the countdown feature to a camera.
Discussion
Please refer to the paper (p.4-6) for the detailed discussion. Underlined options are those we consider the most interesting and promising.
- Programming environments (for programmers) are getting close to runtime environments (for end-users). Live Tuning is such a proposal to connect them through the tuning interfaces.
- Multiple levels of user interfaces allow varied flexibility to edit programs. Live Programming aims at the maximum flexibility and Live Tuning is somewhat in the middle between no and maximum flexibility.
- How can we resolve or avoid conflicts between edits by multiple users? 1) seriously implement conflict resolution mechanisms 2) discard old edits as typical Live Programming systems do 3) separate namespaces and resulting application instances 4) aggregate parameter values from different users.
- How can we achieve liveness when it takes time to apply edits? For instance, updating the 3D models is an instant process, but printing them takes time. 1) significantly progress the research of programmable matter 2) hack humans' feeling of liveness.