A close-up photo of Justin Lubin smiling.

Justin Lubin / Research


Computation is empowering, and programming languages are how we harness it. To that end, I study the human aspect of programming to develop programming languages, environments, and tools that are more accessible, intuitive, and powerful.

Here are some of the research projects I’ve worked on to achieve that goal. Please also feel free to take a look at my CV, which includes a list of publications.

Exploring the Learnability of Program Synthesizers by Novice Programmers

Modern program synthesizers are increasingly delivering on their promise of lightening the burden of programming by automatically generating code, but little research has addressed how we can make such systems learnable to all. In this work, we ask: What aspects of program synthesizers contribute to and detract from their learnability by novice programmers?

How Statically-Typed Functional Programmers Write Code

How working statically-typed functional programmers write code is largely understudied. And yet, a better understanding of developer practices could pave the way for the design of more useful and usable tooling, more ergonomic languages, and more effective on-ramps into programming communities. In this project, we address this knowledge gap by elucidating many high-level authoring patterns that statically-typed functional programmers employ.

Program Sketching with Live Bidirectional Evaluation

Sometimes, when faced with a programming task, it’s easier to provide some input-output examples along with a partial solution with “holes” in it (known as a “program sketch”) than it is to write an entire solution from scratch. In this project, we developed a program synthesizer that completes (potentially recursive) sketches in a statically-typed functional programming language given a set of input-output examples that need not match the recursive structure of the solution.

Sketch-n-Sketch: Output-Directed Programming for SVG

For creative tasks, programmers face a choice: Use a GUI and sacrifice flexibility, or write code and sacrifice ergonomics? In this project, we advance the vision of combining the best of these two worlds via a variety of new “output-directed” techniques in the domain of vector graphics that propagate changes from direct manipulation of a piece of code‘s output back to the code itself.

Deuce: A Lightweight User Interface for Structured Editing

Drafting and refactoring code via text edits can be tedious and error-prone. In this project, we introduce a structure-aware code editor equipped with direct manipulation capabilities for invoking automated program transformations that is tightly integrated within a text-based editing workflow.

Approximating Polymorphic Effects with Capabilities

Unforgeable tokens known as capabilities provide a flexible mechanism to control access to sensitive system resources, but reasoning about what parts of a codebase can and do use these capabilities is often imprecise and manual. Effect systems are one solution that can improve the precision of capability-based reasoning, but their verbosity has proven to be a usability concern. To remove the burden of full effect annotation, we propose “quantification lifting,” an automatic semantics-preserving type transformation to handle the mixing of effect-annotated and effect-unannotated code in a capability-safe language with mutable state and effect polymorphism.