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.
- Catamorph your DSL: Introduction (Haskell)
- Catamorph your DSL: Deep Dive (Haskell)
- Catamorph your DSL: Trade-offs (Haskell)
- Catamorph your DSL: Clojure
- Catamorph your DSL: C++ Port
- Paramorph your DSL: C++
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.
- Code your own QuickCheck
- Code your own QuickCheck: Higher Order Function generation
- Code your own QuickCheck: Shrinking inputs
- Code your own QuickCheck: Experiments on a DSL
- QuickCheck is fun, deal with it
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.
- Building a Clojurescript game: Introduction
- Building a Clojurescript game: Architecture
- Building a Clojurescript game: Game Logic
- Building a Clojurescript game: Thoughts on Spec
- Building a Clojurescript game: Rendering
- Building a Clojurescript game: Application State and Game loop
- Building a Clojurescript game: AI
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.
- LISP meta-programming for C++ developers: Introduction
- LISP meta-programming for C++ developers: First macros
- LISP meta-programming for C++ developers: Compile time computations
- LISP meta-programming for C++ developers: Automatic Traces (Part 1)
- LISP meta-programming for C++ developers: Automatic Traces (Part 2)
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.
- 10 things Idris improved over Haskell
- Idris dependent typing challenge: Bowling Kata
- Implementing Clojure-like Transducers in Idris: definitions and main concepts
- Implementing Clojure-like Transducers in Idris: advanced transducers
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.
- Hexagonal Architecture and Free Monad: Two related design patterns?
- A study of 4 Money class designs, featuring Martin Fowler, Kent Beck and Ward Cunningham implementations
Language(s): Haskell, Clojure, C++.
Follow @quduval
Deque 