software is fun

Gleam is Pragmatic

Sat, 05 Oct 2024 00:00:00 +0000

I’ve spent the past several years working with functional programming languages in my free time – primarily Haskell and OCaml. I love both languages but also find aspects of each frustrating.

Haskell is terse and elegant with type classes providing a powerful mechanism for ad-hoc polymorphism. However, it can also be confusingly implicit and I personally find lazy evaluation to have more downsides than upsides.

OCaml is explicit and powerful with a best-in-class module system. However, I believe it is often exhaustingly explicit, especially when dealing with custom data types in generic containers.

Hello World Haskell

Fri, 16 Sep 2022 00:00:00 +0000

Teacher: Hello class! Welcome to your first day of functional programming. Today, we’re going to be talking about how to write the classic “Hello, World!” program in Haskell. It’ll be slightly more involved as we’ll ask for the user’s name and then greet them. I’m sure many of you have heard scary things about Haskell, but I promise you it’ll be fun.

Student: I heard we have to learn about IO. That sounds scary!

Easy JSON in Haskell

Mon, 12 Sep 2022 00:00:00 +0000

So you’ve learned some basic Haskell and you’re feeling really good about yourself. You sit down the write some code and you’re presented with a deeply nested JSON structure:

{
  "foo": "Hello",
  "bar": 1,
  "baz": "More stuff",
  "people": [
    {
      "name": "Drew",
      "hobbies": [
        { "name": "bridge" },
        { "name": "haskell" }
      ]
    },
    {
      "name": "Jane",
      "hobbies": [
        { "name": "chess" },
        { "name": "ocaml" }
      ]
    }
  ]
}

Your goal is to simply find the name of Drew’s first hobby. LET’S WRITE SOME TYPES!

Parsing Permutations

Thu, 18 Nov 2021 00:00:00 +0000

My favorite game is bridge. It’s an excellent test of cooperation and strategy. I’m in a discord chat devoted mostly to the game and folks often share interesting bridge hands with one another. I decided it would be fun to build a program that parsed a simply-formatted bridge hand and produced a plain text bridge diagram.

Here’s a defensive problem that Sir Hugo Drax faced at Blades, defending a contract of 7♣xx.

$ bridge-cli-exe <<< 't987 6543 - 76532 > akqj akqj ak kj9, r/r, imps, s6'
Vul: R/R   ♠T987
IMPs       ♥6543
           ♦
           ♣76532
Lead: ♠6    -----     ♠AKQJ
           |  N  |    ♥AKQJ
           |    E|    ♦AK
           |     |    ♣KJ9
            -----

I’d like to focus on an interesting problem I faced when parsing this input. I wanted the user to be able to enter several elements: the layout (the cards), the vulnerability, the type of scoring, and the opening lead, each separated by a comma. However, I wanted these elements to be provided in any order. Furthermore, some of these elements were required while others were optional.

Adventures in Looping

Wed, 29 Sep 2021 00:00:00 +0000

I was recently building a Slack bot in Haskell. The core of the Slack integration was a never-ending loop that read messages from a web socket and performed actions based on the message. But how should I go about looping forever in Haskell?

My first pass was to use the aptly-named forever function. My understanding of forever was that it ran a provided IO action over and over (this understanding was incomplete, we’ll get to that). My initial code looked vaguely like this:

Declarative Validation

Tue, 27 Apr 2021 00:00:00 +0000

In the past two years I’ve become reasonably comfortable with both PureScript and Haskell. I’ve learned so many new things while diving into the pure functional programming ecosystem and many of these techniques can be applied to other paradigms. Unfortunately, the pure FP world can feel a bit like another dimension – where many programming problems have elegant solutions but the world of “regular” programming isn’t aware of these patterns.

One such pattern is called “applicative-style validation”, but I’ll simply call it “declarative validation”. In this post I’ll provide some motivation for using this technique and then build a small library in Python implementing these ideas.

PureScript and Haskell

Wed, 24 Feb 2021 00:00:00 +0000

Two years ago, I starting learning PureScript. I had been intrigued by purely functional programming for some time but had failed to learn Haskell once or twice. PureScript seemed to be a kinder, gentler introduction to this world while retaining the fundamental properties of pureness that made Haskell intriguing to me. As part of my learning process, I rebuilt a slack bot¹ I had previously written in go.

Once I had learned PureScript and become more comfortable with purely functional idioms, the next logical step seemed to be learning Haskell. I was surprised to discover how much Haskell I already knew from learning PureScript, but core features like laziness (PureScript is a strict language) took some getting used to.

Parsing Untrusted Input with Elixir

Sun, 23 Aug 2020 00:00:00 +0000

I’ve spent a lot of time in the past year learning PureScript and it has drastically changed the way I think about programming in general. The biggest change in my thinking is described by the excellent blog post Parse, don’t validate.

The most important passage in the post, I think, is this:

Consider: what is a parser? Really, a parser is just a function that consumes less-structured input and produces more-structured output.

Drawing Fractals with PureScript

Wed, 03 Jun 2020 00:00:00 +0000

Recently, for no good reason, I added an easter egg to my personal website. I love fractals and decided to add a visualization of the dragon curve. Here were the requirements:

Every 10 seconds, a new iteration of the dragon curve would be drawn.
If the user clicked anywhere within the drawing area, a new iteration would be drawn and the 10 second clock would be reset.
After the 10th iteration is drawn, the drawing should be cleared and the process should restart.

I decided to use SVG to draw the lines of the fractal. Initially, I built a solution in Elm. However, I was missing the flexibility I’d experienced with my previous back end work in PureScript and wanted to explore using it on the front end. This post walks through the process of rebuilding the solution in PureScript.

Parser Combinators in Elixir

Sat, 14 Mar 2020 00:00:00 +0000

Delving into the world of pure functional programming caused me to learn about parser combinators. Upon returning to Elixir, I was excited to see that nimble_parsec is a great example of a parser combinator library for the Elixir ecosystem.

Parser combinators can be notoriously confusing when first learned. In this post I’ll provide a gentle introduction to parser combinators via nimble_parsec.

What is a Parser Combinator?

Have you ever found yourself writing a regular expression to parse input? I know I have. You finally have the syntax correct and then new requirements get added. Suddenly you need to support optional tokens, lists of values and other complicated types of input. When regular expressions start to break down because of complexity, it’s time to reach for a more powerful abstraction. Enter parser combinators.

Building a Slack Bot in PureScript

Fri, 31 Jan 2020 00:00:00 +0000

I recently open sourced my first large PureScript project. It’s a slack bot that allows searching for cards from the Epic Card Game. In this post, I’ll discuss the process of writing the application, what went well and what went poorly.

An Overview of the Slack Bot

I was excited about building this project in PureScript because it was complicated enough to be interesting but not so complicated as to be overwhelming. The key requirements for the bot were:

PureScript Async FFI

Sat, 04 Jan 2020 00:00:00 +0000

I recently posted about using Aff for asynchronous effects in PureScript. In this follow-up post, I’m going to discuss using JavaScript FFI in conjuction with Aff.

Aff and FFI

PureScript gives us very nice FFI utilities to call JavaScript code. Aff provides a function called fromEffectFnAff that lets us turn asynchronous JavaScript behavior into an Aff in our PureScript code.

Let’s create an example that reads a file from the file system using FFI. We’ll pass our foreign function a String and expect to get back an Aff String of the contents of the file.

Asynchronous PureScript

Tue, 17 Dec 2019 00:00:00 +0000

One of my favorite features of PureScript is its ability to work with asynchronous effects. While learning the language, I struggled to find any beginner material that introduced the relevant topics and included small examples. This post hopes to fill that gap.

Getting Started with Aff

PureScript’s built-in type for effects is called Effect. However, this type represents synchronous effects. This means if we want expose asynchronous APIs to our users using Effect, we’re stuck with the callback-style. Here’s a contrived example that “slowly” adds two numbers together using Effects:

Laziness in PureScript

Wed, 19 Jun 2019 00:00:00 +0000

I’ve been learning PureScript for the past few months and really enjoying it. PureScript is a Haskell dervied language that compiles to JavaScript. You can target node for the backend or the browser for frontend code.

One of my favorite features of PureScript is its fantastic interop with JavaScript. This makes the language very pragmatic – though it has a large ecosystem of native packages, anything that’s missing can easily be handled with an existing npm package and interop. PureScript made a big departure from Haskell in order to make this interop more convenient. While Haskell is a lazy language by default, PureScript is strict.

Go Dependency Injection with Wire

Sun, 07 Apr 2019 00:00:00 +0000

Several months ago I wrote a blog post about dependency injection in go. In the time since that post was written, Google has released a fantastic new dependency injection container for go called wire. I much prefer wire to other containers in the go ecosystem. This post will explain why.

A (Very) Brief Primer on Dependency Injection

Dependency injection (DI) is a style of writing code such that the dependencies of a particular object (or, in go, a struct) are provided at the time the object is initialized.

Concurrent Ruby with Tasks

Mon, 29 Oct 2018 00:00:00 +0000

Yes, you read the title correctly. And yes, ruby still has a GIL. However, ruby has long been able to support concurrency for IO-bound calls. Ruby will not block the current thread if it is waiting on IO. In practice, this means that many of our ruby programs (like web applications) can use ruby’s threads to concurrently serve multiple requests.

Working directly with ruby’s threading primitives can be complicated. This is a problem that the concurent-ruby library aims to solve. This library is mature and comprehensive but it offers a staggering number of APIs for modeling concurrency in your application.

So You Bought a Pixelbook

Sat, 16 Jun 2018 00:00:00 +0000

Initial Setup

First, follow the Quickstart instructions here.

You now have two things set up – a VM called termina and a container inside of that VM called penguin. This VM and container are “special” – files within penguin are accessible via the Files app and any GUI applications installed inside of penguin will be accessible via the launcher. Other than that, penguin is just a regular debian stretch LXC container.

To access a shell inside of pengiun (which is inside of termina), simply launch the Terminal program. This starts the termina VM (if not already started), starts the penguin container (if not already started) and drops you in a shell.

Lazy Providers in Dig

Fri, 25 May 2018 00:00:00 +0000

If you haven’t yet read my previous post on depedency injection in Go, please do so first. This post describes a simple technique to make dig’s DI container even more powerful.

All values provided by dig’s container are singletons. The provider is called the first time the value is required and the result is cached. All subsequent providers that depend on this value used the cached result. This behavior is usually very desireable but there are times when we want a fresh value to be produced by the container. Often this is useful for data that is scoped by a lifecycle that is shorter than the lifecycle of the application itself (say, the lifecycle of an HTTP request inside of an HTTP server).

Dependency Injection in Go

Tue, 15 May 2018 00:00:00 +0000

Update - you should probably read my more recent post about dependency injection with wire.

I recently built a small project in Go. I’ve been working with Java for the past few years and was immediately struck by the lack of momentum behind Dependency Injection (DI) in the Go ecosystem. I decided to try building my project using Uber’s dig library and was very impressed.

I found that DI helped solve a lot of problems I had encountered in my previous Go applications – overuse of the init function, abuse of globals and complicated application setup.

Promises as Values

Thu, 13 Jul 2017 00:00:00 +0000

I was recently working on a small JavaScript project in which I needed to perform several asynchronous operations sequentially. I had a collection of images on a page and I needed to fade each of them out one at a time. I ended up with a nice technique using Promises.

Let’s suppose we have a function that fades out an image given a selector and a duration (I was using jQuery, but the details don’t matter). We can call this function like so:

Elixir's Secret Weapon

Fri, 12 May 2017 00:00:00 +0000

I recently began using a new(ish) feature of Elixir that completely transformed the way I build programs. I’m talking about the special form with. It can feel unfamiliar at first, but it is extremely powerful and flexible. This article will explain how with works and how it can be used to make your code more robust to errors. First, though, let’s look at the problem with is trying to solve.

Another Perspective on Promises

Wed, 28 Dec 2016 00:00:00 +0000

I spent 9 months of this year working on a project using Java 8 and enjoyed it much more than I expected. Specifically, the addition of Optional made my code feel cleaner, more functional and less error prone. I had Java 8 on the brain when I tackled a small JavaScript project a few weeks ago. After finishing it, I decided to go back and try it again using Promises. I was immediately struck by how similar Promises are to a cousin of the Optional – Result. In this post I’ll describe Promises from the perspective of building robust pipelines for your code, later showing how Promises also unify synchronous and asynchronous code.

Specify Your API

Fri, 05 Aug 2016 00:00:00 +0000

Much of the past 6 years of my professional life has been spent designing, implementing and maintaining APIs. I’ve learned many things to avoid as well as a handful of good techniques. However, it wasn’t until 3 months ago that I was exposed to a practice I consider the most important thing you can do while building APIs. Every production-quality API I build going forward will be rigidly and explicitly specified.

Extensible Design with Protocols

Sat, 19 Mar 2016 00:00:00 +0000

I wrote some code this week that reinforced the power of protocols as a tool for software design. The term “protocol” can mean many things in the world of software. Let me clarify that I’m using protocol to mean the mechanism used by some languages (Elixir, Clojure, etc) to achieve polymorphism. Used properly, protocols allow you the provide users of your code with a set of standard behavior as well as a clear contract for implementing that behavior on standard or custom types.

Elixir Streams

Mon, 08 Jun 2015 00:00:00 +0000

I previously wrote about explicitness in Elixir. One of my favorite ways the language embraces explicitness is in its distinction between eager and lazy operations on collections. Any time you use the Enum module, you’re performing an eager operation. Your collection will be transformed/mapped/enumerated immediately. When you use the Stream module, you’re performing lazy operations.

The Stream module provides many of the same operations as Enum, but when used with Stream they’re describing future computations rather than actions to be taken immediately. Conveniently, all streams also implement the Enumerable protocol, meaning they can use any of the functions within Enum.

Sanity Tests

Fri, 29 May 2015 00:00:00 +0000

It is common for test “classifications” to have a plethora of definitions. Sanity tests are no different. Wikipedia says the following on the subject:

the sanity test […] determines whether it is possible and reasonable to proceed with further testing.

This implies that a sanity test is some sort of “pre-test” to determine if further testing even makes sense.

I, however, think of sanity testing as breaking the fourth wall of the codebase. I believe sanity testing should test assumptions about the codebase itself rather than the behavior of the code.

The Value of Explicitness

Fri, 03 Apr 2015 00:00:00 +0000

Elixir is often compared to Ruby. It’s true that Elixir takes inspiration from Ruby’s syntax. One of Elixir’s core tenets is “metaprogramming”, something often associated with Ruby and its ecosystem. That said, after using Elixir for a small amount of time it is immediately obvious that the semantics of the languages are very different. More subtly, Elixir focuses on explicitness where Ruby is often implicit. In this blog post, I’ll discuss Elixir’s approach to composing functionality in an explicit manner.

An Empathetic Functional Language

Fri, 20 Mar 2015 00:00:00 +0000

I’ve been writing Elixir code for over a year. Never have I been more excited about the prospects of the language and its community. The language is young but very promising. Many smart people are getting involved. There’s a hell of a trajectory here for a language that released 1.0 merely 6 months ago.

I’ve been wondering what is it specifically about Elixir that has pulled me in and prompted my involvement in the community. In a word, it’s empathy. More specifically, empathy for the user.

Pagination with Phoenix & Ecto

Fri, 20 Feb 2015 00:00:00 +0000

I’ve been working on a web application built in Elixir. I’m using Phoenix as the web framework and Ecto to talk to my database. As the amount of data in the application grew, I needed to paginate some of the views. I wasn’t able to find an existing pagination solution for these tools so I ended up building my own. This post will discuss what I built.

Goal

Once we’re done, we should be able to paginate any Ecto query using parameters provided by a Phoenix controller action. I’m going to assume you’re familiar with building composable Ecto queries. If you aren’t, read this post.

Composable Queries with Ecto

Fri, 23 Jan 2015 00:00:00 +0000

In my previous post I briefly covered some lessons I’d learned while building a (kind of real) web app in Elixir. Today, I’d like to take an in-depth look at composable queries in Ecto. First, a brief introduction to Ecto.

What is Ecto?

I think of Ecto as a light-weight ORM. Ecto uses Elixir structs to represent database tables and provides a DSL for building and executing database queries. Because I’m boring, we’re going to use the ages-old “post has many comments” example to demonstrate Ecto’s capabilities. We’ll assume we have the following models.

Building an Elixir Web App

Mon, 19 Jan 2015 00:00:00 +0000

Over the past few months I’ve been building a small internal application at work. I’ve been using Elixir, Ecto and Phoenix and it’s been an absolute blast. I thought it would be useful to put together a “lessons learned” blog post about the techniques I’ve found helpful using these tools to build a database-backed web app.

This post is not intended as an introducion to any of the these tools. I assume some knowledge of Elixir, Ecto and Phoenix.

Good Software Developers

Sat, 01 Nov 2014 00:00:00 +0000

I’m approaching 8 years as a professional software developer. I’ve written a lot of code, worked on a few teams and helped build a team from 4 developers to ~60. Now, more than ever, I find myself thinking about what it means to be a good software developer. Not good as in “good is the enemy of great”, but good as in “I want to work with this person again”. I think there are three characteristics that make someone good in this industry.

Node Streams for APIs

Sat, 04 Jan 2014 00:00:00 +0000

Node streams are a fantastic abstraction for evented programming. They’re also notoriously hard to implement. In this post, I’d like to walk through implementing a streams2 Readable stream to wrap an API.

The API

Suppose we have a web service that returns a list of customers. There might be a large number of customers, so this service paginates the results and expects us to provide a page number when requesting data. A sample request to the API might look something like the line below.

Understanding gen_server with Elixir and Ruby

Fri, 25 Oct 2013 00:00:00 +0000

Recently, I’ve been spending some time working in Erlang and Elixir. I had tried to break into Erlang in the past but I was always stymied by the steep learning curve of OTP. gen_server in particular always seemed like black magic to me. However, after attending an Erlang workshop at Lambda Jam this year it finally clicked for me. After I finally “got it” I had another realization: it isn’t that complicated, but there aren’t very many good explanations. In this post I’m going to attempt to explain gen_server using Elixir and Ruby code and some simple diagrams.

Clojure core.async and Go: A Code Comparison

Thu, 04 Jul 2013 00:00:00 +0000

Last week, Rich Hickey announced Clojure core.async in a blog post. As mentioned in the post, the new core.async library has a lot in common with Go. In this post, I’ll compare the fundamental building blocks of concurrency in core.async and Go with code examples.

Note: Clojure core.async provides two sets of operations on channels. The blocking operations are for use with native threads and the non-blocking operations are for use with go blocks. In this post, I’ll be focusing on the non-blocking operations used with go blocks but I’ll briefly mention the blocking versions.