My blog about programming and other stuff

How to "zip" two blocks of lines together

How to "interleave" two blocks of lines together

A full example showcasing overlays and fixpoint evaluation in Nix.

Save on keystrokes by combining the effects of `cd` and `ls` in the terminal

Use nix show-derivation to pretty print Nix derivations

How I ruined my nix.conf file by blindly following howto instructions

My first post in 2020

In this blog post I want to have a look at the actual build step for the ghc executable with packages via Nix

A neat little trick to gain effortless pretty printing of JSON output in your shell

This post is an example how to quickly use vim's scripting possibilities to manipulate text and perform repetitive tasks

This post describes a pattern for better control over where log messages are produced.

Often people think logging does not impact performance when the logging level is high, but this is a misconception!

I present two possible solutions to include external code snippets in Hakyll generated blog posts

I replaced my static site generator from Pelican to Hakyll

How to write a simple text ID replacement plugin in Python for neovim

A short investigation of the callCC function and how it works

How to use do notation with monadic code in Python

Extending the monadic computation examples from a previous post

A proof-of-concept implementation for function overloading in Python

Showcasing the effective use of monads to reduce boilerplate in Python

A complete evaluation of a simple conduit pipeline in Haskell

A recipe for a light weight, flexible and functional style of protocol decoding

A recipe for a light weight, flexible and functional style of protocol decoding

Just a short note about Haskell's RTS options

1 Task, 4 languages: Scraping HTML in Haskell, Clojure, Python and Go

A quick summary how to set up Vagrant in combination with Ansible.

Another code walk, this time for the mapConcurrently function of Haskell's async package

A comparison between two HTML scrappers: scalpel and tagsoup-parsec.

In this post I write two parsers for the same data, one in Haskell the other in Python, and compare them.

This post explains how to control Github's heuristics to determine a repositorie's language.

The first post about my new bonsai and my way to learn this form of art

A simple command line tool to extract recipes from a cooking website.

How to cross compile a program using GNU autoconf

Implementing the lispy lists Python implementation in real functional programming languages

A case study of the awesome techniques of functional programming

A complete evaluation of a simple pipeline in Haskell

How functional list processing can lead to easier code

How to write a quick and dirty script to rename pictures.

How to set your GHCi REPL prompt to a literal lambda

How I usually handle the case when my local branch has diverged with upstream.

Command set to create a new Git repository from parts of an existing Git repository

A collection of useful links regarding Haskell and its FFI

A blog post about fix-point data types and generic folding

What exactly are entry points in setup.py script?

Some explanations and notes about the ReadP module

Me playing around with a lexical scanner in Go

Step by step instruction to build the vim editor from source

A patch for asyncio's sleep function to sleep for a given amount of iterations

An insight into the the inner workings of Python's asyncio library

Vim text objects are a handy thing to know

Vim is powerful right out of the box, but becomes even more powerful with the right configuration

My current approach to the 80 characters text width standard in the Vim editor

A reminder to myself about the packages that should be installed before installing Python from source

Binding the caps lock key to the escape key increases productivity

Useful commands if you played to much with your Linux' */boot* folder

I learned an interesting lesson when I tried to link a Rust program against X11

If you read about parser, some terms are a must to know

I tripped over some Jenkins quirks again lately

Behaviour driven developement is a very popular development style. Python's package index has a few options to support that

Small rst parser tweak for HTML generation

How to handle big pictures with restructured text

Jenkins error output is not easy to interpret

What I don't like about Jenkins' pipeline documentation

Tackeling the same programming task with different languages

I have picked up on Rust and Haskell again

Configuration interface to Bash's autocomplete feature

Part 3 of "A closer look at Python's import mechanism"

Part 2 of "A closer look at Python's import mechanism"

I finally found a satisfying way to handle pipeline scripts

A look at my .gitconfig and .bashrc files

Part 1 of "A closer look at Python's import mechanism"

I am publishing my blog source on GitHub

Modifying the templates

The first article of my new blog