About me

I’m Anthony. I spend most of my time doing something related to programming, bodybuilding, or gaming. I graduated from the University of Maine in 2013 with a B.S. in Computer Science and I’ve been on various team’s inside of Amazon since then. My personal programming interests include front end development, functional programming, and programming languages. I really enjoy writing language parsers and I’m sure at some point I’m going end up making a language or two as a side project.

Professionally, I like modern front end development. Everything from mainstream React/Redux to (my preferred) compile to JavaScript languages like Elm and TypeScript. I was thrown into a lead position on the front end without knowing anything when I first started at Amazon in Display Advertising where I learned that good front end developers are very hard to come by. I really like being good at things that few people enjoy doing, which might help explain Bodybuilding as well.

I’ve competed in two shows so far. The first one wasn’t great but the second one went really well. I’ve been Bodybuilding in one way or another since I was 14 and I plan on competing again in the future. I also enjoy most Blizzard games. I started playing World of Warcraft a decade ago and I still play at least a little during each expansion. Mainly playing Overwatch these days.

Here is all of the stuff that I would imagine people might want to know if they’ve found themselves on this page.

Professional stuff

Probably best to see my resume or my LinkedIn.

I’m an expert in front end development. I have experience with many of the major front end libraries (React, Redux, Angular, etc), modern front end build systems (Webpack, Gulp, Grunt, etc.) and alternative tools and languages (ClojureScript, Elm, TypeScript, etc.). I have never been confined to the front end. I usually work along the entire stack, from the browser up to the servers/services, all the way back to DynamoDB in AWS. I feel confident leading efforts that sound similar to that. Most of the time I’m using Java and JavaScript but I consider myself a programming language polyglot. I can pick up new languages fast and enjoy it.

I’m most interested in using functional programming languages like Clojure and Haskell. These have been passion projects for me so I don’t have any professional experience but I’m confident that I could get up to speed quickly with a good group of developers. I take ideas from these languages all the time so I would love the opportunity to just use them for a change.

Online stuff

Some relevant social media/online profiles.

Programming stuff

These are the things that I’ve enjoyed doing the most recently. I’ll give a summary of each, some reason that I found it interesting, and a snippet that captures the spirit of the project.


Functional, infinite streams of data in Elm that won’t overflow the stack.

    actual =
        Stream.value "a"
            |> Stream.zip (Stream.range 1 5 1)
            |> Stream.toList

    expected =
        [ ( 1, "a" ), ( 2, "a" ), ( 3, "a" ), ( 4, "a" ), ( 5, "a" ) ]
    Expect.equalLists expected actual

I started this while playing around with some Project Euler problems using Elm. I had also just seen a YouTube talk on a JVM Haskell called Frege where the author of the language talks about using functional programming and streams to solve Fizz Buzz so I wanted to use the popular Elm lazy-list. Pretty fast I started running into stack overflows using lazy collections. I ended up attempting to fix the issue with a pull request only to conclude that it would take a pretty big rearchitecture. I decided to just write this instead with the goal of enabling Elm to use tail call optimization. It was definitely tricky to implement but it worked out well. I like it and at least a few people have gotten some use out of it.

Git Bulk

Perform operations on git repositories in bulk.

$ git bulk status
git-js [master ➜ origin/master ▲ 1]

vim-visual-page-percent [HEAD ➜ ]

onion-oled [master ➜ origin/master ▼ 2]
 M main.js

It has an optional JavaScript configuration file named .gitbulkconfig that look like this.

module.exports = {
    "repositories": [
            "path": "./git-js",
            "group": "js"
            "name": "onion-oled",
            "path": "./onion-oled-js",
            "group": "js"

I started this project because I really needed it. I’ve been on team that have a lot of code and its usually split into small repositories. After one day I just had enough with cd and decided to make this. Its a crucial part of my workflow now on all multi-package projects that I do, in or out of work. You can use it too with npm install -g git-bulk.

Quick Cache

A simple, least recently used (LRU) cache in Elm with O(1) get, put and remove operations.

myCache =
    Cache.newCache 3
        |> Cache.put "a" 1
        |> Cache.put "b" 2
        |> Cache.put "c" 3
        |> Cache.put "d" 4

Cache.get "a" => (newCacheState, Nothing)
Cache.get "b" => (newCacheState, Just 2)
Cache.get "c" => (newCacheState, Just 3)
Cache.get "d" => (newCacheState, Just 4)

I was brushing up on some esoteric computer science for an interview and came across this LRU cache question. My naive attempt was to use a heap as the cache structure, but that would have yielded O(logn) insertions. My second approach was to use a linked list and a map, pulling the linked list node to the front every time its accessed and getting a O(1) reference to it through the map. I implemented it in Java and it worked but it was pretty gross. I reimplemented it in Elm with immutable data structures and quickly found that I couldn’t use my linked list mutation implementation. Instead, I implemented the linked list with a Map<string, Node> where Node is a record that contains a previous, next, and value. Saving a reference to head and tail of the linked list makes for a pretty complete implementation for the purposes of this problem. This was useful because I can’t change the previous or next values of the Node, but I can insert new entries in a map. I think it performs better than the other options available in Elm right now.


Utility to help in automating the installation of packages on fresh systems. It is based around a simple Domain Specific Language (DSL) written in PegJS that lets you specify what you need on your computer, and when and how to put it there. This is a sample configuration.

# These lines say that they only apply if the current operating system is ubuntu.
# This is the primitive statement in sysc that others build on. It says how to
# install, uninstall, and test for install status. Here, brew is being installed.
cmd({"os": "ubuntu"}) brew: install -- echo | ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Linuxbrew/install/master/install)"
cmd({"os": "ubuntu"}) brew: uninstall -- sudo rm -f $(which brew)
cmd({"os": "ubuntu"}) brew: isInstalled -- which brew

# This is a convenience around installing brew packages
brew toilet: toilet

# Same with git. This will clone from the first argument to the second arguments location
git oh-my-zsh: https://github.com/robbyrussell/oh-my-zsh.git ~/.oh-my-zsh

# And same with apt for debian distributions.
apt({"os":"ubuntu"}) essentials: git vim vim-gnome zsh mosh

# And for symlinks
symlink vimrc: ~/linux-dotfiles/files/.vimrc ~/.vimrc

And this is sample output using that configuration file. You can actually clone the repository and run this.

$ node ./lib/cli/systemconf.js install ./sample.sysc
Parsing ./sample.sysc...
Seeing which scripts are already installed...
All known schemas:

These are already installed:

These encountered errors while parsing the config file and will not be installed:
        ⤷ Couldn't parse a line in the config file: "iiii"
        ⤷ Wrong args supplied to a git config line for foobar. Each line should have included two args. Got https://no.second.arg.com
        ⤷ Target of the symlink doesn't exist: ~/linux-dotfiles/files/.toprcf

These will be installed with the following commands:
        ⤷  echo | ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Linuxbrew/install/master/install)"
        ⤷ brew install toilet
        ⤷ sudo apt-get install -y yubikey-neo-manager yubikey-personalization libpam-yubico
        ⤷ ln -fs ~/linux-dotfiles/files/.zshrc_ubuntu ~/.zshrc_platform

proceed? [y/N]:

I got into computer science through Linux and I’ve been a bit of a distro-hopper ever since. Reinstalling my OS constantly meant that I had to reinstall all of my software as well, and a lot of it wasn’t on the distribution repositories. I made a version of this that was essentially a big Makefile. That worked for a while but it was too easy for errors to leave my system in an awkward state that rerunning the script wouldn’t fix. I tried to rewrite it in Haskell as an excuse to use Haskell and learned a lot about IO. That implementation forced me to quarantine my side effects to a small portion of the program. Side effects here are installing software, testing if software is installed and reporting to the user. I ended up dropping Haskell for this project in part because of the tooling but also because I really want people to npm install my software. Systemconf is now written in TypeScript. Its mostly the same logic with a bit less rigor. You can run it and it won’t actually do anything but you’ll be able to see ahead of time exactly what happens. You also get a wrap-up summary where it confirms what went right and what went wrong.

Clojure Elm Parser

A Clojure and ClojureScript parser for Elm written in Instaparse.

(deftest test-function-call
  (let [input "Just \"string\""
        actual (parser/parser input :start :function_call)
        parses (insta/parses parser/parser input :start :function_call)
        parse-count (count parses)
        expected [:function_call
                  [:function_name [:Name "Just"]]
                  [:arguments [:expression [:value [:string "string"]]]]]]
    (is (= expected actual))
(is (= parse-count 1))))

This was really fun. I’ve always loved programming languages. My mentor in college showed me Lex/Yac (and their derivatives) and I’ve been making little DSLs ever since. I started this project because I wanted to improve Elm tooling for Vim. I also wanted an excuse to use Clojure and Instaparse seemed like the go-to parsing library. Instaparse is pretty amazing. This was by far the quickest I’ve written a grammar for a language. I was able to focus entirely on the grammar instead of making stupid little helper classes and fighting with the lexer like I was used in with JFlex and Cup from my previous GraphQL parsing attempt. Instaparse outputs data from a parse, which was also new to me. I had a function that took in a string and gave me an AST without me having to do anything. Clojure also has a ton of useful stuff for manipulating data once you have it so this ended up being a really good introduction project. You can see the grammar here.

Bodybuilding stuff

Northwest Championships, 2016. 1st overall Open Men’s Classic Physique, 2nd place Open Men’s Light Heavyweight

This was my second show. Taking what I learned from the first show I was able to move up to second in Bodybuilding and first overall in Classic Physique. Classic Physique is an interesting division that caps your weight based on your height. I was only allowed to weigh 185lbs for this show and I came in at exactly 185lbs. These are the videos from the show if you're interested, and here are the photos.

Emerald Cup, 2014. 11th place Open Men’s Light Heavyweight Bodybuilding

This was my first show. It probably was a bad idea to compete in such a high caliber amateur show for my first attempt. I didn't do well, but I learned a lot.