The Negation

I Blogged Every Day for a Month – Again

Sat, 31 May 2025 22:06:31 +0000

Today marks the final day of my second month-long blogging challenge. The first was in August last year. This one, in May, felt different – but just as transformative.

Daily Z Reports and Weekly Reviews

Fri, 30 May 2025 23:30:13 +0000

This is not about improving productivity, but rather a simple but bottom-up hack to improve personal awareness and accountability and extend it to the team. Productivity should be a natural byproduct of that.

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.

Data Definitions, Not Flowcharts

Sat, 24 May 2025 23:43:58 +0000

Computer programs are best understood in terms of the data they consume, process and produce. Flowcharts are useful for visualizing control flow, but not for understanding complexity.

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.

Haskell Project Template with Nix Flakes

Tue, 20 May 2025 21:43:46 +0000

This post introduces my Haskell project template powered by Nix Flakes – a simple setup I use to quickly spin up new Haskell applications.

Deadman Checks in Grafana

Mon, 19 May 2025 22:17:05 +0000

This post is a quick, technical note on how to set up deadman checks in Grafana with InfluxDB as the data source, and how to deal with a peculiar case when the host is not reporting and the alert enters the resolved state.

Stop Feeling Intimidated by Complexity

Sun, 18 May 2025 21:19:54 +0000

Let me tell you the conclusion up-front: Complexity is not inherently bad. The complications are the real enemy.

Choosing A Template Engine: The More Powerful Problem

Sat, 17 May 2025 21:49:05 +0000

Continuing on the topic of template engines, I would like to share my thoughts on the power of template engines, and how it relates to the power of abstractions in programming.

Thinking in Templates

Fri, 16 May 2025 22:30:13 +0000

I believe that there is value in thinking in templates when it comes to programming. I will try to explore the concept of templating in general, how it reveals important patterns in programming, and how it appears in the wild often in the form of template engines.

SDK-Driven Development: A Litmus Test for Good Software Design

Thu, 15 May 2025 18:23:55 +0000

This-driven development, that-driven development, and now you should bother with this other thing?

Why I am Migrating From Zola Back to Hugo

Wed, 14 May 2025 23:45:57 +0000

This post is a summary of my recent decision to go back to Hugo after using Zola. I also report on how LLM assistants with Web access can aid in such decisions, not as an authority but as a research assistant.

Code is Liability

Tue, 13 May 2025 23:55:27 +0000

While programming, we often aim to avoid repetition. Repetition is boring, and ironically, much of programming exists to automate boring tasks in the first place. But repetition is just one symptom of a much deeper problem: Code itself is a liability.

Build a CLI Emoji Picker with fzf and Nix

Mon, 12 May 2025 21:10:27 +0000

In my blog post yesterday, I mentioned fzf. Its simplicity and power make it a good tool for many scripting tasks. In this post, we will see a practical example of how to use it in a CLI program and package it with Nix.

Wayland Application Launchers: Stick with Rofi

Sun, 11 May 2025 23:55:27 +0000

Today is a lazy Sunday, and I did what nobody should do on a Sunday: Spend time trying to replace something that already works. This time, my victim was rofi.

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.

Why and How to Patch a Python Package in Nix

Thu, 08 May 2025 17:24:26 +0000

I bumped into an annoying issue today while upgrading my Python dependencies in a codebase. And I thought it would be a good idea to share the solution with you. Thanks to Nix for making this kind of fix so straightforward.

Nix-Powered Python Development

Wed, 07 May 2025 19:11:06 +0000

After a few years of floating from one hack to another, this is my practical guide to setting up a reasonable Python development environment using Nix flakes with support for testing, linting, formatting, and LSP-based editor integration.

Nix Flake Templates

Tue, 06 May 2025 11:36:39 +0000

Nix is now central to how I structure my workstation setups and manage development and production environments across my projects. Over time, I found myself repeating certain setups. This post is a short note on how I started working with Nix Flake templates to avoid or reduce this repetition.

Working with OpenTelemetry Metrics

Mon, 05 May 2025 21:17:22 +0000

I have started adopting OpenTelemetry in my workshop to unify metrics, logs, and traces. This post explains why –and how– I took the first step.

Hold My Data

Sun, 04 May 2025 20:20:29 +0000

This post is about data snapshots, backups and archives, why we create and keep them, and how this entire exercise can be seen from top-down and bottom-up in a business setting.

Vectorized Data Pipelines

Sat, 03 May 2025 23:04:29 +0000

This post shows how to use Vector to capture and persist webhook events – like those from SendGrid – into a PostgreSQL database with minimal setup.

Ruff and Ready: Linting Before the Party

Fri, 02 May 2025 14:32:07 +0000

In this post, I share why I value linters and formatters, and how I migrate from traditional Python tools to ruff.

Grafana Webhook Integration with ntfy

Thu, 01 May 2025 11:16:05 +0000

This post explains how to integrate Grafana alerts with the ntfy notification service using Grafana’s Webhook integration, notification templates, and ntfy’s templating capabilities.

Completed My Blogging Challenge

Sat, 31 Aug 2024 17:16:54 +0000

Today marks the end of my monthly blogging challenge. I wrote a blog post every day for a month. Here is how it went and what I learned.

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.

Pomodoro Timer: Waybar and uair

Thu, 08 Aug 2024 21:02:30 +0000

Most life hackers know about the Pomodoro Technique. I tried it, and saw its merits in the past, but I never adopted it as a habit. I decided to fully invest in it this time, starting with my Pomodoro Timer on my desktop.

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.

Managing NixOS Secrets via SOPS, sops-nix and opsops

Sat, 03 Aug 2024 18:29:25 +0000

Secret provisioning is a critical operation during the deployment and management of a software system. The way it is done can have significant impact on both security and operational efficiency.

In this post, I am going to discuss SOPS, sops-nix and opsops tools for managing secrets and how I and my team use it.

Your package.json as a Credit Account

Fri, 02 Aug 2024 21:54:10 +0000

It is quite easy to install a new npm package into your project. I go one step further, and insist on that actually it is too easy.

Every dependency in your project is like an expense on your credit account. And that is not good if this credit account is not managed properly.

OpenResty on NixOS for an API Gateway

Thu, 01 Aug 2024 11:45:40 +0000

Are you using an API gateway? Do you really need one? If you are using NixOS and feel comfortable with some Lua, you may want to consider OpenResty on NixOS as an API gateway.

Running NixOS Guests on QEMU

Wed, 31 Jul 2024 14:41:19 +0000

Once in a while, I want to test some NixOS configuration without affecting my main system or launching new hosts on the cloud.

Running NixOS on a virtual machine (VM) is a safe and reproducible way to test such configurations. As for VMs, I have used VirtualBox, Vagrant and lxd in the past. However, I have found QEMU to be the simplest and most flexible solution for my needs.

This guide is a quick reference to create and run NixOS guests on QEMU.

Archiving PostgreSQL Backups on NixOS

Tue, 30 Jul 2024 09:18:10 +0000

This is a technical note on how to archive PostgreSQL backups on NixOS to one or more targets using rclone.

Develop R Packages under Nix Shell

Fri, 05 Jan 2024 08:22:10 +0000

This is a guide for creating, developing and testing R packages under a Nix Shell using R tools such as devtools, testthat and usethis.

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.

Modern Web-based APIs: What to Expect?

Wed, 03 Jun 2020 00:00:00 +0000

Here are some quick notes for mysels on what to expect from a modern, Web-based API that facilitates data query and manipulation (and possibly remote procedure calls).

Unreasonable Revolutionary

Sun, 10 Jun 2012 23:10:00 +0000

How to Solve It: A New Aspect of Mathematical Method by George Pólya provides a detailed and entertaining survey of general methods for problem solving, namely heuristics. I guess that most people dealing with mathematics in daily life have read this book.

Abstraction as Bread and Butter

Sat, 19 May 2012 14:09:23 +0000

I find the first pages of a book to be the most instructive ones for many reasons. When I look at a good book that I read many years ago, I still find those first pages more interesting and inspiring.

Redefining the Ontology of Accounting

Sun, 15 Jan 2012 08:03:01 +0000

Accounting is more than 7,000 years old. This discipline helps us to plan, execute and assess business transactions. It is also the universal language of business.

In particular, double-entry accounting (also known as double-entry bookkeeping) system has been used for about the last five centuries as a framework to record business transactions. We can then consolidate these transactions and report summaries through standardized documents such as ledgers, balance sheets, income statements, etc.

However, we are living in the age of information technology. And the way we perform accounting still looks like it is pre-computer age.

Can we do any better now?

In the following, I will briefly explain my concerns. Then, a relatively recent and exciting ontological approach to accounting follows.

About

Mon, 01 Jan 0001 00:00:00 +0000

My name is Sinan.

I am a computer programmer and a lifestyle entrepreneur. You can find more information about me on my LinkedIn and GitHub profiles, or contact me at vst@vsthost.com.

This Website hosts my blog posts, and its source code is available on GitHub.

Unless otherwise noted, this Website and its content are licensed under CC BY-SA 4.0.