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.