Type Classes

Disregard Data.List

Chris Martin — Mon, 13 May 2024 05:10:32 GMT

Lately I’ve started using streaming library by default instead of the utilities in Data.List. The standard manipulation functions for list are part of the Haskell Report and are a staple of every introductory Haskell tutorial, but I’m over it. I don’t think they’re very useful for everyday programming, and I don’t even think they’re great as an introduc…

Mise en place

Chris Martin — Mon, 04 Dec 2023 14:24:01 GMT

Early language acquisition students, at the elementary and middle school levels, can see a problem with the language invisible to those of us who are old, incurious, and set in our ways: The language contains synonyms. These excess words which ancestors have failed to prune represent the lack of insight and care that characterizes the older generation w…

Haskell PVP numbers are your friends

Chris Martin — Mon, 21 Aug 2023 14:25:04 GMT

Using the Computer involves being exposed to, and at times interacting with, a lot of nonsense. If you use git, you have probably said things Online like “this issue is fixed by b7ae910a.” That last bit is a hash and its entire purpose is to be meaningless nonsense; it’s a beautiful marvel of cryptography, really. It identifies the git commit, but you w…

Nonzero magnitude: Prisms and lenses

Chris Martin — Sat, 05 Aug 2023 17:58:54 GMT

The first part of this series argues that affine traversals should be considered the core optics concept. You might ask, if that's true, why does everybody talk about “prisms” and “lenses” so much?

Part two gave an example of a class of affine traversals, but I did not give instances to define them.

Here I pick up where that left off, and in the process I…

Positive integers and affine traversal

Chris Martin — Sat, 22 Jul 2023 22:55:43 GMT

I do not in general enjoy fussing with numbers. Arithmetic in programming is usually drudgery, a distraction, a problem in need of correction. This article will contain a small amount of math involving numbers (no greater than 10), but the focus will then turn to affine traversals, which I have previously asserted to be a super important idea.

Integer ty…

Lead or be led

Chris Martin — Sun, 16 Jul 2023 18:50:21 GMT

I like dogs for thinking about the nature of agency. I’ve written previously about how designing systems that work for us in the long term is more effective than fighting problems as they come up, my chief example being that instilling good habits is more effective than fighting a dog’s bad habits.

Dogs are interesting because they’re submissive enough t…

The turtle protocol

Chris Martin — Mon, 03 Jul 2023 21:05:55 GMT

Haskell subjects discussed below: streaming-commons, binary, GADTs, and a bit about transactional queues.

hspec, specify, shouldBe

Chris Martin — Mon, 26 Jun 2023 10:27:59 GMT

The title of this article is a test framework.

import Test.Hspec (hspec, specify, shouldBe)

It’s really important to have a low-friction path to get started with writing tests, or else you probably won’t do it. So get into the habit of starting with this little template (three silly test assertions provided for demonstration):1

import Test.Hspec (hspec, spe…

The Args and the Env

Chris Martin — Tue, 20 Jun 2023 23:16:57 GMT

The moral of today’s story is: Don’t do a job badly just because the job is easy.

The resilient repository

Chris Martin — Sun, 18 Jun 2023 16:08:06 GMT

These days, we tend to design our gardens and our gardening for good times, times when everything is going well. That isn’t what we need. Reality is, there is almost always something going wrong. Hard times are normal.
[…] How to garden in the best of times was not the issue. I didn’t need a “good-time garden.” I needed to understand more about how to ga…

Using AWS Secrets Manager

Chris Martin — Thu, 08 Jun 2023 14:04:24 GMT

I’ve been anticipating the release of Amazonka 2.0 for several years now. The latest release on Hackage requires base <= 4.14 (GHC 8.10), and this is the last package that has held me back from upgrading the Type Classes server. Unwilling to wait any longer, I’ve given up on Amazonka.

I was only using it for one thing: to fetch passwords stored in AWS Secrets Manager. So it wasn’t hard to replace Amazonka with my own library that is simply a small wrapper for the official AWS command line interface. My package is aws-secrets.

The centrality of AffineTraversal

Chris Martin — Mon, 05 Jun 2023 11:20:03 GMT

Today’s subject is optics. This article is not extensive enough to qualify as an introduction to the subject, but it does offer a palatable sample. If I had to vote for the worst example of off-putting Haskell jargon, I think it would be "affine traversal." My math background is not insubstantial, but I never studied anything in which the word “affine” came up. This is part of why I ignored this sort of optic for so long. This was unfortunate, because I now think that

In the garden with NixOS and XMPP

Chris Martin — Tue, 30 May 2023 03:08:00 GMT

I’m departing from my usual thing to tell a story about a little project I did today. It will take us into some gritty aspects of systemd service configuration. If you have a NixOS server running already, you could follow along and have a fun tool running in an hour or so. If not, just come along with me to get an idea of what NixOS can do!

Programming requires breadth of knowledge

Chris Martin — Fri, 26 May 2023 19:56:24 GMT

For readers who haven’t figured it out already, my shtick is arguing that the pragmatic experience of Haskell doesn’t have to be substantially different from any other language. Here I want to combat the notion that learning Haskell is primarily about grasping some hard core concepts.

Subscribe now

Folks seem to expect and perhaps want the language to have a few Deep …

Turtles aren't just for kids

Chris Martin — Fri, 19 May 2023 23:00:33 GMT

I have a confession: I’ve gotten extremely bored with writing demonstration code. The problem is that the only interesting effect I’ve ever been able to achieve in a program that can be fully presented within the scope of a blog post or book chapter is printing text. No matter what interesting Haskell concepts I introduce, no matter what kind of files, databases, or network steps are involved, it’s all up to your imagination to picture what’s going on. At best I’ve been able to spice things up by drawing diagrams that depict the steps involved, but in the end I really have nothing to

Abstractions of import

Chris Martin — Tue, 09 May 2023 23:18:00 GMT

Today I have released the 100% complete Sockets and Pipes book, a labor now five years from its inception. It is a unique project, in many ways experimental, and in retrospect a greater risk than a wiser man would have taken on.

Julie and I had been writing about Haskell mostly by covering one subject at a time: a series about monoids, a series about fun…

Faking with type families

Chris Martin — Wed, 03 May 2023 23:23:46 GMT

My example this week expands upon testability and the notion of “seams” borrowed from Working Effectively with Legacy Code. I ended the Working with Legacy Haskell article by hinting that because Haskell’s approach to polymorphism is more general than that of Java or C++, we have more substantial ability to create places in our code where a test suite c…

Make invalid states representable.

Chris Martin — Tue, 25 Apr 2023 20:23:31 GMT

A favorite functional programming motto is “make invalid states representable.” If we can fully model the possible states of a system using algebraic types—including states that are invalid—then we can provide good error messages that describe why something is invalid, and we have more possibilities for recovering from error.

A datatype: Configuration

For…

Erasing at the blackboard

Chris Martin — Wed, 19 Apr 2023 01:49:30 GMT

A common tic among my old math professors was to compulsively erase or revise what they had written and then immediately chastise themselves for doing so. “I'm sorry, it’s terrible to erase at the blackboard,” they'd mutter immediately after wiping something away.

Teachers who write a lot often erase just to recover space on the board, and it tends to be…

Working with Legacy Haskell

Chris Martin — Mon, 10 Apr 2023 17:25:28 GMT

In 2010 I picked up Michael Feathers’ Working Effectively with Legacy Code1 from the company book shelf because I felt the title described something I had been having trouble with. Most of my software experience at that time was from class projects, and I found that what I had learned so far in school wasn’t sufficient for corporate work. I was reminded of it again while thinking about some commentary from grumpy Haskell advocate Deech:

I've found very few tech tutorials which teach you to get out from under a mess. It's all golden path scenarios, maybe that's why there's such a massive gap between learning and practice.

Too much writing focuses on school-style stuff but not corporate wisdom, and so I got to wondering how much of Feathers I could translate into Haskell. What follows is a sort of book review: Working Effectively with Legacy Code from a Haskeller’s perspective. This article covers my thoughts on chapters one through four.

What is legacy code?

Our legacy is what we pass down for others to inherit. A legacy can be valuable, but in any inheritance one is likely to find something disturbing.

“Now… Little man, I give the watch to you.”

My favorite quote from this book comes from the preface:

To me, legacy code is simply code without tests.

I think this definition is spot on. When we’re using “legacy” in the pejorative sense, it’s code that we’re stuck with because it’s hard to change. When we say code is hard to change, we mean it’s hard to be confident that the changes will work and not break something. The book, then, is about how to regain lost confidence.

Specifically, by tests Feathers is talking about unit tests: checks that are very fast and have no dependencies on a database, network, file system, or any other kind of environment that isn’t fast and easy to set up. These tests are what really matters because they allow a tight feedback loop that lets us continually work with confidence.2

Main bullet point of the book: To work with legacy code, first we have to make it not legacy code anymore, and we do that by introducing testing. To introduce testing, careful refactors are often needed first. So we first do conservative refactoring code to make it testable, then write tests, and finally then we can begin the work we set out to do.

Working with Feedback

Feathers gives examples using Java and C++ with UML diagrams — all things I recall from school but haven’t worked with in a long while — and they are at times difficult for me to follow. But the gist of the example in chapter two is that shows two types of refactor to break problematic dependencies:

Changing a function’s domain to something more specific so a test doesn’t have to instantiate values that are not really needed.
Changing a function’s domain to something less specific by, in a language like Java, changing a parameter’s type from a concrete class to an interface.

These are really two ways of accomplishing the same thing, which I will illustrate in Haskell.