(functional)
programming & more.

My recent side-project vindex is a semantic video indexing platform. Users upload videos that then run through a multi-step processing pipeline to prepare and index them. Finally, users can search specific locations in the video using natural language.

Code review is one of the most important tools for successful collaboration on large code bases. It’s an easy way to learn from each other and maintain a high code quality bar.

This week I was reviewing a pull request and the author had disabled Flow type-checking for a specific line via $FlowDisableLine. Since the code was in a central location, we decided to investigate how we’d need to restructure the code for a type-safe version. Spoiler alert: TypeScript didn’t error on the code at hand.

The recently presented Haskell library superrecord is still under heavy development and making great progress. While working on it we noticed that application code using the library would become very slow to compile when the record size exceeded 10 fields. Without any deeper thought, I guessed that the current type level insertion sort (which is O(n^2) in worse case complexity) was at fault. This turned out to be wrong, but I still implemented a more efficient merge sort at type level and would like to share the journey as it was quite fun.

Many mainstream Haskell programs that reach a certain size need to solve at least two core problems. First, all your logic will run in some kind of environment that provides logging, configuration, other external data such as templates and/or some global application state. This environment must be managed somehow and correctly be passed to the specific logic. Secondly, you will need to read and write out data into the real world, for example, to talk to a JSON REST-API. Let’s take a look in detail at these problems and how we can solve them today.

Recently, I wanted to make sure that the generated API documentation for my web framework Spock is always available (on the web) and up to date, both with the current release and with the current master branch.

A popular puzzle interview question goes like this: “Sir Blake has 200 bottles of wine in his wine cellar. 99% of those bottles are red wine and 1% of them are white wine. How many bottles of red and/or white wine does Sir Blake need to drink to reduce the percentage of red wine to 98%?”

Today we will explore how to build a small parser combinator library in Haskell from scratch. This blog post is the result of an experiment to see if I could actually implement this by only looking at the base and text documentation, explicitly without looking at other parser implementations or examples.

I’m exploring programming languages for web front-ends. I’ve enjoyed using JavaScript, but as our projects have grown I’ve wanted more help from the type system when refactoring. TypeScript has been useful, though I was looking for stronger static guarantees after running into some limitations. I was also interested in making state management more explicit: React and other frameworks offer useful patterns, but keeping state in sync still requires care in how we structure our applications. Could Elm help with both? Let’s see!

At Checkpad we are moving JavaScript code to TypeScript. Apart from some initial “take-off” issues like finding, modifying and/or writing missing .d.ts files for libraries, or getting our build pipeline to work, the process was pretty smooth. A few months into that, I’ve discovered some road bumps and will share one today.