Computing on The Negation

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.

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.

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.