Of the many fascinating insights to be found in Elinor Ostrom's book Governing the commons there are a few that have really stuck with me. My personally sticky insights aren't really related to the core argument, it's all well out of my wheel house after all. My ears most pricked up when Ostrom wrote about the social responsibilities of scientists and the social impact of social research.

Deploying Ruby on Rails apps to Heroku has always been a delight, and now that they have a container registry other run-times are similarly delightfully deployable. No build-packs required.

with (import <nixpkgs> {});
dockerTools.buildImage {
  name = "hello";
  contents = [ hello ];
}

brad@brad
~ » nix-shell -p figlet
brad@brad [nix:shell]
~ » figlet -f smscript nifty

      o |\_|_
/|/|  | |/ |  |  |
 | |_/|/|_/|_/ \/|/
        |)      (|

If you're like me, you develop on both macOS and Linux and are very much a creature of habit, then this may be of interest. It's a description of how I arrived at my current approach for maintaining a base development environment across the two platforms.

Writing software can give us the ability to take a nearly impossibly abstract idea and use it to create a runnable program.

In this post we're to talk about "fundamental things" and see how much we can build with them.

type a × b =
  forall c.
    (a -> b -> c) -> c

type a + b =
  forall c.
    (a -> c) -> (b -> c) -> c

{ config, pkgs, ... }:
let
  repo = builtins.fetchTarball {
    url = https://repo.tar.gz;
  };
in
{
  imports = ["${repo}/module.nix"];

  services."site".enable = true;
}

I can't promise that this will take you five minutes (it won't). What I will say is this: if you'd like to learn more about Nix and NixOs then this may be interesting.

Haskell has some very interesting type-level features, Servant is a great case-study in how they can be used to build a practical and feature rich library. This post walks through an example in an attempt to become more familiar with its inner workings.

type UsersIndex =
  Get '[JSON] [User]

type UsersShow =
  Capture "username" String
    :> Get '[JSON] User

type UsersAPI =
  "users"
    :> (UsersIndex :<|> UsersShow)

type Lens s t a b =
  forall f. Functor f =>
    (a -> f b) -> s -> f t

_1 :: Lens (a, c) (b, c) a b
_1 = _

_2 :: Lens (c, a) (c, b) a b
_2 = _

Gaining an understanding of the Lens type has been on my todo list for a long time. So I finally bit the bullet and read up a little. These are (more or less) my notes as I went along.

I sought to understand what the fuss was all about and I've now added to the mass of Monad Explainer posts on the internet.

readAFile().then(function (content) {
  return writeAFile(content)
}).then(function (report) {
  console.log(report)
})