This page lists and describes the main series of posts available through this blog. Each series goes into depth in one specific domain.


Open recursion (function)

In this series, we explore a nice and simple technique that allows to combine dynamic programming effectiveness while preserving the declarative nature of naive recurrence formulas.

We demonstrate how to separate the specification of a recurrence formula from the way we execute it, and consequently increase the efficiency of the computation.

Language(s): C++, Haskell.


Open recursion (data)

A deep dive into the recursion schemes known as Catamorphism and Paramorphisms in the Haskell world, to build a small DSL of Arithmetic expression.

Through this series, we show how to decouple the traversal of an Abstract Syntax Tree from the operations we can perform on it, and how it helps building shorter, more maintainable and more composable DSLs.

Language(s): C++, Clojure, Haskell.


Code your own QuickCheck

In this series, we go over the process of building our own Property Based Testing library, inspired by QuickCheck, which we name RapidCheck.

Through this series, you will gain great insight on how Property Based Testing libraries work. You will consequently be in a better position to use them effectively and avoid falling in some of their pitfalls.

Language(s): Haskell.


Implementing a Web Game

In this series, we go over the creation of a Web game in Clojurescript, diving into each of the main phases: from the game logic to the rendering, and covering the Artificial intelligence and the game loop. You can play the game at this link.

Through this series, we show how to architecture such a game, based on very little components: Reagent (a wrapper around React.js) and SVG mainly.

Language(s): Clojure(Script).


Lisp meta-programming for C++ developer

A comprehensive tour of meta-programming in Clojure, aiming at offering a different perspective on meta-programming as C++ developers are accustomed to.

Through this series, you will learn how supporting reflection, being able to manipulate the AST of the language inside the language, and perform any computation at compile time can greatly improve and simplify your code.

Language(s): C++, Clojure.


Fun with Idris

This series of post is about trying the rather new language named Idris, which features pure functional programming like Haskell, coupled with dependent typing features.

Language(s): Idris (and a bit of Haskell).


Domain Driven Design and Functional Programming

This collection of blog posts is about explaining in what aspects Functional Programming approaches are in synergy with Domain Driven Design and its concepts.

Language(s): Haskell, Clojure, C++.


Create a website or blog at

Up ↑

%d bloggers like this: