Hacking on The Negation

Cross-Compiling Haskell under NixOS with Docker

Thu, 29 May 2025 23:55:54 +0000

I learned how to cross-compile Haskell projects under NixOS using Docker images for ARM architectures, and how to run them under emulation on x86_64 hosts.

The Terminal State of Mind

Wed, 28 May 2025 21:24:28 +0000

I use the terminal. Not because I am a command-line wizard or particularly efficient with it, but because the GUI has never given me the rhythm and flow I need.

NixOS Rebuilds, Upgrades and Generation Diffs

Tue, 27 May 2025 21:20:42 +0000

Today, I upgraded my NixOS system to the latest version, v25.05. It went smoothly. I just want to report my experience here.

Boring on Purpose: Bold Moves in Internal Tooling

Mon, 26 May 2025 23:56:04 +0000

Boring work is often the most effective work. It is the kind of work that might lead us to understand patterns and solve problems that we did not even know we had.

A Glimpse into My Shell

Sun, 25 May 2025 23:20:42 +0000

A glimpse into my shell history reveals the tools I rely on daily. These are not curated – just raw, frequent commands logged over time.

Magic JSON in Haskell

Fri, 23 May 2025 21:19:46 +0000

Among all Haskell libraries I have used, the one I reach for the most is autodocodec. I will explain what it is and what freebies it gives you.

Hacking Haskell with Nix: Two Tricks

Thu, 22 May 2025 22:10:37 +0000

I have mentioned a few times in my posts that Haskell is my go-to language. This is true even for small applications which go beyond a simple shell script.

Hacking Haskell with Nix is an easy and fun way to quickly prototype. I want to share two tricks that I use.

Hacking with mdBook

Wed, 21 May 2025 20:35:08 +0000

This post explores how to hack an mdBook project with scripts.

GitHub Projects My Way

Sat, 10 May 2025 22:33:27 +0000

This post explains why and how I use GitHub for nearly everything. I will also explain how I use GitHub Actions to automate the creation of issues in my GitHub Projects.

Time and Truth: Lessons from Tracking My Work with Watson

Fri, 09 May 2025 23:15:40 +0000

I started using Watson with low expectations. Two and a half years later, it is still one of the few tools I have not quit. And it taught me a little bit about how I really spend my time.

More Haskell Diagrams: Contribution Graph

Fri, 30 Aug 2024 22:39:46 +0000

Shell Cacophony

Thu, 29 Aug 2024 20:05:47 +0000

I am using jq, qsv, uplot quite often. This post is to make sure that you know and use them, too. I hope you will waste as much time as I do, especially with uplot.

Web Browser Extension Workshop - Part 5

Wed, 28 Aug 2024 22:12:02 +0000

This is the last post in the series of the Web Browser Extension Workshop. In this post, we will populate our popup using the service we created in the previous post.

Web Browser Extension Workshop - Part 4

Tue, 27 Aug 2024 21:53:14 +0000

This is the fourth part of the Web Browser Extension Workshop series. In this part, we will populate a database with the OpenGraph information parsed from the Webpage on active tabs. For this, we will implement a service that we can use later to query the OpenGraph information as well.

Web Browser Extension Workshop - Part 3

Mon, 26 Aug 2024 21:53:14 +0000

This is the third part of the series of blog posts about creating a Web browser. In this part, we will change the extension icon based on the OpenGraph information parsed from the Webpage on the active tab. We will also refactor the code by encoding parse results in a better type.

Web Browser Extension Workshop - Part 2

Sun, 25 Aug 2024 15:42:40 +0000

This is the second part of the series of blog posts about creating a Web browser extension using WXT. In this part, we will try to read the OpenGraph tags of the Webpage that is rendered on the active tab.

Web Browser Extension Workshop - Part 1

Sat, 24 Aug 2024 22:31:40 +0000

I am starting a short series of blog posts about creating a Web browser extension using WXT. In this first part, we will set up the development environment and try to read the content of the navigated Webpage or Webpage on the active tab.

Managing NixOS on DigitalOcean with Colmena

Fri, 23 Aug 2024 21:14:29 +0000

In this post, we will prepare a DigitalOcean image for NixOS, launch a droplet with it and manage it using Colmena.

Plot GeoJSON on Your Blog Posts

Thu, 22 Aug 2024 21:50:38 +0000

If you wonder how to plot GeoJSON data on your blog posts, here is a simple example. In this blog post, I will show how to plot Microsoft Azure regions on a map using the Leaflet.js JavaScript library.

Cross-Posting to Hashnode with API

Wed, 21 Aug 2024 17:42:49 +0000

In my previous post, I showed how to cross-post to Dev.to using its API. In this post, I will show how to cross-post to Hashnode using its API.

Cross-Posting to Dev.to with API

Tue, 20 Aug 2024 22:54:52 +0000

Let’s cross-post this blog post to Dev.to using its API.

Easy GitHub CLI Extensions with Nix

Mon, 19 Aug 2024 20:35:24 +0000

GitHub CLI (gh) is one of my favourite tools. In addition to its built-in commands, it allows you to write your own extensions. In this post, I will show you how to write a simple GitHub CLI extension and how to package it with Nix, in particular under Nix Home Manager.

Learning to Like Neovim

Sun, 18 Aug 2024 21:43:13 +0000

After using Emacs for almost 20 years, usually day-in and day-out, I decided to give Neovim a try. I have been using Neovim for two months now, and I can say that I am starting to like it. In this article, I will share my experience of switching from Emacs to Neovim, highlighting the differences, challenges, and benefits I encountered along the way.

Hacking Watson with Haskell - Part 3

Sat, 17 Aug 2024 21:02:23 +0000

In the previous blog posts (part 1, part 2), we managed to read Watson frames and state from its JSON files. In this blog post, we will do something more useful: start and stop timer.

Hacking Watson with Haskell - Part 2

Fri, 16 Aug 2024 22:50:46 +0000

In the previous blog post, we read the Watson frames from a JSON file. In this blog post, we will read the Watson state file and print it to the standard output.

Hacking Watson with Haskell - Part 1

Thu, 15 Aug 2024 21:33:55 +0000

Watson is a command-line tool that helps you to track your time. It is simple and powerful, yet it lacks some features that I would like to have. In this blog post, I will start hacking Watson with Haskell.

More Haskell Diagrams: Dynamic OpenGraph Images

Wed, 14 Aug 2024 20:29:55 +0000

This blog post is a Literate Haskell program that produces its own OpenGraph image using the infamous Haskell diagrams library.

More Haskell Diagrams: Wrapping Text

Tue, 13 Aug 2024 19:14:35 +0000

Working with text, especially wrapping it, can be tricky when generating images with Haskell’s diagrams library. In this blog post, we will write a literate Haskell program to generate an image with text that fits in a box and wraps if we want so.

More Haskell Diagrams: OpenGraph Images

Mon, 12 Aug 2024 21:15:53 +0000

In this blog post, we are continuing to play with Haskell’s diagrams library. We will write a literate Haskell program to generate an OpenGraph image.

Executable Blog Posts: Second Take

Sun, 11 Aug 2024 22:35:12 +0000

This is a second take for my previous blog post Abusing Haskell: Executable Blog Posts. This time, I am going to improve the solution with a Lua filter for pandoc.

More Haskell Diagrams: Images

Sat, 10 Aug 2024 11:03:50 +0000

Let’s continue exploring the Haskell diagrams library. In this post, we will embed external images in our diagrams.

Introduction to Haskell Diagrams

Fri, 09 Aug 2024 23:20:10 +0000

I need a solid declarative diagramming library or tool that I can invest time in. I always wanted to learn Haskell’s diagrams library. In this post, I will give it a try.

Hasura CLI on NixOS: A Working Solution

Wed, 07 Aug 2024 22:02:10 +0000

This post comes after an exciting discovery of a solution to a problem I and my team have been facing for a while: Getting Hasura CLI work on NixOS like any other program.

Using niv to Manage Haskell Dependencies

Tue, 06 Aug 2024 20:31:10 +0000

Using Nix to manage project dependencies and development environments is a great way to keep your projects reproducible and isolated. niv can help you further in this by pinning the versions of your dependencies outside of your Nix code as JSON data.

In this post, I will show you what using niv looks like and how to override Haskell dependencies. I will also demo a small script I wrote to add Hackage packages to the sources.json file.

Backup GitHub Repositories with gidek

Mon, 05 Aug 2024 21:24:10 +0000

Do you backup your Git repositories? If not, you should consider doing so. I might even have a solution for you if you are using GitHub: gidek. It even has some NixOS goodies packed with it.

Abusing Haskell: Executable Blog Posts

Sun, 04 Aug 2024 12:21:10 +0000

Why? Because I can, and it is a rainy Sunday.

I post my notes on my blog, Hashnode and dev.to, which require slightly different markdown formats. I have been doing the sane thing to fix formats so far. But it is a rainy Sunday and I am bored, so I decided to make this blog post an executable Haskell program to do the same.

NixOS on Raspberry Pi 4 with Encrypted Filesystem

Sat, 18 Nov 2023 00:00:00 +0000

This guide documents how to install NixOS on Raspberry Pi 4 with an encrypted root filesystem.

Literate Haskell with Markdown

Sat, 16 Oct 2021 00:00:00 +0000

This is a short guide to writing Literate Haskell programs using Markdown.