A collection of systems programming projects written in C and x86 assembly language. These projects focused on low-level programming, memory management, performance optimization, and understanding computer architecture fundamentals.
PLEASE NOTE: All source code is available for request from William.Goldman@tufts.edu
A fully functional Reverse Polish Notation (RPN) calculator implemented entirely in Universal Machine Assembly language. The system uses a finite-state machine to process character-by-character numerical input and manages a value stack for arithmetic operations. The implementation required strictly adhering to a recommended calling convention, creating custom macro instructions, and managing low-level program sections to ensure the assembly code mirrored the behavior of a reference C implementation.
A performance-tuning project dedicated to optimizing a Universal Machine emulator by identifying and eliminating computational bottlenecks. Using qcachegrind and valgrind, I profiled the emulator while running the "sandmark" benchmark to isolate high-latency instructions and memory access patterns. Improvements were achieved through code-tuning techniques such as reducing function-call overhead and optimizing the inner instruction-dispatch loop, resulting in measurable increases in MIPS performance
A software emulator for the "Universal Machine," a 32-bit virtual architecture featuring segmented memory and a custom instruction set. The system implements a complete execution cycle to run compiled .um binaries, managing a machine state that includes eight general-purpose registers and dynamic memory mapping. Key technical challenges included simulating 32-bit segment identifiers on a native 64-bit system and optimizing the instruction-dispatch loop to meet specific millions-of-instructions-per-second (MIPS) performance benchmarks.
A reverse-engineering project focused on defusing a "binary bomb" executable by analyzing its AMD64 (x86_64) assembly code. Using the GNU Debugger (GDB) and objdump, I performed deep-dive analysis into six distinct phases of increasing complexity, identifying control-flow structures, stack frame management, and data-flow patterns. This required a precise understanding of the calling convention, register usage, and the Instruction Set Architecture (ISA) level representation of C procedures.
A lossy image compression tool modeled after the JPEG standard, utilizing color space transformation and discrete cosine transforms (DCT). The program converts PPM images from RGB to component video before quantizing luminance and chroma data into 32-bit codewords. A significant portion of the project involved building a robust Bitpack interface to manipulate bit-level data, requiring careful handling of two's-complement signed integers and floating-point precision6666.
An experimental study of cache performance and memory locality through the implementation of polymorphic, blocked 2D arrays. The project focused on optimizing image rotation algorithms by comparing row-major, column-major, and block-major access patterns. Technical deliverables included a performance analysis that used cache-hit predictions and measurement tools to explain the dramatic execution-time differences caused by spatial and temporal locality in the CPU cache.
A suite of data structures and applications built around custom 2D unboxed arrays (UArray2) and bit-mapped arrays (Bit2). The project demonstrates modular design through two primary applications: a Sudoku solution verifier and an "unblackedges" tool that utilizes a depth-first search (DFS) or similar traversal to remove bordering black pixels from PBM images. This assignment emphasized the design of clean function contracts, representation invariants, and polymorphic interfaces.
An image restoration utility designed to recover corrupted digital images by identifying and extracting hidden data within a proprietary file format. The project involved implementing a modular readaline interface for robust input handling and building a restoration engine that uses pattern recognition to filter out "treacherous" data. This served as an introduction to managing memory with Hanson’s interfaces and developing large-scale C programs with a heavy focus on modularity and pointer arithmetic.