About me

My name is Alexis King, and I write a lot of software. I currently 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 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 lexi.lambda@gmail.com.

Things I’ve worked on

This list is just a smattering of the cooler things I’ve worked on over the past few years. It is neither exhaustive nor particularly scientific in its curation.

2021 Reimplemented this blog on top of Scribble, replacing frog. Released megaparsack v1.5, adding support for user-defined parser state and parser lookahead.

2020 Published “Macros for DSLs” with Michael Ballantyne and Matthias Felleisen at OOPSLA. Presented “Effects for Less” at ZuriHac 2020 on the design of eff and its accompanying GHC proposal to add delimited continuations to the RTS. Led a large-scale refactoring effort to statically rule out several classes of bugs in graphql-engine. Opened a GHC proposal for improving arrow notation. Started contributing to GHC, including some performance fixes and improvements to arrow notation.

2019 Published “Does blame shifting work?” with Lukas Lazarek, Samanvitha Sundar, Robby Findler, and Christos Dimoulas at POPL. Released monad-validate based on work done for Hasura. Started working at Hasura.

2018 Presented “Hackett: a metaprogrammable Haskell” at Curry On, and again a few months later at Strange Loop. Started working on contract systems with Christos Dimoulas at Northwestern University.

2017 Released the freer-simple package. Presented “Hackett, a Haskell for Racketeers” at RacketCon. Started working on Hackett, a Haskell-like language embedded in Racket.

2016 Started learning about type systems to explore ideas inspired by Turnstile. Presented “Languages in an Afternoon” at RacketCon. Released the megaparsack and scripty Racket libraries. Started writing Haskell professionally for the first time.

About this blog

This blog is powered by Scribble, an unusually flexible document preparation system written in Racket. Unlike most markup languages, every Scribble document is a program that evaluates to a document, which can then be rendered using one of a number of different backends. Scribble provides a TeX-like notation for writing such programs, but unlike TeX—which is essentially an overgrown macro preprocessor—Scribble is a full-fledged functional programming language. In fact, the Scribble syntax is really just an alternate notation for Racket itself, so all the libraries and abstractions available in Racket can be used more or less directly in a Scribble document.

This makes Scribble a remarkably powerful tool for writing prose documents, and indeed, it serves as the foundation for Racket’s best-in-class documentation system, among other things. Using it to power a blog is perhaps a bit overkill, but it gives me the wonderful ability to define whatever abstractions I desire to make blogging as effortless as possible. For example, after finding myself linking to Hackage packages quite frequently, I decided to define a one-line function:

(define (hackage-package package-name)
  (hyperlink (string-append "https://hackage.haskell.org/package/" package-name) package-name))

Now all I have to do is write @hackage-package{lens} and I get lens. Sure, it’s not exactly mind-blowing, but it’s certainly convenient… and of course, the most significant advantages involve abstractions too elaborate to describe here.

This site is, naturally, open source, so if you’d like to see how all the pieces fit together for yourself, feel free to clone the GitHub repository. And if you’re interested in a simple example of what Scribble looks like to use, you might as well take a peek at the source code for this page in particular.