- Arch Linux
- My projects
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.
Rust is a systems programming language from Mozilla with a heavy community focus.
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.
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.
The Rust guidelines are Mozilla’s official
[c]onventions, principles, patterns, and best practices for Rust code.
bors is Mozilla’s buildbot for Rust.
- 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.
Ranger is a text-based file manager.
- Fixed a crash in previews of non-previewable files.
- 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 is a Python data analysis library.
Tabview is a CSV viewer written in Python with Vim-like keybindings.
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.
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.
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 conceptssection. For these things to be useful, the language had to be exact, providing a quick overview of what exactly these words like
- Now the 8th link on Google for
iptables, just below Debian’s much more spartan competition.
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.
- Maintainer for AUR package (Arch Linux)
See About this site.
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.
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.
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.
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.
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.
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.
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 datastandard) 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.
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.
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.
- Added a section on color in mathematics.
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.