Projects

Here are a list of projects that I have done outside of work and school sorted in reverse chronological time. This is not a resume replacement, which can be found on the about page, but rather a collection of my works that can be referred to in the future.


Dropwizard

Completion: 2015 - now
Technology Used: Java, Jetty, Jersey, Jackson
Source: Github

Core contributor to Dropwizard, a Java framework for developing ops-friendly, high-performance, RESTful web services. I’ve contributed:

  • Significant improvements to client payload validations
  • Hot reload TLS certificates for zero downtime (Let’s Encrypt)
  • Benchmarking configurations for optimal performance
  • Issue triaging, documentation, and blog post writer


boxcars

Completion: Sep 2016 - now
Technology Used: Rust, WebAssembly, nom, python, matplotlib
Source: Github

Rocket League is a video game where player controlled cars compete in a multiplayer arena in a classic game of car soccer. At the end of the game, a replay can be saved, which will store all the player, environment, goal, and network (ie. positioning) information.

At the time, the state of the art parsers consumed more than a couple of seconds to output the binary replay into JSON. I thought this would be a great opportunity to try out the Rust language and the corresponding parser combinator library, nom. While later evolutions dropped nom in favor of the richer contextual messages a hand rolled parser can yield, the result has still been a 1000x speedup when compared to other implementations.

The resulting JSON can be fed through Python and matplotlib to create fun graphs showing statistics across the games.

The goal for 2018 is to create a WebAssembly version by writing minimal glue code for wasm-bindgen and see huge performance gains in the browser.


rrinlog

Completion: Nov 2017 - now
Technology Used: Rust, Elasticsearch, nginx, SQLite, Rocket
Source: Github

rrinlog is my attempt at Replacing Elasticsearch with Rust and SQLite for my nginx access logs, as Elasticsearch is a resource hungry application even at idle. rrinlog’s success has been outstanding, with a 100x reduction in memory, 1000x reduction in CPU usage, and 100x reduction in disk usage.

There are two parts of this project. First one is tailing the nginx access logs, parsing them, and persisting into a SQLite database. The second part is exposing a JSON API for Grafana to query the SQLite database.


collectd-rust-plugin

Completion: Nov 2017 - now
Technology Used: Rust, collectd, ffi
Source: Github

Collectd is a ubiquitous system statistics collection daemon. collectd_plugin leverages Collectd’s ability to dynamically load plugins and creates an ergonomic, yet extremely low cost abstraction API to interface with Collectd.

Features:

  • No unnecessary allocations when submitting / receiving values, logging
  • Register multiple plugin instances
  • Automatic deserialization of plugin configs via Serde (optional) feature
  • Deployment: compile against collectd version and scp to server
  • Referenced Rust libraries are statically linked


OhmGraphite

Completion: Nov 2017 - now
Technology Used: C#, TopShelf, NLog, Graphite, InfluxDB
Source: Github

OhmGraphite takes the hard work of extracting hardware sensors from Open Hardware Monitor (technically LibreHardwareMonitor for most up to date hardware) and exports the data in a graphite (or InfluxdDB) compatible format. OhmGraphite is for those missing any of the following in Grafana or (other time series UI):

  • Breakdown of GPU utilization
  • Fan speed
  • Temperature for hard drives, CPU cores, GPU, Motherboard
  • Voltage readings


Umich DPS (udps)

Completion: Feb - May 2016
Technology Used: React and ecosystem, D3, webpack, nginx, let's encrypt, Google Maps API
Source: Github

Very similar to an earlier project, University of Michigan's Police Incident Reports, this approach takes the API approach where all the data is communicated via JSON and the frontend renders the data. This is the first project where I used React and the surrounding ecosystem.


Pfarah

Completion: Feb 2015 - July 2016
Technology Used: F#, functional programming, recursive descent parsing
Source: Github

Pfarah was initially created because Paradox save files like EU4, change subtly with each version and it is too much work to version the API because the API consists of fifteen hundred properties and a savegame doesn't need to have all the properties so it can be near impossible to know what changed. A DOM parser like Pfarah is flexible enough to fit the bill. I became intimately familiar with monads, learned that functional style must eschewed occasionally for performance, and I even wrote my own F# computation expression!


Farmhash.Sharp

Completion: Winter 2015 and sporadically updated
Technology Used: C#, .NET Core, and hash algorithms
Source: Github

Farmhash.Sharp is an extremely simple, low-level, and blazingly fast library for computing Google's Farmhash algorithm for .NET. Compared to other non-cryptographic hash functions, this library is 2x-10x times faster. This library has allowed me to create a poor man's ascii string interning implementation that is unparalleled and turned out to be significantly faster than even allocating memory for the string


EU4 Stats

Completion: June - Dec 2015
Technology Used: C#, F#, Mono, NancyFx, Razor templating, gulp, javascript, nginx
Source: Github

Europa Universalis 4 is a computer game of immense possibilities where players control and manage a country from the dawn of the Renaissance to the start of the industrial revolution. With managing a country comes lots of data and the game must save this data out whenever the player would like to quit and resume later. This service accepts the savegame through a file upload, making sure to compress it first, and the user waits while the server crunches statistics for a second or two (maxing out a core in the meantime). The result is a unique URL for that specific upload. Due to the amount of data the server receives and has to process special care was taken to rate limit and filter incoming data as to not to overwhelm the server and cause catastrophic failure for all.


UMEC

Completion: Summer of 2014
Technology Used: gulp, pure, and markdown
Source: Github

The University of Michigan's Engineering Council, also known as UMEC, is the student government for the College of Engineering. While elected as Director of Finance, I created a new website with the help from other board members. We moved from Google Sites with many broken links and poor styling to a slick and slim static site with content written in markdown. In the future, I would no longer be part of the council and so the website may drastically change. The version I helped create is here.


University of Michigan's Police Incident Reports

Completion: December 2013
Technology Used: Flask, Javascript, SQLite3, knockoutjs, D3, Google Maps
Source: Github

Due to the Clery Act, all universities are required to publish crime data on campus. Unfortunately, this data is not in an easily digestable format. For the University of Michigan, the data is disclosed on police.umich.edu, which is a plain HTML page of the daily incidents. This is fine for most purposes, but I wanted to build a service where I can query incidents based on location, but also create infographics about when certain crimes happen in the day and throughout the year. Thus, I scraped all available data since 2001, put it in a database, and threw up a front end. Currently, the site is self sustaining, as every midnight, the service scrapes the previous day's data.


Vigenere Cipher

Completion: October 2013
Technology Used: Javascript and knockoutjs

Allows encyption and decryption with a known key using Vigenere's Cipher, but if a key is not known, will give a best guess to what the key is and the cleartext. This project was inspired by a homework assignment in the computer security class taught at the University of Michigan where we implemented a cracker in python.


EECS 381 Style Check

Completion: Development stopped in Septermber 2013
Technology Used: TCL and C++
Source: Github

EECS 381 - Object Oriented and Advanced Programming has a well defined C and C++ style guide. These guidelines were full of good tips, but there were some of them that I feared I would forget. For instance, writing for loops instead of memcpy and implicitly comparing against 0/NULL. Thus, I decided to utilze vera++ to analyze the code I wrote and make sure it conformed with the style guide. In its current state, the C style guideline is mostly implemented. Continuation with this project has not continued because after enough code was written I had the style guide committed to memory. I am also not in the class anymore.


Grunt-reference

Completion: Initial write in Summer 2013. Re-write December 2013
Technology Used: Nodejs
Source: Github

This project grew out of my concern for citing where I found some tidbit of information. I wanted to quote a passage with a footnote that had the source. This program does just that. I quote a passage and then end it with an ISBN and page number. The program goes out and fetches the information about the book and creates a citation. The end result is a pretty slick looking page with this post being a good example. </div>


Pdoxcl2Sharp

Completion: August 2013
Technology Used: C#
Source: Github

In compiler terminology this program is an efficient hybrid of lexical analysis and syntax analysis of game files for games published by Paradox Interactive such as Europa Universalis III and Hearts of Iron III. Internally, the library scans the file, performs basic syntax checking, and passes all tokens of interest to the invoker of the library.