My first fad post on DEV.
A checkbook/envelope budget app for Android.
My second Android app. My first one has code so terrible I was too embarrassed to share, and now even if I wanted to share it I don't know where it is.
It's also the Android app of mine that I still regularly use. I just never added anything more to it because it does what I want, it does what a bunch of other people want, and because this was before I converted to the religion of unit testing, I'm afraid to add new features.
There are known bugs in it, mostly because I thought I was being clever by running database changes in a background thread, and if you leave a screen quickly enough, it'll crash.
What I learned: ongoing maintenance needs tests.
Make a Discourse user's posts invisible to everybody but themself.
My first and last attempt at a Discourse plugin. It uses... a lot of undocumented interfaces to pull it off, and since I'm not using it anywhere, haven't bothered trying to maintain it. I might end up dusting it off if I need it, though.
What I learned: this was my first sustained attempt to write Ruby code.
A comparison sort (specifically, IntroSort) for Rust.
Written because Servo was using a naïve quicksort algorithm in its graphics system that blew up on already-sorted input. It was fun trying to make it faster, having the benchmark tell me it was actually slower, and going back to try again. Ended up being beaten by a better algorithm by someone else.
What I learned: completely rethought algorithms aside, it's hard to beat your typical implementation.
An abandoned implementation of Content-Security-Policy parsing and checking.
I got way too fancy with the algorithm, got burnt out, and will probably rewrite it just by doing what the spec says to do the way the spec says to do it. Eventually.
What I learned: completely rethought algorithms are hard.
Query the GitHub API for the recent activity of a GitHub app.
I actually still use this, and run it regularly as a way to check what a github bot is doing. It could be nicer, but it's not worth it for something I run, like, a few times as week.
What I learned: the GitHub API
Automatically maintain a repository of code that always passes all the tests.
My first attempt at a GitHub mergebot, written in Rust because it was intended as a replacement for a bot that's primarily used by the Rust compiler. When tokio came out, it was pretty obvious that it would form the basis of all the good Rust web server stuff, but it was announced after I had already started without it, and it wasn't stable yet, so I would've ended up having to rewrite it, then turn around and port it to whatever breaking changes came later... and switch to the new GitHub Apps API... screw it, let's use Elixir, which already has a decent web/async framework, instead.
What I learned: being on the bleeding edge hurts
Rust bindings to LiReSSL's native API.
Abandoned because libtls is build around file descriptors, native-tls is build around the
Read trait, and I can't bridge them without using a pipe, which would double the number of syscalls needed.
What I learned: don't build language bindings around already-high-level APIs, even if they're C APIs.
An Android launcher that does nothing.
It was design for people who want to specifically use something like Wave Launcher to interact with their Android phones. And I guess it's still useful for that, though I'm not using or doing anything with it myself. My third Android app.
What I learned: the basics of writing an Android launcher