Projects completed for a course during Joshua’s 4 years at Yale University.
Mechanical & Control Systems
Senior Capstone: ASML Wear Tester
ASML’s deep ultraviolet (DUV) lithography machines rely on a cable slab that undergoes repeated dynamic loading, leading to premature failure. Reproducing the exact operating conditions to evaluate replacement slabs is both costly and time-intensive. My capstone team was tasked with isolating the friction wear caused by the cable’s slap-and-slide motion and designing a machine capable of replicating that wear at an accelerated frequency. The resulting proof-of-concept provides ASML engineers a foundation to develop a higher-speed, precision testing platform for rapidly evaluating cable slab coatings.
I owned the electronics and embedded systems design for the device. Working outside my primary discipline, I collaborated closely with the mechanical team to understand system requirements, then designed a power and control circuit for a high-torque motor. Given the significant power demands needed to simulate real cable forces, safety was a central design consideration. The system incorporated emergency stop functionality that safely interrupted motor operation without damaging downstream electronics. The electronics and controls were reviewed and verified by multiple electrical engineers, confirming the safety and soundness of the design prior to final demonstration.
Ball Return Mechanism & Multi-Method Motion Analysis
In my Advanced Design and Analysis of Machines course, I synthesized and physically built a 6-bar mechanism designed to catch a ball, carry it up a structure, and drop it to be caught, completing a full cycle. Using three desired positions as design constraints, the mechanism features a quick-return driving dyad ensuring the catch position is reached ahead of the ball’s descent.
With the mechanism built, I validated the mechanism’s kinematics through three independent methods: MATLAB scripts using iterative numerical techniques, SolidWorks motion study, and video analysis via Tracker. To ensure each method was grounded in real-world data, I measured motor RPM directly from the built mechanism, then used that value as inputs across all three approaches. The result was 12 comparable datasets, velocity and acceleration in both x and y directions across all three methods, which I plotted against each other to evaluate consistency and accuracy. I CAD’d the mechanism in OnShape with careful attention to PLA 3D printing tolerances, successfully printed and assembled the design, then re-imported it into SolidWorks for motion analysis, which kept the virtual model grounded in the actual hardware throughout.
Self-Balancing Motorcycle
For the second half of a Mechatronics course, I designed and implemented the full control system for a small motorized bike. The platform featured a driven rear wheel for movement, a flywheel for active counterbalancing, and a servo-controlled front wheel for steering. The final challenge was to travel 2 meters completely unassisted while remaining upright.
The control system was built around an Arduino microcontroller paired with an IMU to measure real-time tilt and motor encoders to track wheel state. This data fed into a PID loop driving the flywheel to actively counteract imbalance. Steering added a layer of complexity as the front servo needed to simultaneously keep the bike tracking straight and assist with balance, two goals that frequently conflicted. I resolved this by weighting and averaging the competing control signals into a single output value sent to the servo.
Before tuning on hardware, I grounded the design in analytical first principles by deriving transfer functions from the bike’s dynamics, constructing root locus plots, and simulating step responses to identify optimal PID parameters. These simulated values served as informed starting points for real-system tuning, narrowing the gap between model and hardware and ultimately yielding a controller that successfully completed the challenge.
Software & Computer Systems
Parallelization Analysis of Block Banded Triangular Solver (BBTS) For Linear Systems
For an open-ended final project in a parallel programming course, I chose to explore an area of genuine personal interest: the optimization of numerical solvers. Block banded triangular systems are a class of structured linear algebra problems that appear frequently in computational science and engineering applications. While an efficient parallel algorithm for solving these systems already exists, I identified opportunities for further optimization through deeper analysis of its implementation.
Starting from a publicly available OpenMP implementation, I worked through the underlying mathematics to pinpoint parallelism opportunities that had not yet been exploited. I then reimplemented the algorithm using ParlayLib, systematically evaluating how different scheduling strategies, thread counts, and chunk sizes affected performance on real hardware. My findings were presented to my professor and class, and culminated in a 7-page technical report covering the mathematical foundations, implementation decisions, and final conclusions.
MiniShell: Unix Shell Implementation in C
As part of a computer systems course, I implemented a simplified Unix shell in C from the ground up, building core infrastructure without relying on standard library conveniences. This included a hand-written parser, a custom string header, and dynamic string and array implementations originally developed in an earlier assignment. Choosing to carry those custom implementations forward, rather than defaulting to standard alternatives, introduced deeper edge cases that pushed me to write more rigorous and secure code.
The shell supports 8 built-in commands composable via pipes and binary operators (&& and ||), and uses fork() to run background jobs in parallel. Spanning over 1,600 lines of code across multiple files, the project gave me hands-on experience debugging a larger C codebase and deepened my understanding of system-level programming and process management.
Minicompiler: Source to Source Transpiler in D
As part of a computer systems course, I built a compiler for a simplified programming language, supporting control flow, expressions, and loops, that transpiles source code to C. Written in D, a systems-level language with stronger memory safety guarantees than C or C++, the project was a dual challenge: learning compiler construction while working in an unfamiliar language under course constraints.
Though compact at under 500 lines of code, the project demanded a disciplined, incremental workflow. Each feature was tested thoroughly before building the next, since correctness at every stage was a prerequisite for everything that depended on it. Working through the core stages of the compilation pipeline, including lexing and parsing, gave me firsthand insight into how high-level languages are systematically reduced to lower-level representations.
Custom Memory Allocator in D
As part of a computer systems course, I implemented a custom heap memory allocator in D, built on low-level system calls, using sbrk() for heap expansion and mmap() for larger allocations. Rather than growing the heap indefinitely, the allocator uses a first-fit algorithm to efficiently locate and reuse freed memory blocks, mirroring the core design decisions found in real-world allocators.
The project deepened my understanding of how memory management systems balance allocation efficiency against fragmentation and overhead across varying request sizes. It also pushed my fluency in D further, particularly around the language’s strict type casting rules demanding precision when working directly with raw memory.