About Me

Hi there! My name is Justin Lubin. I’m excited by programming languages, human-computer interaction, social justice, music, mathematics, and vegan cooking.

I am a second-year PhD student in computer science advised by Sarah E. Chasins at UC Berkeley, where I’m part of the Programming Systems Research Group. Previously, as an undergraduate at UChicago, I worked extensively with Ravi Chugh. These folks have been absolutely fantastic mentors to me!

Research

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

Here are some of the projects I’ve worked on! Please also feel free to take a look at my CV.

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. The goal of this work is to address this knowledge gap: to better understand the high-level authoring patterns that statically-typed functional programmers employ.

Program Sketching with Live Bidirectional Evaluation

We present a system called Smyth for program sketching in a typed functional language whereby the concrete evaluation of ordinary assertions gives rise to input-output examples, which are then used to guide the search to complete the holes. The key innovation, called live bidirectional evaluation, propagates examples “backward” through partially evaluated sketches. Live bidirectional evaluation enables Smyth to (a) synthesize recursive functions without trace-complete sets of examples and (b) specify and solve interdependent synthesis goals. Eliminating the trace-completeness requirement resolves a significant limitation faced by prior synthesis techniques when given partial specifications in the form of input-output examples.

Type-Directed Program Transformations for the Working Functional Programmer

We present preliminary research on Deuce+, a set of tools integrating plain text editing with structural manipulation that brings the power of expressive and extensible type-directed program transformations to everyday, working programmers without a background in computer science or mathematical theory. Deuce+ comprises three components: (i) a novel set of type-directed program transformations, (ii) support for syntax constraints for specifying “code style sheets” as a means of flexibly ensuring the consistency of both the concrete and abstract syntax of the output of program transformations, and (iii) a domain-specific language for specifying program transformations that can operate at a high level on the abstract (and/or concrete) syntax tree of a program and interface with syntax constraints to expose end-user options and alleviate tedious and potentially mutually inconsistent style choices.

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? To obtain both flexibility and ease of use, a number of systems have explored a workflow that we call output-directed programming. In this paradigm, direct manipulation of the program's graphical output corresponds to writing code in a general-purpose programming language, and edits not possible with the mouse can still be enacted through ordinary text edits to the program. Such capabilities provide hope for integrating graphical user interfaces into what are currently text-centric programming environments.

To further advance this vision, we present a variety of new output-directed techniques that extend the expressive power of Sketch-n-Sketch, an output-directed programming system for creating programs that generate vector graphics. To enable output-directed interaction at more stages of program construction, we expose intermediate execution products for manipulation and we present a mechanism for contextual drawing. Looking forward to output-directed programming beyond vector graphics, we also offer generic refactorings through the GUI, and our techniques employ a domain-agnostic provenance tracing scheme.

Deuce: A Lightweight User Interface for Structured Editing

We present a structure-aware code editor, called Deuce, that is equipped with direct manipulation capabilities for invoking automated program transformations. Compared to traditional refactoring environments, Deuce employs a direct manipulation interface that is tightly integrated within a text-based editing workflow. In particular, Deuce draws (i) clickable widgets atop the source code that allow the user to structurally select the unstructured text for subexpressions and other relevant features, and (ii) a lightweight, interactive menu of potential transformations based on the current selections. We implement and evaluate our design with mostly standard transformations in the context of a small functional programming language. A controlled user study with 21 participants demonstrates that structural selection is preferred to a more traditional text-selection interface and may be faster overall once users gain experience with the tool. These results accord with Deuce's aim to provide human-friendly structural interactions on top of familiar text-based editing.

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. 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. Because quantification lifting operates on types rather than expressions, it may be used even when the effect-unannotated code is unavailable ahead of time, such as in the cases of dynamic loading and previously compiled code. To evaluate the practicality of quantification lifting, we implemented this transformation for use in the Wyvern programming language, and, in doing so, demonstrate how it allows for secure and ergonomic mixing of effect-unannotated code with effect-annotated code in a realistic capability-safe programming language.

News

I’m so excited to present How Statically-Typed Functional Programmers Write Code in-person at OOPSLA 2021! Really looking forward to some great conversations about the intersection of PL and HCI!
I was accepted to the CHI 2021 student research competition for my work on how statically-typed functional programmers write code!

I’ve been hard at work helping organize #ShutdownPL @ ICFP 2020, an anti-racism event happening from 2–6 PM (ET) on August 27. I hope to see you there!
My first full, first-author paper to a major conference venue has been unconditionally accepted for publication! Look out for Program Sketching with Live Bidirectional Evaluation at ICFP 2020!
I graduated from the University of Chicago! Now I have an honors BS in Computer Science, a BS in Mathematics, and a minor in Music!
I’m excited to announce that this fall I will start a PhD in computer science advised by Professor Sarah Chasins at the University of California, Berkeley in the Programming Systems Research group!
I presented Type-Directed Program Transformations for the Working Functional Programmer at PLATEAU 2019 and had a great time meeting people at this lovely conference!
I had a great time meeting people and presenting Program Synthesis with Live Bidirectional Evaluation at MWPLS 2019/PurPL Fest!
I’m very excited to be attending the Oregon Programming Languages Summer School this year!
I won first place in the SPLASH 2018 Student Research Competition for Approximating Polymorphic Effects with Capabilities!
I am excited to present a poster for Approximating Polymorphic Effects with Capabilities at the Midwest Programming Languages Summit 2018.
I am honored to be accepted to Carnegie Mellon’s Research Experiences for Undergraduates in Software Engineering (REUSE) program. Catch me in Pittsburgh this summer!

Fun

Compositions

In my free time, I like to compose music. Here are some of the pieces that I’ve composed! All my pieces are composed in the wonderful, open-source music notation software MuseScore. Stars () denote my current favorites!

  • Field (mp3 | pdf). String Quartet, April 2022.
  • Puzzle (mp3 | pdf). July 2021.
  • Meadow of the Pelagic (mp3 | pdf). Wind Quintet, April 2021.
  • Warm Encounter (recording | pdf). Variation on “Londonderry Air.” Solo Piano (recorded by Anthony Cheung), June 2020.
  • Looking Glass (mp3 | pdf). Solo Flute, May 2020.
  • Reminiscences (mp3 | pdf). String Quartet, May 2020.
  • Adventure (mp3 | pdf). Solo Piano, May 2020.
  • Focus (mp3 | pdf). Solo Piano, April 2020.
  • Revitalization (mp3 | pdf). Solo Viola, April 2020.
  • Slumber (mp3 | pdf). Solo Violin, April 2020.
  • An Impossibility (mp3 | pdf). Cello & Piano, January 2020.
  • Ring (mp3 | pdf). SBB, November 2019.
  • Florescence (mp3 | pdf). Orchestra, September 2019.
  • Morrow & Deseora Town (info). June 2019.
    • Morrow Town – Marielle (mp3 | pdf). Violin, Viola, Cello, Lute, Harpsichord.
    • Morrow Town – Felix (mp3 | pdf). Wind Quartet & Harp.
    • Morrow Town – Cordelia (mp3 | pdf). Trumpet, Horn, Trombone, Tuba, Drums.
    • Morrow Town – Reduction (mp3 | pdf).
    • Deseora Town – Marielle (mp3 | pdf). Violin, Viola, Cello, Lute, Harpsichord.
    • Deseora Town – Felix (mp3 | pdf). Wind Quartet & Harp.
    • Deseora Town – Cordelia (mp3 | pdf). Trumpet, Horn, Trombone, Tuba, Drums.
    • Deseora Town – Reduction (mp3 | pdf).
  • Jam (mp3 | pdf). Game Boy Synthesizer, April 2019.
  • Lucas (info). April 2019.
    • Theme (mp3 | pdf). String Quartet
    • Battle Theme (mp3 | pdf). Trumpet, Trumpet, Violin, Cello, Drums
  • Sonata in G Minor (mp3 | pdf). String Quartet, April 2019.
  • Invention in D Minor (mp3 | pdf). Keyboard, January 2019.
  • Lofty Stars (mp3 | pdf). Wind Quartet, December 2018.
  • Wind Quintet in C (mp3 | pdf). Wind Quintet, November 2018.
  • Reflections (mp3 | pdf). String Quartet, October 2018.
  • Dive (mp3 | pdf). Orchestra, August 2018.
  • Travels (mp3 | pdf). Synthesizer, August 2018.
  • Lessons (mp3 | pdf). Synthesizer, August 2018.
  • Realizations (mp3 | pdf). Synthesizer, July 2018.
  • Outset (mp3 | pdf). Synthesizer, June 2018.
  • Minuet and Trio in A (mp3 | pdf). Keyboard, May 2018.
  • Caged Bird (mp3 | pdf | annotated). SATB, April 2018.

The Shards of Mt. Lampora Play!

As my final project for the functional programming class that I took at the University of Chicago, I created The Shards of Mt. Lampora, a 2D platformer written using the Elm programming language featuring modular music that I composed myself.

As the player moves throughout the world and collects the shards it contains, the music responds dynamically. These musical details (along with some other information about the creation of the game) are further described in the brief presentation that I gave before demoing my game.

If you’d like, you can click here to play The Shards of Mt. Lampora! You can also view the source code for the game here and its sheet music here.