blue-ot.js - collaborative text editing

This is an implementation/demo of collaborative text editing via operational transforms. It's mostly inspired by Daniel Spiewak's description of operational transform.

Initially, I implemented the seminal (though, unfortunately, incorrect) Concurrency Control in Groupware Systems from 1989. You can see that unsuccessful implementation in my git history.

This implementation includes transformation/composition of operations, generation of operations based on text changes, and application of operations to text. In addition, it includes all the logic necessary for handling communication and conflict resolution between multiple clients over an out-of-order high-latency network.

You can see the source-code on GitHub and a detailed writeup + demo online.

Real-time Hatched Renderer

I built this renderer from scratch in modern C++. I use RAII to handle OpenGL resources, lambda closures to cleanly setup different shader pipelines, shared_ptr for memory management, etc.

It renders a scene with soft shadows using variance shadow mapping [Donnelly 2006], hemisphere based screen-space ambient occlusion, and real-time hatching [Praun 2001].

You can see the source-code on GitHub and a detailed writeup online.

(ssao, real-time hatching, variance shadow maps, diffuse lighting)

Star Captain

A toy star-ship simulation I built to learn fundamentals of FlowType. I experimented with a functional style, relying heavily on stateless functions and Flow's algebraic type system.

Check out the sourcecode on GitHub!


BlueDocs

In early 2016, I built a collaborative markdown editor backed by FirePad and CodeMirror. I ran it for about a month (garnering about 3,000 pageviews).

You can see the source-code on GitHub.


PanesLibrary

PanesLibrary was an open-source library I built in 2013 that makes it ridiculously easy to build native Android apps with flexible multi-pane tablet layouts. On the phone, the app appears as a conventional app with a sliding menu and a content pane where fragments are stacked on top of each other. On the tablet, the menu and all other fragments appear in dynamically added panes of varying sizes.

It's been starred >300 times, forked >100 times, and used (by others) in production!

Rex: Explore the App World (1 year, 3 months)

I co-founded Rex (originally called Mapsaurus) with Danny Guo, Evan Leichter, and Alice Zheng in early 2012. We participated in TigerLabs University Accelerator in summer 2012, raised a small angel round in late 2012, and shut down the company in late 2013. In addition to general project management and investor relations, I worked on our Python backend, Javascript/HTML5 frontend, and owned our Android frontend.

Our goal was to build the easiest way to discover new Android apps. Rex provided personalized app recommendations and a unique, visual interface for exploring related apps. ~60,000 people downloaded our app.

AutoWallpaper

AutoWallpaper updates the wallpaper of your phone with the top images from Reddit multiple times a day. It's been downloaded >20,000 times.

CurtainBot

A custom built, Arduino powered curtain opening alarm clock!

Codecademy (10 months)

I worked at Codecademy for 10 months as a full-stack engineer in Javascript + Rails.

During my time there, I worked on adding support for user-created projects and rebranding the website. In addition, I owned, developed, and wrote tests for the inline code + preview widgets. I also rapidly developed and user-tested prototypes for an annotated debugger, a quiz game, bugfix challenge, and more.

(debugger prototype)

Path Tracer

This is a path tracer I built for COS 526, a graduate level course on graphics. It handles caustics, reflections, refractions, and general indirect lighting. You can see the source-code on GitHub.

Imperfect Shadow Maps

Fall of 2011, I worked on an algorithm for computing radiosity utilizing imperfect shadow maps inspired by Ritschel 2008. This method involves splatting a point representation of the scene to generate a shadow map. Multiple imperfect shadow maps can be generated in a single rendering pass.



(standard shadow maps, imperfect shadow maps)

Rest In Peace

The ghosts of the dead haunt one dimension and the dead come back to life in the other!

I built RIP in 48 hours for the 30th Ludum Dare competition. It's coded from scratch in Javascript using HTML5 <canvas/>.

You can play it in your browser or checkout the sourcecode on GitHub!


Wolfenstein AI

For our computer vision final project, Kynan Rilee, Robert Timpe, and I built an AI that plays (and beats) the first level of Wolfenstein 3D. It analyzes the pixels on the screen and spoofs keyboard events to play the game.

My part of the project was figuring out how to localize the player. I used a particle filter that took, as input, randomly sampled depth measurements. These depths were determined by judging the height of the visible wall.

Escape!

This is a classic stealth game set in a pastel colored world inhabited by Death.

I built Escape over a week for the Insanity Jam competition. It's coded in C# using Unity3D.

Play it here: Unity Web Player, Linux, Windows, Mac

Dead Arcade

Summer of 2011, Justin Kruskal (coder), Melinda B (artist), and I built Dead Arcade, an Android game based on the original Mario Bros arcade game. The game engine we built relies on an entity/component model and renders with OpenGL.

Until Rex, this was my biggest project. It was the first time I'd worked with another programmer for a significant period of time and the first time I actually polished and published something. Since publishing it late 2011 (polishing it took a lot of time), it's been downloaded 23,000 times.

Facebook Princeton Hackathon (2011)

I built this game from scratch in 24 hours for the Facebook Princeton Hackathon (2nd place!). It's a tower-defense real-time-strategy game. The AI relies mostly on gradient descent and a grid data structure.

Checkout the sourcecode on GitHub.

Zombie Shooter

For our graphics final project, Kynan Rilee and I built a top-down zombie shooter from scratch in C++ using OpenGL. It includes billiard ball physics, baked lighting, point/spot/directional light, simple object avoidance, boid AI, and more!

2D Java Game Engine (olden times)

In early college, I discovered Java generics and set out to build a flexible 2D game engine.

The engine was somewhat flexible-- I used it to build a single-screen Mario Bros platform in just a couple of days and an Asteroids-style shooter in an afternoon. I dropped the project, however, after struggling for a few weeks to build an RTS using the engine.

Checkout the sourcecode on GitHub.

2D Java Games (ancient times)

In high school and early college, I made a bunch of simple Java games from scratch. These games are how I learned the basics of programming and began to grok principles like modular design, inheritance, thread-safe programming, and more. I consider these games a huge part of my education. It's by suffering through my own over-engineered or poorly designed game that I learned the value of simplicity.


Wolfenstein: Source (ancient times)

Wolfenstein: Source is a Half Life 2 mod I made in high school. The goal was to convert the classic Wolfenstein 3D video game to the Source engine. I built a Java program that would process Wolfenstein 3D maps and generate Half Life 2 levels. While the first level was playable, I never finished the project.

Wolfenstein: Source Wolfenstein 3d

Yoda Life (pre-history)

Yoda Life is a Half Life mod I made freshman year of high school. It's Half Life, except every character is Yoda and all the weapons are from Star Wars.