Making the Invisible Visible in Computational Notebooks

Abstract

Notebooks are increasingly popular programming tools adopted by a diverse range of users, including professional and novice users, from various fields not necessarily skilled in software engineering, to experiment with programming and develop software. Notebooks are often used within interactive and exploratory programming settings; however, some of their main use cases are not naturally supported by their design. For example, users can only get insights into the program's state by executing program fragments and updating one's mental model. This paper discusses the possibility of defining widgets to improve notebooks by providing direct insights into the program state. The widgets are developed upon previous work in which a novel approach to incremental programming is suggested based on the notion of an exploring interpreter. As example, we present widgets for visualizing execution history and variable assignments, thereby reducing the cognitive load on users.

A Language-Parametric Approach to Exploratory Programming Environments

“…Especially non-expert users copypaste code snippets and start tweaking them to understand their semantics and to adapt them to achieve their goals [31]. Users require a mechanism to display the history of the different commands they have executed in their sessions with a limited number of actions and be able to interact the alternatives they have created [16,21,33,36,65]. As discussed later, our experimental front-end supports backtracking with unlimited levels of undo/redo and branching explicitly, as suggested by Hauswirth and Azadmanesh [15].…”

“…As the front-end is based on the EPP, it naturally supports backtracking and jumping to previous program states (history). Rather than visualizing the execution tree such as in [33,60], the front-end shows a single 'execution trace' corresponding to the path in the tree from the root node to the node representing the current program state (center component). For each edge in the trace, the executed program is shown together with its output 4 (feedback) and a button to revert to the state prior to that execution.…”

“…One way specialization is achieved is by making the implementation of a feature parametric such that language-specific behavior can be provided as an argument. For example, a variable watcher [33] ś showing the assignments to variables in the current run-time state ś can be implemented such that a function is given as an argument that extracts variable assignments from a configuration. A different argument is used for different object languages as each language has its own notion of configuration and approach to keeping track of assignments.…”

“…This work reports on the next step in a research line aimed at designing and implementing features that simplify exploratory programming in (general-purpose and domain-specific) programming environments. Previous work has demonstrated how software languages can be (re-)designed to enable exploratory programming with 'execution graphs' encoding execution histories as a central datastructure [11,33,60]. This paper contributes by presenting a protocol for interacting with execution graphs alongside an architecture designed for prototyping exploratory programming features.…”