My name is Alexis King, and I write a lot of software. I live in Chicago.
I’m interested in functional programming, static types, and programming language research, and I try to spend as much time as I can writing Haskell and Racket. I mostly work on web applications and infrastructure, but I’m especially passionate about writing libraries, open-source software, and various kinds of tooling.
I write about some of the things I do on this blog, and I sometimes tweet about them and other things on Twitter. I work on a lot of open-source projects on GitHub, and you can email me at firstname.lastname@example.org.
Things I’m good at
Programming languages and DSLs
I have spent a lot of time turning complicated problems into less complicated ones by building languages to solve them, focusing on everything from environment variable management to type-safe unit testing to shell scripts that manage their own dependencies. I work on a programming language called Hackett.
Web applications and APIs
I’ve been working with web tech since long before I started programming professionally, and I know how to design user-friendly applications and strong, stable APIs. I know how to encode many domains into a type system to make the most common bugs impossible, and I can build embedded languages that make things like database queries and templating safe, efficient, and concise.
Libraries and developer tooling
I dedicate most of my free time to developing and maintaining open source software, and I know how to write and document watertight abstractions that can be used and reused. I approach library interfaces from a user experience perspective as well as a technical one.
Teaching and technical writing
Things I like to use
I am deeply familiar with Haskell and its ecosystem, and I know how to do everything from practical type-level programming to metaprogramming with Template Haskell. I am skilled in designing Haskell applications that are testable and easy to change and maintain. I use a specific set of libraries and language extensions to turn GHC into a compile-time assistant that knows so much about my domain that it can write a lot of my code for me.
Recently, I’ve done a lot of work using servant, a Haskell type-level DSL for building REST-y HTTP APIs, which makes implementing complex APIs easy in a composable way. I also maintain four open-source Haskell libraries, text-conversions, monad-mock, monad-persist, and test-fixture, and I’ve contributed to many others.
I work on Racket almost as much as I work with Racket, and I know its state of the art macro system inside and out. I use Racket to build extremely flexible tools that are both easy to extend and easy to understand, and I use its documentation language, Scribble, to write general-purpose technical documentation and specifications.
I maintain too many Racket libraries to list.
Projects I’m working on
The Hackett programming language
Hackett is a very new programming language that combines a Haskell-style type system and Racket’s cutting-edge macro system to form a statically typed Lisp that exposes type information at macroexpansion time. It is based on research by Stephen Chang, Alex Knauth, and Ben Greenman on embedding types and typechecking in a macro system. Hackett is semantically much closer to Haskell than Scheme, but it uses an s-expression-based syntax to enable more powerful syntactic abstractions.
My efforts so far have yielded a working implementation of most of Haskell 98, though it is slow and not especially user-friendly. The implementation involves a fusion of the types-as-macros techniques with a more traditional unification-based typechecker. Hackett is already powerful enough to solve simple programming problems, especially when paired with Racket’s extensive library ecosystem, but there is still much work to be done around improving performance, ease of use, and additional type system features.
Testing strongly-typed monadic effects in Haskell
I am the primary author of the monad-mock and test-fixture Haskell libraries, which aim to assist Haskell developers in flexibly testing effectful code with zero boilerplate and without giving up any static guarantees. These are implemented with a combination of some type-level trickery, a monadic implementation of explicit typeclass dictionary passing, and some Template Haskell utilities for code generation and unnecessary manual maintenance.
The general techniques are described in more detail in this blog post on monad-mock and this blog post on test-fixture. Open problems with these techniques include cleanly testing polymorphic methods and better supporting concurrent programs, but I’m working on that.
racket-tulip and Racket language tooling
I maintain a working prototype of the tulip programming language. While having an implementation of tulip is useful in and of itself, the main purpose of the project is to explore Racket’s language tools in more depth. A handful of libraries have come out of my research, most notably megaparsack, a Parsec-style parser combinator library that is uniquely capable of automatically producing “syntax objects”, which cooperate with Racket’s advanced set of static analysis tools.
Other research in a related space has involved looking into ways to compose syntactic language extensions in safe and predictable ways, making reader syntax as composable and safe as ordinary Racket macros. This work is demonstrated by the curly-fn package, powered by the underlying namespaced-transformer library.
Other things I know about
I like to stay as far away from ops as I possibly can, so (perhaps ironically) I’ve gotten pretty good at understanding how to safely and reliably deploy infrastructure on AWS in a way that won’t ever require me to
ssh into a production box. Most notably, I’m knowledgable in creating software-defined architecture, architecture that can be tracked in version control, reliably replicated as necessary, and composed together to achieve coordination between independent subsystems.