Welcome!

I'm a student at University of Alabama at Birmingham working on a PHD in computer science with Thomas Gilray. We're working on tunable static analysis. Right now I'm mostly learning Racket.

As a side project I've worked with Rust's type-level system. I've learned to do computation with traits, and to set up simple type functions and semantic rules.

I received my master's degree through the Programming Languages and Verification group at CU Boulder, advised by Matthew Hammer. We worked together on incremental computation with Adapton in Rust.

In undergrad I worked with Adapton in OCaml at UMD's PLUM lab. I also worked on a few data visualizations in javascript.

Papers

• Incremental Computation with Names [ACM,Arxiv,PDF] Published in OOPSLA'15 proceedings

In Submission

• A DSL embedded in Rust[draft] Accepted for publication in iFL'18 proceedings
• The Random Access Zipper: Simple, Purely-Functional Sequences [Arxiv,PDF] Accepted for publication in TFP'16 proceedings

Presentations

• Towards Pervasive Incremental Computing Presented at UAB CS Coloquium Dec'18 with slides [PDF] (45 min)
• Embedding a DSL in Rust Presented at IFL'18 Symposium with slides [PDF] (20 min)
• Speed and Simplicity for Incremental Sequence Computation Presented at PLDI'17 SRC with slides [PDF] (10 min)
• Speed and Simplicity for Incremental Sequence Computation Presented at IC'17 with slides [PDF] (25 min)
• The Random Access Zipper Presented at PLDI'16 SRC with slides [PDF] (10 min)
• The Random Access Zipper: Simple, Purely-Functional Sequences Presented at TFP'16 with slides [PDF] (20 min)
• Correct-by-Construction Interactive Software Presented at OBT'16 with slides [PDF] (20 min)
• Sparse Adapton [YouTube] Presented at ICFP'15 SRC with slides [PDF] (8 min)

Posters

• Using Rust's Type-level Language [PDF] Displayed at ICFP'18 SRC
• IODyn: A High-level Language for Incremental Computation [PDF] Displayed at POPL'18 SRC
• Speed and Simplicity for Incremental Sequence Computation [PDF] Displayed at PLDI'17 SRC
• Random Access Zipper [PDF] Displayed at PLDI'16 SRC
• Sparse Adapton [PDF] Displayed at ICFP'15 SRC

Abstracts

• Using Rust's metalanguage as a DSL type checker [PDF] Accepted at ICFP'18 for the SRC
• Simplifying incremental code with IODyn [PDF] Accepted at POPL'18 for the SRC
• Tuning Data and Control Structures for Incremental Computation [IC,PDF] Accepted at IC'17 (with PLDI) for presentation (original submission [PDF])
• Random Access Zipper [PDF] Accepted at PLDI'16 for the SRC
• Correct-by-Construction Interactive Software: From Declarative Specifications to Efficient Implementations [OBT,PDF] Accepted at OBT'16 for presentation
• Space and Time Optimizations In Adapton [PDF] Accepted at ICFP'15 for the SRC

Drafts

• A DSL embedded in Rust (Partial Paper) [PDF,IFL Draft Proceedings] Accepted for presentation at IFL'18, (Full Paper) [PDF] Later accepted for main publication
• Programming in the Rust Type System (Proposal) [PDF] Prepared for POPL'18 Tutorials (not selected to give tutorial)
• IODyn: A High-level Language for Incremental Computation (Slides)[PDF] Prepared for POPL'18 SRC (not selected to give talk)
• The Random Access Zipper: Simple, Persistent Sequences (Partial Paper) [PDF] Accepted for presentation at TFP'16, (Full Paper) [PDF] Later accepted for publication in TFP'16
• Please Repeat Yourself: A Simple and Responsive Text Editor via Incremental Computation and the Random-Access Zipper (Full Paper) [PDF] Reorganized into later projects

Projects

TraitLang - Constraining a type-level langauge in Rust

• Draft - IFL'18 Talk Submission
• Poster - ICFP'18 Presentation
• Extended Abstract - ICFP'18 SRC Submission
• TraitLang DSL - early example

Fungi Language - Typed language for incremental computation

• Paper - Arxiv draft under development
• Rust implementation

IODyn Language - DSL for incremental computation

• Rust project
• Checkpoint Poster - POPL'18 SRC Presentation
• Checkpoint Abstract - POPL'18 SRC Submission

Type-Level Rust

• Experimental project - playing with different ideas
• Untyped lambda calcules - complex use of type functions
• early trials - copy some demos

Other Rust projects with types

• Traitlang DSL - type checking (and macro parse) example
• Inheritance demonstration - Traits augmenting value-level code
• Functor translations - Implementation of OCaml manual section on functiors
• HKT example - use traits as type functions

Giraz Collection - Sequence data structure using Adapton

• Rust project
• Cargo crate - rust language package
• Poster - PLDI'17 SRC presentation
• Slides - PLDI'17 SRC talk (10 min)
• Slides - IC'17 talk (25 min)
• Extended Abstract - PLDI'17 SRC Submission

Incremental Sorting - Memory-efficient incremental sort

• Rust project - Initial progress

RAZ - Random Access Zipper for functional sequence editing

• Paper - TFP'16
• Raz in OCaml
• Poster - PLDI'16 SRC presentation
• Slides - PLDI'16 SRC talk (10 min)
• Slides - TFP'16 talk (20 min)
• Paper Draft - TFP'16 talk
• Extended Abstract - PLDI'16 SRC Submission

IC_Edit - Incremental text editor programmed in rust

• PRY - Unsubmitted Paper
• Talk Abstract - OBT'16 Submission
• Rust project
• Semantics - early version
• Demos
• Slides
• Adapton in rust

Sparse Adapton - Uses fewer memo points for efficiency

• SRC Abstract - ICFP'15 Submission
• Poster
• Presentation
• Slides

Nominal Adapton - Exposes names for memo table rewriting

• Paper - OOPSLA'15
• Ocaml project
• VM artifact large file
• Artifact documentation: guide and supplement

Graphmovie - A viewer for dynamic graphs

• On-line
• JavaScript project - with samples

WebGL - some experiments with graphics

• Globe of Life - drag and zoom
• Dynamic Color - image creation

Teaching

• Programming Languages - UAB CS401/501 Spring '19 TA, lab instructor
• Priciples of Programming Languages - CU CSCI3155 Fall '18 TA lab instructor

Service

• Student Volunteer - ICFP'18
• Student Volunteer Co-Captain - PLDI'18
• Student Volunteer - POPL'18
• Student Volunteer - PLDI'17
• Faculty Candidate Evaluation, student group - CU Boulder, Spring 2016