Howdy! I'm Josh, a senior at Rice University studying Computer Science and Math.

First things first, I'm **definitely not** a web developer!
I'm passionate about algorithms, low level performance optimization, and distributed systems.
I've especially enjoyed my recent work in
Rice's Sketching and Hashing Lab,
where I've just written a paper
describing a new algorithm for lightning fast high dimensional near neighbor search.
I've also been busy in industry, where I've designed, built, and productionized scalable storage services
while interning at Two Sigma and Databricks.

In my free time, I like to run and go backpacking. Luckily those, along with programming, can all be practiced at a safe social distance.

A framework I built to simulate a wide variety of full ballot voting strategies and ballots. The end goal is to use the mistakes the models make to identify ballot deficiencies and improve the accuracy of human voting.

A clean and simple Chrome extension that displays a fully functional
browser of Wikipedia pages in a tooltip in response to highlighted words or phrases.

A background Electron app that tracks posture using a PoseNet model
and notifies the user when they are slouching.

Project Euler is a collection of mathematical programming challenges. It got me into programming many years ago, and so holds a special place in my heart. I've never really stopped solving problems, and as the quality of my math and programming skills has increased so has the difficulty of the problems I've attempted. I've solved ~240 problems, and although I'm honor bound not to post solutions, I've posted a few of my favorites problems below. Feel free to take a crack at them, but I'm warning you they're harder than they seem!

I'll leave you with a little story of the making of the
"howdy" gif at the top of this page to sate your curiosity
(I get a lot of requests about it, and by that I mean one so far).
I can't do the story justice within this margin, but here's the
abbreviated version:

Long ago, I was captivated by the idea of creating the "perfect" bouncing
ball simulation. Instead of updating each ball and checking for a
collision, a horribly inexact updating mechanism, I projected each
balls' path and calculated the exact intersection time for each pair,
then found the minimum over all such times to find the next collision.

Unfortunately and to my horror, I eventually realized my simulation
*wasn't* perfect:
the exact solution for collision times involved square roots and
thus irrational numbers, and the position vector had only finite precision.
Even worse, because I was simulating a chaotic system, after a
few hundred collisions the results of my simulation
wildly diverged from the exact solution.

Distraught, I wondered if it all my work was for naught. Was it
even possible to construct a perfect bouncing ball simulation?
The repo fell into disrepair. (As a side note, I think the answer is
"no"—at least with finite compute + space—but I have some ideas for ball
simulation version 2 that will push the errors out far along into the
simulation)

Two years pass, and we come to the modern day. When I was building
this website I needed a "hook" to draw the reader in
(maybe it worked? you've read this far, after all).
"Aha!" I thought to myself, "What if I could repurpose
my old work?" I proceeded to hatch a harebrained scheme: set up a careful
arrangement of balls to spell out a word, then turn on a screen recorder,
let the balls bounce... and then *reverse* the recording!

6 hours of implementation details later (see the
repo),
amd I was done!
And that's the story of how I reversed entropy. Perhaps unsurprisingly,
like a video of an egg getting unscrambled, the secret is simple
movie magic.

So it goes.