Hazelnut: a bidirectionally typed structure editor calculus

Omar, Cyrus; Voysey, Ian; Hilton, Michael; Aldrich, Jonathan; Hammer, Matthew A.

doi:10.1145/3009837.3009900

Cited by 25 publications

(39 citation statements)

References 75 publications

(90 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…"extract variable" has no effect on the result; "change constant value" forces recomputation of subsequent code). This can be elegantly implemented using bi-directional lambda calculus [43], but it also makes us consider more human-centric abstractions [14,15] further discussed in appendix D.…”

Section: Related and Future Workmentioning

confidence: 99%

Foundations of a live data exploration environment

Petříček

2020

Programming

View full text Add to dashboard Cite

A growing amount of code is written to explore and analyze data, often by data analysts who do not have a traditional background in programming, for example by journalists. The way such data anlysts write code is different from the way software engineers do so. They use few abstractions, work interactively and rely heavily on external libraries. We aim to capture this way of working and build a programming environment that makes data exploration easier by providing instant live feedback.We combine theoretical and applied approach. We present the data exploration calculus, a formal language that captures the structure of code written by data analysts. We then implement a data exploration environment that evaluates code instantly during editing and shows previews of the results. We formally describe an algorithm for providing instant previews for the data exploration calculus that allows the user to modify code in an unrestricted way in a text editor. Supporting interactive editing is tricky as any edit can change the structure of code and fully recomputing the output would be too expensive. We prove that our algorithm is correct and that it reuses previous results when updating previews after a number of common code edit operations. We also illustrate the practicality of our approach with an empirical evaluation and a case study.As data analysis becomes an ever more important use of programming, research on programming languages and tools needs to consider new kinds of programming workflows appropriate for those domains and conceive new kinds of tools that can support them. The present paper is one step in this important direction. ACM CCS 2012Human-centered computing → Interactive systems and tools; Information systems → Data mining;Software and its engineering → Compilers;Foundations of a live data exploration environment development and execution. Data analysts write small snippets of code, run them to see results immediately and then revise them.Notebooks are used by users ranging from scientists who implement complex models of physical systems to journalists who perform simple data aggregations and create visualizations. Our focus is on the simplest use cases. Making programmatic data exploration more spreadsheet-like should encourage users to choose programming tools over spreadsheets, resulting in more reproducible and transparent data analyses.Consider the Financial Times analysis of plastic waste [7,25]. It joins datasets from Eurostat, UN Comtrade and more, aggregates the data and builds a visualization comparing waste flows in 2017 and 2018. Figure 1 shows an excerpt from one notebook of the data analysis. The code has a number of important properties:There is no abstraction. The analysis uses lambda functions as arguments to library calls, but it does not define any custom functions. Code is parameterized by having a global variable material set to "plastics" and keeping other possible values in a comment. This lets the analyst run and check results of intermediate steps.The code relies on external lib...

show abstract

Section: Related and Future Workmentioning

confidence: 99%

Foundations of a live data exploration environment

Petříček

2020

Programming

View full text Add to dashboard Cite

show abstract

“…We start with the type system of the Hazelnut Live external language, which closely follows the Hazelnut type system [Omar et al 2017a]; we summarize the minor differences as they come up. The type synthesis judgement Γ ⊢ e ⇒ τ synthesizes a type τ for external expression e under typing context Γ, which tracks typing assumptions of the form x : τ in the usual manner [Harper 2016;Pierce 2002].…”

Section: Static Semantics Of the External Languagementioning

confidence: 99%

“…Throughout the process of addressing these errors, which can sometimes span many days, the program text remains formally meaningless. About 40% of edits performed by Java programmers using Eclipse left the program text malformed [Omar et al 2017a] and some additional number, which could not be determined from the data gathered by Yoon and Myers [2014], were well-formed but ill-typed.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Live functional programming with typed holes

Omar

Voysey

Chugh

et al. 2019

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

Live programming environments aim to provide programmers (and sometimes audiences) with continuous feedback about a program's dynamic behavior as it is being edited. The problem is that programming languages typically assign dynamic meaning only to programs that are complete, i.e. syntactically well-formed and free of type errors. Consequently, live feedback presented to the programmer exhibits temporal or perceptive gaps. This paper confronts this "gap problem" from type-theoretic first principles by developing a dynamic semantics for incomplete functional programs, starting from the static semantics for incomplete functional programs developed in recent work on Hazelnut. We model incomplete functional programs as expressions with holes, with empty holes standing for missing expressions or types, and non-empty holes operating as membranes around static and dynamic type inconsistencies. Rather than aborting when evaluation encounters any of these holes as in some existing systems, evaluation proceeds around holes, tracking the closure around each hole instance as it flows through the remainder of the program. Editor services can use the information in these hole closures to help the programmer develop and confirm their mental model of the behavior of the complete portions of the program as they decide how to fill the remaining holes. Hole closures also enable a fill-and-resume operation that avoids the need to restart evaluation after edits that amount to hole filling. Formally, the semantics borrows machinery from both gradual type theory (which supplies the basis for handling unfilled type holes) and contextual modal type theory (which supplies a logical basis for hole closures), combining these and developing additional machinery necessary to continue evaluation past holes while maintaining type safety. We have mechanized the metatheory of the core calculus, called Hazelnut Live, using the Agda proof assistant.We have also implemented these ideas into the Hazel programming environment. The implementation inserts holes automatically, following the Hazelnut edit action calculus, to guarantee that every editor state has some (possibly incomplete) type. Taken together with this paper's type safety property, the result is a proof-of-concept live programming environment where rich dynamic feedback is truly available without gaps, i.e. for every reachable editor state.

show abstract

“…As future work, we will extend HFI into an interactive program editor, based on our existing bidirectional type system, and the (typed) structure editor approach developed by Omar et al [2017a]. We speculate that Fungi itself may be useful in the implementation of this tool, by providing language support for interactive, incremental developer features [Omar et al 2017b].…”

Section: Prototype In Rustmentioning

confidence: 99%

Incremental computation with names

et al. 2015

Self Cite

View full text Add to dashboard Cite

Over the past thirty years, there has been significant progress in developing general-purpose, language-based approaches to incremental computation, which aims to efficiently update the result of a computation when an input is changed. A key design challenge in such approaches is how to provide efficient incremental support for a broad range of programs. In this paper, we argue that first-class names are a critical linguistic feature for efficient incremental computation. Names identify computations to be reused across differing runs of a program, and making them first class gives programmers a high level of control over reuse. We demonstrate the benefits of names by presenting NOMI-NAL ADAPTON, an ML-like language for incremental computation with names. We describe how to use NOMINAL ADAPTON to efficiently incrementalize several standard programming patterns-including maps, folds, and unfoldsand show how to build efficient, incremental probabilistic trees and tries. Since NOMINAL ADAPTON's implementation is subtle, we formalize it as a core calculus and prove it is from-scratch consistent, meaning it always produces the same answer as simply re-running the computation. Finally, we demonstrate that NOMINAL ADAPTON can provide large speedups over both from-scratch computation and ADAPTON, a previous state-of-the-art incremental computation system.

show abstract

Hazelnut: a bidirectionally typed structure editor calculus

Cited by 25 publications

References 75 publications

Foundations of a live data exploration environment

Foundations of a live data exploration environment

Live functional programming with typed holes

Incremental computation with names

Contact Info

Product

Resources

About