This is my programming portfolio. These are mostly small programs written to study specific topics. These copies are meant to be read, not compiled or executed and may have some bit-rot. They did all work at one point. My active projects are available at: http://github.com/rayiner. Verrazano is now maintained by Attila Lendvai and is available at: http://common-lisp.net/project/fetter. All code herein was written by myself, except where otherwise noted.

This is a prototype and mockup of the air traffic control system described in the paper: Feigh & Bruneau, "Incorporating Controller Intent into a Runway Incursion Prevention System." The paper is based on a project submission to the 2007 FAA Airport Design Competition, Runway Safety category.

The prototype is a Java program that simulates the proposed user interface of the air traffic control system. It features:

• A GUI written using Swing
• Loading and rendering of airport runway maps (ATL and PDK) stored in vector format
• Use of Dijkstra's algorithm for finding the shortest path to a destination along taxiways
• Simulated communications between the tower and aircraft using the proposed protocol

This is an assembler that generates AMD64 binary machine code. It is written in Common Lisp. It features:

• Use of macros to generate encoding functions at compile-time from declarative instruction specifications
• Use of macros to generate randomized testing functions from the same specifications that drive the encoder
• A testing framework that checks that the output is bit-for-bit identical with that of YASM
• A "jump relaxation" algorithm to minimize the size of compiled jumps
• Simplistic output to linkable Mach-O object files

This is a simple simulation of a gas turbine (jet engine) written in Matlab. It uses a thermodynamic model to evaluate the performance impact of varying certain design parameters.

This was my project for the Google Summer of Code 2005. It is a tool that automatically generates foreign function interface (FFI) declarations from C++ headers. The program is written in Common Lisp. It features:

• Parsing of an XML representation of C++ programs
• Lowering of complex C++ semantics into a simpler intermediate representation
• Various transformations to generate more Lisp-like bindings from C++ APIs
• Generation of C-FFI declarations (attempting to be) compatible with the GCC C++ ABI

Portions of this code were written by Attila Lendvai, who took over maintainership of the project in 2007.

I prototyped a KDE/Qt implementation of the METACITY_UPDATE_COUNTER protocol, which had been included in Metacity/GTK+, but was not standardized and not implemented in KDE/Qt. I contributed to the ensuing discussion, which led to the standardization of the _NET_WM_SYNC_REQUEST protocol.

The prototype involved:

• Modifications to Qt to cause it to signal when it finishes drawing a frame
• Modifications to Kwin to avoid resizing and redrawing a window frame until Qt finishes drawing
• Use of the X11 SYNC extension to block the window manager while waiting for the client to redraw

A very simple Lisp interpreter along with an Emacs mode for its syntax.

An implementation of Joel F. Bartlett's mostly-copying garbage collection algorithm, which mixes conservative root scavenging with precise object copying. As a modification, I experimented with optimistically allowing the mutator to fill up more than the half of the heap allowed in a traditional semi-space algorithm and using a fallback compactor when this resulted in the collector running out of space before all live objects could be copied. The included technical report is Bartlett's original report.

Open Dylan as an implementation of the Dylan language developed as a commercial project and open-sourced in 2004. The directory contains several of my patches to the project:

• Fixing up the C backend, which had not been used for some time
• Porting the system, with the C backend, to Mac OS X (x86 and PPC)
• Fixing certain bugs in the C-FFI

The changes in the patches are mine, but the system as a whole was not written by me.

This is a simple Matlab program that applies a finite-element model to the task of optimizing the figure of merit of a helicopter rotor.

This program takes a simple source language as input (an assembly-level language with virtual registers), and performs various transformations on it as would be done in an optimizing compiler. It features:

• Construction of a control flow graph from the source-level representation
• A worklist-based iterative data-flow solver
• Dominance analysis using the algorithm of Cooper, Harvey, and Kennedy
• Liveness analysis based on the data-flow solver
• Construction of pruned SSA form using the method outlined in Cooper & Torczon's "Engineering a Compiler"
• Copy propagation in SSA form
• Elimination of SSA form minimizing inserted copies using Sreedhar's algorithm, along with Tarjan's union-find data structure
• Computation of the interference graph and register allocation using Chaitin's graph coloring algorithm