Worklog

Contents

These are my efforts to make the world better.

The point of this is to keep some sort of record of the things that I’ve helped out with online, and organizations I participate in, so that I can reference them later and don’t forget about my efforts.

MongoDB

Rust

Rust is a systems programming language from Mozilla with a heavy community focus.

Rust class

I took David Evans’ operating systems class in Spring 2014 as an open student, part of his project letting anyone worldwide register. Informally, I think I was the only open student to actually finish all of the projects. I collaborated on the last three remotely on teams with UVa students - who were actually taking the course for credit, and graded on the projects. I was on Google Hangouts in one of the presentations for the final projects at the end, but didn’t get the chance to talk (I’m not bothered).

Overall it was a wild experience. From using a completely new language to me, to doing systems and kernel programming for the first time, it’s really one of the most positive experiences I’ve had programming.

Projects

Team projects are labeled explicitly. Others were completed solely by me.

  • ps0: getting familiar with Rust.
  • ps1: really simple webserver.
  • ps2: writing a shell.
  • ps3 (currently private): parallelized webserver (team project).
  • ps4: hacking ironkernel (team project).
  • final project: Raft in Rust (team project). Incomplete.

It’s worth noting that all of these were written to a very old version of rust (0.7 or so, slightly later for the more recent ones). Rust has changed very significantly since then; none of them even still compile.

rust-lang/rust

The Rust reference implementation.

Guidelines

The Rust guidelines are Mozilla’s official [c]onventions, principles, patterns, and best practices for Rust code.

quickcheck

BurntSushi’s quickcheck is a QuickCheck implementation for Rust.

bors

bors is Mozilla’s buildbot for Rust.

rust-nightly-archlinux

A rust-nightly-archlinux is a PKGBUILD generator for Arch Linux.

  • use argparse to parse cli arguments. Somewhat daft, but I improved the CLI interface for this script, since I use it sometimes and seeing manual argument parsing in Python bothers me.

rust-url

Python

Ranger

Ranger is a text-based file manager.

python-mode

python-mode is a major mode for Emacs.

  • Bug report regarding virtualenv, with some code for a potential workaround. My code got improved by one of the contributors, and a real workaround is supplied further down.

Pandas

Pandas is a Python data analysis library.

tabview

Tabview is a CSV viewer written in Python with Vim-like keybindings.

global-pygments plugin

python-iwlib

iwlib is an interface to wireless tools for Linux. python-iwlib is Python bindings to that interface, so you don’t have to use C for everything.

fuzzywuzzy

Haskell

sandbox-move

Arch Linux

I make a lot of wiki contributions for Arch. Still, if I mention a page here, it’s not to say I singlehandedly wrote this - wiki pages are community efforts, and no one person gets credit for them.

There were some cases where I made significant contributions to pages, and watched them grow into awesome resources where others could take over. One of the dynamics you see on wikis is that people don’t help out with the stub pages, since they don’t visit them without useful information. Having good information on a page attracts visitors, however, which in turn garners contributions from people who otherwise would never help out.

Security

I did a big overhaul of the Arch Wiki page on security in June–August 2013.

  • The whole thing used to just be links, or lists of links to other pages. I rewrote nearly every section, did tons of research on Linux security (RHEL best practices, research papers on mandatory access control, etc.) and shaped it into an actual pleasant overview of security.

iptables

I rewrote the then-dwindling ArchWiki page for iptables.

  • Wrote an actual tutorial. This was the one thing the page desperately needed - a no-frills walkthrough on how to use it. It’s still my #1 reference when I need to hack at some rules, and I only read things like this crazy in-depth guide if I really have to.
  • I spent a lot of time poring over the verbage in the basic concepts section. For these things to be useful, the language had to be exact, providing a quick overview of what exactly these words like chains, tables, and rules meant.
  • Now the 8th link on Google for iptables, just below Debian’s much more spartan competition.

Packages

Occasionally, I find a package isn’t available in either the Arch standard repositories or the AUR. When this is the case, I package it rather than just installing it directly (perhaps from the Makefile). This helps my system stay clean, and it saves time for anyone who repeats the work after me.

global-pygments plugin

stmd-git

My projects

This website

See About this site.

CNULUG

Summer 2013 - present. Website.

I founded the Linux user group at CNU. It’s still getting on its feet, but I run the mailing lists and do a static site for it. We had weekly meetings all through Spring 2014.

Dotfiles

Fall 2012. GitHub.

One of the cool things Linux users do is they post their user-level configuration files on the internet for other people to grab. We often have useful scripts, vim configurations, and creative ways of setting our environment variables tucked away in our dotfiles for nobody to see. Now, with sites like GitHub, you can search the vast repositories of user configuration for just the settings you need.

I post mine, too. There’s a short writeup with some extra photos about my most recent configuration over at Imgur.

Math notebook

Spring 2011. Webpage. GitHub.

Once college-level integral calculus hit me I started searching for a better solution to managing my notes. One of the nice things about computerized documents is that you can search them, but math always seemed out of that domain. LaTeX turned out to be the solution to that problem - I started learning it early into my second semester of college, and ended up writing over 200 pages of notes. Some on discrete math, some on calculus, and a little bit of random tidbits thrown in there. It covers more than just that one class, but the bulk of describes tricky integration, sequences, and series - standard Calc II material.

It’s something I’m really proud of, and I still reference them whenever I need a bit of that math knowledge.

The experience as a whole gave me the chance to explore mathematics a little deeper, and to gain some grasp on technical writing. I haven’t feared any technical writing projects since then, and I gained an awesome new skill (technical typesetting) for any time I’ve had to write papers.

SmartsGarden Visualizer

Spring 2011. GitHub.

I joined a capstone project to build generative music and artwork from network data. It was a team project with two others (although we each built specialized components) and my first serious effort using Git.

I made the music visualizer. Even though it was generated from music, and not visualizing live network data, the results had to look like they were coming from a network. I experimented with creating nodes onscreen and drawing them like network graphs, then got them working in resposne to thresholds from a FFT of the audio.

We won CNU’s information systems capstone competition that year. The result was visually impressive, and the others had produced good music from their traffic analysis. My code is written in Processing, a sort of Java-lite for the computer graphics and artwork community. As far as I know, only the visualizer component is open-source.

ZombieRL

2011. GitHub.

As a senior in high school I got the chance to take my fourth and final computer science class as effectively an independent study. It was taught in C++, but I blew through the course material and started exploring other languages and projects to work on. I did the first couple chapters of SICP, which I have yet to get back to, and picked up Python in my free time.

The culmination of all this effort was a zombie-themed roguelike in Python. It uses The Doryen Library to draw graphics to the screen. After working on it for a while I ported it to Python 3, but it hasn’t seen much activity since then.

This was my first real intro to ideas like blitting graphics to a screen or having a main loop that had to respond to user input. It was also probably my first project where version control would have helped me; unfortunately I didn’t discover Git until college.

MGMT

2010. GitHub.

I took IB Computer Science as a Junior in high school. This was my dossier, a massive final project that makes up half of the curriculum.

It managed customer contacts, but only had a CLI interface. The real beauty of the project was that - unlike most pedagogical software projects - it forced you to go through a sort of software engineering life cycle that lasted more than a week or two. I had to make diagrams, describe the class interfaces and the way the objects interacted, and all that fun stuff before I could even get started coding.

Other

NASA

I worked at NASA from September 2013 to May 2015. My big project has been standardizing this huge volume of data files, where a team and I have built an expert system that uses fuzzy matching against our knowledgebase to standardize (meta)data.

From my Reddit post:

Data scientists call this process data wrangling, and my job is making it automatic.

This means writing parsers for things that no sane person would write parsers for (a human-writable data standard) and automatically sanitizing/cleaning that input data so normal people can actually write parsers for data that’s in the standard format. Then I apply machine learning techniques to (fuzzy) match the metadata for those files to a database of known metadata, thereby automatically standardizing things like variable naming, descriptions, and notation used to write their units.

I have yet to receive my undergrad degree in computer engineering. The main skills involved in my work are

  • a deep understanding of Python (my main language),
  • knowledge of parsers (compilers can teach you about this),
  • fuzzy matching algorithms.
  • Hopefully will get GPL’d someday. I’ve been pushing for this, but it’s not really in my control.
  • We have a short conference paper in ICAI discussing the work.

Git talk

I gave an hour-long brown bag talk about Git for one of NASA’s departments (though some outsiders stumbled in as well). It was accompanied by a live demo with some branching/rebasing bits. You can find the slides over here.

We’re building momentum and there’s now plans for some teams to start migrating projects away from Subversion.

nasa/NTL-Lunar-Mapping-and-Modeling-Portal

Large Scale Development Culture Change: Google and the US Government

I was a slide reviewer for Mike Bland’s talk on fostering healthy developer culture.

LaTeX WikiBook

CNU UAV Lab

I volunteer hosting the mailing lists for CNU’s unmanned aerial vehicle lab.

CNU Math HPC project

CNU’s math department is getting their feet wet with high-performance computing. I volunteer as the sysadmin for their server, a ProLiant SL250s Gen8. Mostly this means I installed RHEL on it, found drivers for the Tesla GPU, and configured a dev environment for CUDA and whatnot.

I’ll hopefully be doing more wrt coding on it soon; my scratchpad is on GitHub.


  1. I got credited in the pandas 0.15.0 release notes for this little fix. Yay!

  2. Authors of the first Displaylink linux drivers, I think.