Programming

My first experience programming was back in college, when I was a pure and applied math student, learning Mathematica and LaTeX for visualizations and typesetting, as well as mathematical computations and modelling.

After graduating and working in industry, as a data scientist before that was really a term ("Staff Mathematician & Lab Technician"?), I started getting into Ruby for building web applications, and GUIs with Shoes (how I loved class Creation < Shoes::App).

Later, I decided to focus on software, and so began consulting, building out websites and web applications for various companies and governmental departments.

Eventually, I got tired of building web applications, and wanted to be getting into more mathematically interesting work, and magically happened upon a job posting to work with Erick Matsen in the Computational Biology Department of Fred Hutch Cancer Research Center. This led to a bunch of fascinating biology research, not to mention Python and R code along the way.

During my time at "the Hutch", I began working on a project with some friends (Colin Megill and Michael Bjorkegren) to see if we could use voting and machine learning to make sense of large scale conversations and feedback. This led to the creation of https://github.com/pol-is.

My experience with Clojure working on the math engine behind Polis made me a functional, declarative, data-driven programming convert. Consequently, I've become an active member of the Clojure community, maintaining a number of open source libraries, and have been fortunate to do some Clojure consulting for a number of companies. I've also got a few talks about my work with Clojure which you might want to take a look at.

Lately, I've been spending a lot of time working with data visualizations, and have finally found an ecosystem with (nearly) everything I would want in terms of visualization needs: Vega-Lite & Vega. On multiple projects now, both in Clojure and vanilla JavaScript, these tools have proven their worth many fold over, and I have become a staunch advocate for their approach to data visualization.

Projects of interest:

For a complete list of everything public/OS, please visit my github page. Below are some select highlights:

Polis

I built and maintain the code powering Polis, a participatory democracy tool featured as a core part of the vTaiwan participatory democracy process. In rough order of contribution:

• polisMath: I was lead developer of the math code behind Polis, having designed the core algorithms powering the tool.
• polisServer: The core node server which handles requests.
• polisReport: Advanced analytics dashboard.
• polisClientAdmin: Administrative client code.
• polisClientParticipation: Commenting, voting, and participant visualization code; The entire participation experience.

Clojure data science work

As a member of the budding Clojure data science community, I build tools which try to fill gaps in our toolkit and aim to make Clojure a first class language for data science.

• Oz: Data visualization and scientific document swizz army knife for Clojure, based on Vega & Vega-Lite; features dynamic interactive data visualizations, static site generation, and publishing capabilities.
• semantic-csv: A CSV parsing library for Clojure which adds some nice higher level features for working with tabular data.
• clojure-datascience: Compilation site of resources for data science in Clojure.

Datsys

I've been working on a set of tools for making full stack Clojure + ClojureScript applications using Datomic and DataScript as a data model. The most interesting pieces of this as of this writing:

• Datsync: Datomic <-> DataScript syncing utilities.
• Datview: A customizable/extensible set of utilities for building interactive views out of such data. (Be warned; this is currently in flux).
• Datsys: The umbrella project for the above, in the form of a simple example application with these things hooked up together.
• Posh: Consulted with @mpdairy in the design of Posh, and contributed miscellaneous features and community support.

Computational biology

Working with Erick Matsen at Fred Hutch in the Computational Biology department, I built a number of reusable analysis tools:

• CFT: Computational pipeline for processing deep sequenced B-cell receptor data.
• Olmsted: Data exploration/visualization tool fed by cft (above) for analyzing the adaptive immune system.
• Hyperfreq: The tool I developed for analysis of APOBEC hypermutation, a specific host defense mechanism against HIV and related viruses.
• Tripl: An attempt at capturing some of the core expressiveness of Datomic and DataScript as a relatively small Python package.

Internet of "things"

Where things are sometimes chickens! The fruit of my time doing device programming:

• clj-bots (WIP): A set of tools for working with Clojure for device programming, such as the BeagleBone Black, Raspberry Pi and (hopefully) eventually the Arduino via the Firmata protocol.

Misc contributions

• lein-clique: Contributed to a tool for analysis of clojure function dependencies.
• markdown-clj: Added yaml metadata processing.
• Help maintain cljsjs bindings for vega, vega-lite, vega-embed and vega-tooltip.