CIS 352, Spring 2021

Undergraduate programming languages course. Occurs every Spring at Syracuse. Currently in development.

CIS 700, Fall 2020

Graduate seminar. Formal methods in computer security. This was a small reading group of students that worked to study a variety of topics and papers. We looked into Soufflé, Coq, noninterference, Sel4, and other tools that lie at the synthesis of formal methods and computer security.

CIS 352, Spring 2020

Our undergraduate programming languages course at Syracuse takes a semantics-focused approach, and includes a set of challenging programming projects meant to build core competency in programming.

CIS 700, Fall 2020

This is a course that focuses on the theory and practice of static analysis. We first cover standard formulations of programming language semantics (e.g., metacircular interpreters, big/small-step semantics) and continue by introducing ideas from lattice theory, abstract interpretation, and abstract-machine-based analysis techniques.

CMSC 245, Spring 2019

This is the second iteration of my programming languages course at Haverford. This iteration features an autograding tool we built so that students can get immediate feedback on their work.

CMSC 395, Fall 2018

CS 395 is a exciting project-based course that teaches software engineering by pairing student groups with nonprofit groups for which they build apps. I was really proud of the course outcomes, and we were able to work with some really awesome organizations.

CMSC 107, Fall 2018

Path finding project in CS 107

Fall 2018 I taught a revamped version of the introductory course at Haverford. My offering was fairly unique in that I replaced all of the course projects with incremental assignments that had students write core data structures and eventually built up to the implementation a tile-based videogame (complete with enemy AI!). A few example projects are available here, here, and here.

CMSC 311, Spring 2018

Spring 2018 I taught a new course (for Haverford) in computer security. We covered a broad set of attacks and defenses. Students build an end-to-end project, and hold each other accountable by finding exploits and breaking each other’s projects.

CMSC 245, Fall 2017

The course covers programming paradigms at several different levels of hardware abstraction, and teaches students to both understand how the machine executes code and expand their foundational understanding of programming abstractions. The main course website is here.

CMSC 330, Summer 2015

330 Board screenshot

Link to GitHub repository with examples

During the summer of 2015, I taught CMSC 330, an undergraduate course on programming languages. CMSC 330 covers a wide range of concepts in programming languages: both foundational and practical. In particular, the students learn OCaml, Ruby, and Prolog, and learn core material such as automata theory (finite state machines and grammars) and programming language semantics.

For the Summer 2015 iteration of the course, I reworked a large part of the lectures to cover the same set of material, but presented it in an interactive style: developing concepts in class, while supplementing this development with projects and course notes. I also elected to put more emphasis on teaching functional programming and programming language semantics. The course included extensive coverage of small step semantics: for one project students implement an interpreter for a core-ML.

Relevant lecture material I particular enjoyed writing includes:

One off lectures

Occasionally I get invited to give one-off lectures in various classes. I see this as a great opportunity to expend some energy into digesting a topic well enough to present it to other people in a comprehensible way. In particular, I have a set of lectures I’ve given (some a few times) in courses: