Squick is the evolution of ZAP. While working on ZAP I realised that trying to cram every single thing I might want to do with my website into a general-purpose static site generator is not only too much work, but also no fun at all. There are a few things that I was interested in doing differently (at least from the static site generators I've found) and many things that I was interested in doing exactly the same as everyone else.

Making ZAP flexible enough would require a plugin system, which takes quite a bit of work to get right. Making those plugins means wrangling other people's software (like sass compilers, git, elasticsearch, etc.) which is a pain. So, instead of fighting with other people's software, I decided to build on other people's software, by making a simple node module that renders markdown files with templates in a way that is very easy to integrate into gulp. Squick is the result. The templates are rendered (asynchronously) using dust. This website is now built with Squick, along with the following gulp plugins:

  • gulp-sass: to compile the stylesheets
  • gulp-notify: to pop up desktop notifications when continuous, background builds finish or fail
  • gulp-connect: to provide a livereload-enabled webserver
  • gulp-gh-pages to automate deploying to GitHub pages
  • gulp-indexify: to turn /foo/bar.html into /foo/bar/

Overall, I'm very happy with this new system and the workflow it enables!

BackTalk is a programming language designed to provide simple points of configuration or interaction within a larger piece of software. For instance, it could be used to allow a user to add custom behaviour to a button in a WYSIWYG website editor. You can try out BackTalk right now by going through the interactive BackTalk tutorial.

The syntax is designed to be expressive and also natural. It is also very simple, and can be easily remembered. Variables start with a "$" and function calls look like natural language. Here is an example of a small script you could write and execute with BackTalk:

-- this is a comment
with $color as "orange"
set the background color to $color

A more complicated script could look something like this:

with $all_words as (an empty set)

for each $word in the text:
    with $lowered as (convert $word to lowercase)
    add $lowered to $all_words

show message:
    "there are"
    (length of $all_words)
    "words in the text"

Many of the functions in the samples above would be expected to be written by the BackTalk embedder.

The embedder can write functions that execute asynchronously, create loops, modify and access the surrounding scope, and also run whatever JavaScript behaviours are desired. Any function which returns a Promise will pause the BackTalk VM until the promise is resolved. This is done transparently, allowing for complex async behaviours to appear as simple, synchronous scripts.

with $user_info as (GET "/user/3")
with $posts as (GET (attribute "posts_url" of $user_info))

-- let's say this renders the template using the scope Variables
-- set up in the block below it
render template "posts_index.html":
    with $user as $user_info
    with $posts as $posts

As you can see, BackTalk code sometimes looks a bit lispy. The whole project is still a bit rough around the edges, but it uses a PEG to parse the input, has a real AST, and uses a simple VM to run the code. The whole project is written in TypeScript, Microsoft's static-typed superset of ECMAScript 6, and is well tested.

The Shake Stick is a NIME (New Interface for Musical Expression) implemented in C++ and SuperCollider on a Raspberry Pi B+. This repo contains all of the necessary code and data to run a Shake Stick. This project was produced as part of a directed study with Dr. Abram Hindle at the University of Alberta. You can read a pre-print of the resulting paper on PeerJ.

Cryssake is a simplified C++ build system written in Python. It Understands very basic configurations of C++ executables and libraries. The guiding principle of Cryssake is that by adding structure to the project being built, we can simplify the build system. Unfortunately, C/C++ code tends to have complex requirements from the underlying operating system, available libraries, etc, and structure cannot be enforced in those areas. Ultimately, I determined that this project, though it works well for very simple C++ builds, would need to rapidly grow in complexity to accomodate more complex configurations. At that point I gave up and learned CMake.

Go has a build system that works sort of how I wanted Cryssake to work, but even better. Rust has a similar build system called cargo that is even closer to what I wanted for C++, but also handles packaging/dependencies: nice!

Zap is multiple prototype CMSes that lets you edit locally and deploy your site using git. The guiding principle of ZAP is to keep your content in git. The rest is still being explored. Currently, ZAP is still being prototyped, with two branches that you might find interesting:


This is a fairly complete CMS that provides an in-browser editor powered by AngularJS. Content is stored in your file-system and you are expected to manage it via git. Editing is done locally and a copy of ZAP must also be running on your server in read-only mode to provide search, rendering etc. This version also has fairly good test coverage.

Ultimately, this became overly complicated and unwieldy, with an annoying dependence on Elasticsearch (this was needed even while editing your site offline).


A rewrite that includes some of the lessons I have learned from the master branch. Currently implemented as a static site generator, it reads files from your project folder and assembles the website as you wish. Extra features such as SASS/LESS compilation, GUI editor, search are not implemented and likely will never be. This removes complexity from ZAP and lets tools that are good at those things (Makefiles, gulp.js, your text editor, etc.) handle those parts. Features:

  • very nice error messages for the user
  • explicit over implicit
  • specifically designed to make it easy to host your website through github-pages.

Haiku is a new open-source operating system that specifically targets personal computing. Inspired by the BeOS, Haiku is fast, simple to use, easy to learn and yet very powerful.

This is not a project that I started, nor am I the biggest contributor. Far from it. GitHub can show you my commits if you are interested. However, I did do quite a bit of work on Haiku. All programming was in C++, and I worked on:

  • the interface layout API (grids, groups, alignments, that sort of thing)
  • refactoring many built-in applications to use that API
  • updating a linear programming-based layout manager to a newer version of the layout API
  • documenting the layout API and fixing bugs

At this point, I no longer work on Haiku, but it was a great experience. I not only learned quite a bit about C++, but this was the period of time when I first became interested in Software Engineering (as opposed to simply computer programming), design patterns, maintainability, etc.. I also formed a good understanding of how open source can work, and had some very cool doors opened for me, such as going to New Zealand on a scholarship to work on Haiku there.

Socrates and Aristotle Are Fighting Again is computer-generated novel I produced for NaNoGenMo 2015 (that's National Novel Generation Month).

The code I wrote to generate the novel is available on GitHub, and includes a write-up of the techniques I used. In short, I used web-scraping to make a corpus of philosophical text, then used a Markov model to generate text from it. In an attempt to make something that resembles conversation and a Socratic text (with the Aristotle learning from Socrates), I added some twists onto this classic technique. The results range from confusing and boring to confusing but funny.

You can read "Socrates and Aristotle Are Fighting Again" online right now!

some pixely green and blue audible jelly

Sounds of Jelly is a relaxing jelly simulator with wave noises. It uses three.js for graphics and WebAudio to synthesize audio in your browser!

some colourful blocks

I once decided to do an exercise from a game design textbook. The exercise was to design a simple game around a territory capturing mechanic. Instead of just completing the exercise, I decided to make it possible for people to make and share games that used the same type of board/moves. Finally, the resulting game editor/player is ready to share! I think this could maybe be a good tool for people to experiment with game design.

I would really love it if you would try this out and make some games. I would love it even more if you would share those games with me!

two white circles and a green circle

I made this game for the 2013 js13k contest, which had a theme of bad luck that year. Originally, I was inspired to make a game about bad luck and failure. I had a vague idea of making a point in this game, so I tried to do that by forcing people to give up. The game encourages you to keep going with little text snippets, but then at some point you cannot progress any further. I'm not really sure anymore that this fits with 'bad luck', but I thought so at the time.

Many players had a reactions of anger and/or confusion. One thing that added to the confusion was that each level introduced something new. When the final, unbeatable level arrives, it can appear that the player is simply missing some new mechanic.

A design goal I had in this game was to have minimal to no instructions. Overall, I think this worked out pretty well, as the players I observed seemed to discover the simple controls and mechanics fairly quickly with a bit of experimentation. I think the complete lack of information contributed to the annoying effect of the eventual impossibility of the game.

Although I'm happy with the mechanics and visual aesthetics of the game, I feel that it really tries too hard to mean something.

Spincycle logo: basically, the word spincycle

A long time ago, as BlackBerry prepared to launch their foray into the tablet market, they announced a promotion for developers: make a PlayBook app, get a PlayBook. One of the technologies you could use to make the app was HTML5, which, at the time, was still somewhat new. I decided this was the perfect time for me to get my feet wet with web-based game development, and so I started planning and making this game.

The game is sort of fun, it's kind of like a more boring version of Super Hexagon (although I had the idea before Super Hexagon was released, and I didn't ever play its predecessor, Hexagon). I learned much more about web design/technologies making this game than I did about game design. The game part stayed fairly static from an early point, but the UI/UX/implementation went through several major revisions. Finally, it has landed on something I'm pretty happy with and ready to share.

This repo houses a few simple experiments in controlling the Raspberry Pi GPIO using C++. Maybe it will be helpful to someone else trying to do the same thing!

Written in 1 hour, this repo provides an example of HTML5, CSS, and REST usage. This simple application written with AngularJS monitors the issues on its own GitHub repo via the GitHub JSON API.