add kokada.dev (RSS and Atom) - sfeed_tests - sfeed tests and RSS and Atom files
(HTM) git clone git://git.codemadness.org/sfeed_tests
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
(DIR) commit 627538879a243435de10999fae80626ea58eea86
(DIR) parent 0952a65777ea4fa93533cc27ff2c348a61f7c929
(HTM) Author: Hiltjo Posthuma <hiltjo@codemadness.org>
Date: Fri, 6 Dec 2024 13:04:24 +0100
add kokada.dev (RSS and Atom)
uses https://capivaras.dev/ (blogging platform)
Diffstat:
A input/sfeed/realworld/kokada.dev.a… | 3703 +++++++++++++++++++++++++++++++
A input/sfeed/realworld/kokada.dev.r… | 3707 +++++++++++++++++++++++++++++++
2 files changed, 7410 insertions(+), 0 deletions(-)
---
(DIR) diff --git a/input/sfeed/realworld/kokada.dev.atom.xml b/input/sfeed/realworld/kokada.dev.atom.xml
@@ -0,0 +1,3702 @@
+<?xml version="1.0" encoding="utf-8"?>
+<feed xml:lang="en-us" xmlns="http://www.w3.org/2005/Atom"><title>kokada</title><link href="https://kokada.dev" rel="alternate"/><link href="https://kokada.dev/atom/" rel="self"/><id>https://kokada.dev</id><updated>2024-12-04T00:00:00+00:00</updated><subtitle/><entry><title>Praise to scdoc to generate man pages</title><link href="https://kokada.dev/blog/praise-to-scdoc-to-generate-man-pages/" rel="alternate"/><published>2024-12-04T00:00:00+00:00</published><id>https://kokada.dev/blog/praise-to-scdoc-to-generate-man-pages/</id><summary type="html"><p>Hey, its been a long time since my <a href="posts/2024-10-07/01-enabling-le-audio-lc3-in-wf-1000xm5.md">last blog
+post</a>. It is mostly
+because I ran out of things to write, but I expected this. This is probably
+more likely how I am actually going to post from now. At least, it shows that
+my plan to have a <a href="https://kokada.dev/blog/making-a-blog-for-the-next-10-years">blog for a long
+time</a>, that is
+easy to go back when I wanted is working fine, but I digress.</p>
+<p>Going back to the theme of the today blog post, I needed to write a <a href="https://en.wikipedia.org/wiki/Man_page">man
+page</a> for the first time in years. I
+hate <a href="https://en.wikipedia.org/wiki/Troff">troff</a>, the typesetting system used
+for man pages (similar to <a href="https://en.wikipedia.org/wiki/LaTeX">LaTeX</a> for
+documents). It is one of the weirdest languages that I ever saw, and even the
+example in Wikipedia shows that:</p>
+<pre><code class="language-troff">.ND &quot;January 10, 1993&quot;
+.AU &quot;Ms. Jane Smith&quot;
+.AT &quot;Upcoming appointment&quot;
+.MT 5
+.DS
+Reference #A12345
+.sp 4
+Mr. Samuel Jones
+Field director, Bureau of Inspections
+1010 Government Plaza
+Capitoltown, ST
+.sp 3
+Dear Mr. Jones,
+.sp 2
+.P
+Making reference to the noted obligation to submit for state inspection our newly created production process, we request that you consider the possible inappropriateness of subjecting the innovative technologies of tomorrow to the largely antiquated requirements of yesterday. If our great state is to prosper in the twenty-first century, we must take steps
+.B now ,
+in
+.I this
+year of
+.I this
+decade, to prepare our industrial base for the interstate and international competition that is sure to appear. Our new process does precisely that. Please do not let it be undone by a regulatory environment that is no longer apt.
+.P
+Thank you for your consideration of our position.
+.FC Sincerely
+.SG
+</code></pre>
+<p>Keep in mind that the break lines are necessary every time you introduce a
+macro, like <code>.I this</code> (that I <em>think</em> it is for italics). Yes, this format is
+as illegible as hell, and it is worse that the format lacks good tooling (or at
+least I didn't find any good ones).</p>
+<p>Most people when they need to write a man page nowadays ends up using some
+other format that generates a man page. For example, in the past I used
+<a href="https://pandoc.org/">Pandoc</a> to convert Markdown to a man page, but even if
+Pandoc is a great project the result is sub-optimal at best: Markdowns are, at
+the end, designed for generating HTML (and a subset of it), and not man pages,
+so you basically ends up fighting the format for it to do what you want.
+Also, Pandoc is a big project, with a ~200MB binary (at least it is the default
+Pandoc binary in Nix).</p>
+<p>For this specific project I needed something small. I am trying to replace one
+of the most essential pieces inside NixOS, <code>nixos-rebuild</code>, written in Bash,
+with a <a href="https://discourse.nixos.org/t/nixos-rebuild-ng-a-nixos-rebuild-rewrite/55606/">full rewritten in
+Python</a>
+(sorry Rust zealots!), called <code>nixos-rebuild-ng</code>.</p>
+<p>Since this project will eventually (if successful) be in the critical path for
+NixOS, I want to reduce the number of dependencies as much as possible, so
+something as big as Pandoc is out. I could use
+<a href="https://asciidoc.org/">AsciiDoc</a>, but it is a big complicated Python project
+(this may seem ironic, but <code>nixos-rebuild-ng</code> has only one runtime dependency,
+that is optional). And I also hated the last time I tried to use it to generate
+man pages: it more flexible than Markdown, but still far from optimal.</p>
+<p>Thanks to Drew DeVault (creator of <a href="https://swaywm.org/">SwayWM</a>) that seems it
+had the same issues in the past and created
+<a href="https://drewdevault.com/2018/05/13/scdoc.html"><code>scdoc</code></a>, a very simple man
+page generator using a DSL inspired in Markdown, but specific to generate man
+pages. The binary is written in C (and advantage in this case since it means it
+is easier to bootstrap), is small (~1 Kloc) and has no dependencies, so it
+fits the requirement.</p>
+<p>While the language suffers from being a niche project for a niche segment, the
+<a href="https://man.archlinux.org/man/scdoc.5.en">man page</a> for it is actually really
+nice. It is terse though and lacks examples, and this is what this blog post
+will try to accomplish.</p>
+<p>To start, let's have a quick summary of the syntax, written in <code>scdoc</code> as
+comments:</p>
+<pre><code class="language-scdoc">; quick summary:
+; # new section
+; comments starts with ;
+; - this is a list
+; - sub-list
+; - *bold*: _underline_, force a line break++
+; - [tables], \[ can be used to force an actual [
+; . numbered list
+; please configure your editor to use hard tabs
+; see `man 5 scdoc` for more information about syntax
+; or https://man.archlinux.org/man/scdoc.5.en
+</code></pre>
+<p>I actually added this summary in the <code>.scd</code> (the <code>scdoc</code> extension) files that
+I wrote, so it is easy for someone that never saw the format to start
+collaborating.</p>
+<p>And here an example of a (summarised) man page in <code>.scd</code> format:</p>
+<pre class="chroma"><code><span class="line"><span class="cl">nixos-rebuild-ng(8)
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># NAME
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl">nixos-rebuild - reconfigure a NixOS machine
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># SYNOPSIS
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl"><span class="ge">_nixos-rebuild_</span> \[--upgrade] [--upgrade-all]++
+</span></span><span class="line"><span class="cl"> \[{switch,boot}]
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># DESCRIPTION
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl">This command has one required argument, which specifies the desired operation.
+</span></span><span class="line"><span class="cl">It must be one of the following:
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="ge">*switch*</span>
+</span></span><span class="line"><span class="cl"> Build and activate the new configuration, and make it the boot default.
+</span></span><span class="line"><span class="cl"> That is, the configuration is added to the GRUB boot menu as the
+</span></span><span class="line"><span class="cl"> default menu entry, so that subsequent reboots will boot the system
+</span></span><span class="line"><span class="cl"> into the new configuration. Previous configurations activated with
+</span></span><span class="line"><span class="cl"> nixos-rebuild switch or nixos-rebuild boot remain available in the GRUB
+</span></span><span class="line"><span class="cl"> menu.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="ge">*boot*</span>
+</span></span><span class="line"><span class="cl"> Build the new configuration and make it the boot default (as with
+</span></span><span class="line"><span class="cl"> <span class="ge">*nixos-rebuild switch*</span>), but do not activate it. That is, the system
+</span></span><span class="line"><span class="cl"> continues to run the previous configuration until the next reboot.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># OPTIONS
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl"><span class="ge">*--upgrade, --upgrade-all*</span>
+</span></span><span class="line"><span class="cl"> Update the root user&#39;s channel named &#39;nixos&#39; before rebuilding the
+</span></span><span class="line"><span class="cl"> system.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> In addition to the &#39;nixos&#39; channel, the root user&#39;s channels which have
+</span></span><span class="line"><span class="cl"> a file named &#39;.update-on-nixos-rebuild&#39; in their base directory will
+</span></span><span class="line"><span class="cl"> also be updated.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> Passing <span class="ge">*--upgrade-all*</span> updates all of the root user&#39;s channels.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl">See the Nix manual, <span class="ge">*nix flake lock --help*</span> or <span class="ge">*nix-build --help*</span> for details.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># ENVIRONMENT
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl">NIXOS_CONFIG
+</span></span><span class="line"><span class="cl"> Path to the main NixOS configuration module. Defaults to
+</span></span><span class="line"><span class="cl"> <span class="ge">_/etc/nixos/configuration.nix_</span>.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># FILES
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl">/etc/nixos/flake.nix
+</span></span><span class="line"><span class="cl"> If this file exists, then <span class="ge">*nixos-rebuild*</span> will use it as if the
+</span></span><span class="line"><span class="cl"> <span class="ge">*--flake*</span> option was given. This file may be a symlink to a
+</span></span><span class="line"><span class="cl"> flake.nix in an actual flake; thus <span class="ge">_/etc/nixos_</span> need not be a
+</span></span><span class="line"><span class="cl"> flake.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># AUTHORS
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl">Nixpkgs/NixOS contributors
+</span></span></code></pre><p>And here is a screenshot of the result:</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-12-04/2024-12-04-230955_hyprshot.png"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-12-04/2024-12-04-230955_hyprshot.png" alt="Man page rendered from scd
+file"></a></p>
+<p>One of nice things that I found is how looking at the plain text looks kind
+like the man page result already. And if you know Markdown, you can basically
+understand most things that is happening. There are a few differences, like
+<code>*bold*</code> instead of <code>**bold**</code>, and while they're unfortunate they're not the
+end of the world.</p>
+<p>Now, the format has its quirks. The first line being the name of the program
+and section in parenthesis is required, but this makes sense, since you need
+this information for the corners. But for one, it requires the usage of hard
+tabs to create indentation, and the error messages are awful, in a situation
+that kind remembers me of <code>Makefile</code>. Also the choice of <code>[</code> to start a table
+means that the traditional <code>app [command]</code> needs in many cases to be escaped as
+<code>app \[command]</code>. I found this a strange choice since this is supposed to be a
+format that is only used for man pages, and using <code>[command]</code> to indicate an
+optional is common, but at least it is easy to escape.</p>
+<p>In the end, I think all that matters is the result. And for the first time for
+all those years trying to write a man page, I am satisfied with the result. The
+man page looks exactly as I wanted once rendered, and the <code>.scd</code> file looks
+reasonable good that it can work as a documentation for someone that for one
+reason or another can't use the man page (can't say the same for the troff
+version). Also, it is really easy for someone to just go there and update the
+man page, even without experience in the format (except for maybe the
+requirement of tabs). So all in all, I really liked the format, and will use it
+again if I need to write another man page in the future.</p></summary></entry><entry><title>Enabling LE Audio/LC3 in WF-1000XM5</title><link href="https://kokada.dev/blog/enabling-le-audio-lc3-in-wf-1000xm5/" rel="alternate"/><published>2024-10-07T00:00:00+00:00</published><id>https://kokada.dev/blog/enabling-le-audio-lc3-in-wf-1000xm5/</id><summary type="html"><p>One of things that I hate the most about the fact that we are all using
+wireless earbuds instead of wired earphones is the latency: it is bad, getting
+up to seconds(!) depending on your particular combination of OS/earbuds/device.</p>
+<p>There is a solution though: Bluetooth LE Audio, that is supposed to fix
+multiple issues with the original design for Bluetooth Classic Audio, including
+a much lower latency, improved efficiency (e.g.: less battery power) and even
+multiple streams of audio. LE Audio also includes a new default codec for
+improved audio quality, <a href="https://en.wikipedia.org/wiki/LC3_(codec)">LC3</a>, that
+replaces the venerable <a href="https://en.wikipedia.org/wiki/SBC_(codec)">SBC</a> codec
+for audio.</p>
+<p>However, the standard is a mess right now: a few wireless headphones already
+support it, but they're generally disabled by default and it is pretty messy to
+enable. And even after enabling it, getting it to work can be a pain.</p>
+<p>I have pretty much the best setup to use LE Audio right now: a recently
+released Pixel 9 Pro with Sony's
+<a href="https://www.sony.ie/headphones/products/wf-1000xm5">WF-1000XM5</a> earbuds, and
+after lots of tries I got it to work. You can see below the versions of
+everything I am using:</p>
+<ul>
+<li>Android: 14</li>
+<li><a href="https://play.google.com/store/apps/details?id=com.sony.songpal.mdr">Sound
+Connect</a>:
+11.0.1</li>
+<li>WM-1000XM5: 4.0.2</li>
+</ul>
+<p>The first thing you need to do is enable in &quot;Sound Connect&quot; app &quot;LE Audio
+Priority&quot; in &quot;Device Settings -&gt; System&quot;:</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-10-07/photo_4909454744305642922_y.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-10-07/photo_4909454744305642922_y.jpg" alt="LE Audio option inside Sound
+Connect"></a></p>
+<p>After this, you will need to pair your headset with the device again. You can
+do this as same as always: press and hold the button in case for a few seconds
+until a blue light starts to blink. However, this is where things starts to get
+janky: I couldn't get the headset to pair with Android again.</p>
+<p>A few of the things that I needed to do (in no specific order):</p>
+<ul>
+<li>Remove the previous paired headset</li>
+<li>Restart the Android</li>
+<li>Clean-up &quot;Sound Connect&quot; storage (Long press the app icon -&gt; &quot;App info&quot; -&gt;
+&quot;Storage and Cache&quot; -&gt; &quot;Clear storage&quot;)</li>
+</ul>
+<p>If you can get the headset to connect, go to the &quot;Bluetooth&quot; settings in
+Android, click in the gear icon for the headset and enable &quot;LE Audio&quot; option:</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-10-07/photo_4909454744305642937_y.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-10-07/photo_4909454744305642937_y.jpg" alt="LE Audio option Bluetooth
+Settings"></a></p>
+<p>If you can't, you may want to <a href="https://helpguide.sony.net/mdr/2963/v1/en/contents/TP1000783925.html">restore the headset to factory
+settings</a>
+and try again from the start (that means pairing your device with &quot;Sound
+Connect&quot; again, and you may want to try to clear the storage before doing so).</p>
+<p>Yes, the process is extremely janky, but I think this is why both &quot;Sound
+Connect&quot; and Android marks this feature as beta/experimental. And I still need
+to test the latency, but from my initial testing there are some glitches when
+the audio is only used for a short period of time (e.g.: Duolingo only enables
+the audio when the character is speaking). So I only recommend this if you want
+to test how LE Audio will behave, since it is clear that this needs more
+polish.</p></summary></entry><entry><title>Quick bits: where does Nix store Flake's trusted settings?</title><link href="https://kokada.dev/blog/quick-bits-where-does-nix-store-flakes-trusted-settings/" rel="alternate"/><published>2024-09-30T00:00:00+00:00</published><id>https://kokada.dev/blog/quick-bits-where-does-nix-store-flakes-trusted-settings/</id><summary type="html"><p>Have you ever run a <code>nix build</code> command and had this prompt?</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix run .#darwinActivations/Sekai-MacBook-Pro
+</span></span><span class="line"><span class="cl"><span class="go">do you want to allow configuration setting &#39;extra-substituters&#39; to be set to &#39;https://nix-community.cachix.org https://thiagokokada-nix-configs.cachix.org&#39; (y/N)? y
+</span></span></span><span class="line"><span class="cl"><span class="go">do you want to permanently mark this value as trusted (y/N)? y
+</span></span></span></code></pre><p>And realise that you did/didn't want to mark this value as trusted? But where
+is this stored? Well, I had to look at the Nix source code to find the answer,
+since I can't find this anywhere in the web or in ChatGPT (but I am sure that
+now that I posted this it will eventually be searchable), and the answer can be
+found
+<a href="https://github.com/NixOS/nix/blob/c116030605bf7fecd232d0ff3b6fe066f23e4620/src/libflake/flake/config.cc#L13-L16">here</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="n">Path</span> <span class="nf">trustedListPath</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">getDataDir</span><span class="p">()</span> <span class="o">+</span> <span class="s">&#34;/trusted-settings.json&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Where is <code>getDataDir()</code> though? I found the answer
+<a href="https://github.com/NixOS/nix/blob/c116030605bf7fecd232d0ff3b6fe066f23e4620/src/libutil/users.cc#L52-L65">here</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="n">Path</span> <span class="nf">getDataDir</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">auto</span> <span class="n">dir</span> <span class="o">=</span> <span class="n">getEnv</span><span class="p">(</span><span class="s">&#34;NIX_DATA_HOME&#34;</span><span class="p">);</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">(</span><span class="n">dir</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="o">*</span><span class="n">dir</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">auto</span> <span class="n">xdgDir</span> <span class="o">=</span> <span class="n">getEnv</span><span class="p">(</span><span class="s">&#34;XDG_DATA_HOME&#34;</span><span class="p">);</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">(</span><span class="n">xdgDir</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="o">*</span><span class="n">xdgDir</span> <span class="o">+</span> <span class="s">&#34;/nix&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">getHome</span><span class="p">()</span> <span class="o">+</span> <span class="s">&#34;/.local/share/nix&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>So we solved the mystery:</p>
+<ul>
+<li>If <code>NIX_DATA_HOME</code> is set, the file will be in
+<code>$NIX_DATA_HOME/trusted-settings.json</code></li>
+<li>If <code>XDG_DATA_HOME</code> is set, the file will be in
+<code>$XDG_DATA_HOME/nix/trusted-settings.json</code></li>
+<li>Otherwise Nix will fallback to <code>$HOME/.local/share/nix/trusted-settings.json</code></li>
+</ul>
+<p>By the way, if you don't know why you got this prompt, if <code>flake.nix</code> has a
+<code>nixConfig</code> attribute inside <code>outputs</code> <strong>and</strong> this <code>nixConfig</code> is an unsafe
+attribute (like <code>extra-substituters</code>) you will get this prompt, unless you set
+<a href="https://nix.dev/manual/nix/2.23/command-ref/conf-file#conf-accept-flake-config"><code>accept-flake-config = true</code></a>
+in your Nix configuration (please <strong>do not do this</strong>, it is dangerous because
+it may allow running possible unsafe options without asking you first).</p>
+<p>You can inspect the JSON file or delete it and Nix will prompt you again the
+next time you run a <code>nix</code> command. And yes, saving this preference is
+controversial considering this is Nix, but having the power to set <code>nixConfig</code>
+attributes is really powerful, and with great powers comes great
+responsibilities.</p></summary></entry><entry><title>My coding experience with LLM</title><link href="https://kokada.dev/blog/my-coding-experience-with-llm/" rel="alternate"/><published>2024-09-02T00:00:00+00:00</published><id>https://kokada.dev/blog/my-coding-experience-with-llm/</id><summary type="html"><p>I don't want to talk about AI. AI fatigue is real, with (garbage) AI content
+everywhere you go. However, I like to talk about tools, and AIs, or more
+specifically, <a href="https://en.wikipedia.org/wiki/Large_language_model">Large Language
+Models</a> (LLM), can be
+really useful tools. Maybe someday we will have our AI overlords dominating
+everything (including my job), but right now I don't feel particularly
+threatened given my experience with AIs.</p>
+<p>Given that <a href="https://mashable.com/article/google-search-low-quality-research">Google Search is getting
+worse</a>, I am
+slowly relying in LLMs more and more. This is the focus of this post, basically
+<a href="https://www.rottentomatoes.com/m/the_good_the_bad_and_the_ugly">the good, the bad and the
+ugly</a> (by the
+way, never saw this film) of LLMs, especially focused for solving coding
+problems. I will take a look at the my chat history in
+<a href="https://chatgpt.com/">ChatGPT</a> and see where it was a good tool, where it
+shined, and where it just completely wasted my time.</p>
+<p>A disclaimer, I never bothered to buy a ChatGPT subscription because I don't
+feel that the tool is useful enough (at least yet), so most of the examples
+here are either with <a href="https://openai.com/index/chatgpt/">GPT-3.5</a> or <a href="https://openai.com/index/gpt-4o-mini-advancing-cost-efficient-intelligence/">GPT-4o
+mini</a>,
+since those where the models offered by free in ChatGPT.</p>
+<p>An addendum, I have some experience with <a href="https://github.com/features/copilot">GitHub
+Copilot</a> (another LLM, but this one runs
+inside your IDE or favorite text editor) in <code>$PREVIOUS_JOB</code>. But my experience
+with it is even more underwhelming than what I am going to describe in this
+post: it was basically really good for generating fixture for tests and between
+ok-ish to plain bad for everything else. Yes, that's would fit in a tweet (or
+xeet?).</p>
+<h2>The good</h2>
+<p><a href="https://chatgpt.com/share/c58a1432-2761-4954-acac-cade29942c34">Chat history</a>.</p>
+<blockquote>
+<p>Is there any way that I can pass a context for a net.conn to cancel its
+Read()?</p>
+</blockquote>
+<p>This is one of the good cases where ChatGPT felt to me that I was talking with
+an expert in Go. To start, I didn't even mention in my initial prompt that I
+was talking about Go, but it correctly inferred so. Also, the solution overview
+was great:</p>
+<blockquote>
+<ol>
+<li><strong>Use a separate goroutine</strong> to handle the context cancellation.</li>
+<li><strong>Set a deadline</strong> on the connection using <code>SetReadDeadline()</code> to unblock
+the <code>Read()</code> when the context is canceled.</li>
+</ol>
+</blockquote>
+<p>Before asking ChatGPT about this issue I had already coded my own naive
+solution that was something similar to this:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">foo</span><span class="p">(</span><span class="nx">ctx</span> <span class="nx">context</span><span class="p">.</span><span class="nx">Context</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// ...
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kd">struct</span><span class="p">{})</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">n</span> <span class="kt">int</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">err</span> <span class="kt">error</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">Read</span><span class="p">(</span><span class="nx">buf</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">done</span> <span class="o">&lt;-</span><span class="kd">struct</span><span class="p">{}{}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}()</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">select</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">ctx</span><span class="p">.</span><span class="nf">Done</span><span class="p">():</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">conn</span><span class="p">.</span><span class="nf">Close</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">ctx</span><span class="p">.</span><span class="nf">Err</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">done</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// ...
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
+</span></span></code></pre><p>Compared this solution with the one from ChatGPT:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">readWithContext</span><span class="p">(</span><span class="nx">ctx</span> <span class="nx">context</span><span class="p">.</span><span class="nx">Context</span><span class="p">,</span> <span class="nx">conn</span> <span class="nx">net</span><span class="p">.</span><span class="nx">Conn</span><span class="p">,</span> <span class="nx">buf</span> <span class="p">[]</span><span class="kt">byte</span><span class="p">)</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kd">struct</span><span class="p">{})</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">n</span> <span class="kt">int</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">err</span> <span class="kt">error</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1">// Start a goroutine to perform the read
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">Read</span><span class="p">(</span><span class="nx">buf</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">close</span><span class="p">(</span><span class="nx">done</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}()</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">select</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">ctx</span><span class="p">.</span><span class="nf">Done</span><span class="p">():</span> <span class="c1">// Context was canceled or timed out
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="c1">// Set a short deadline to unblock the Read()
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"> <span class="o">&lt;-</span><span class="nx">done</span> <span class="c1">// Wait for the read to finish
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">ctx</span><span class="p">.</span><span class="nf">Err</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">done</span><span class="p">:</span> <span class="c1">// Read finished successfully
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>The ChatGPT version is much better because:</p>
+<ol>
+<li>It doesn't close the connection socket allowing it to be reused</li>
+<li>It waits until the goroutine is finished to avoid leaks</li>
+<li>It closes the channel after it finishes</li>
+</ol>
+<p>Now, I don't claim to be a Go expert (far from it), but this was one of those
+cases where I felt that I was being guided by someone that is coding in Go for
+years.</p>
+<p>But it didn't end there, I asked:</p>
+<blockquote>
+<p>If I want to reuse the connection, do I need to reset the SetReadDeadline?</p>
+</blockquote>
+<p>Since in this particular case I wanted the underlying connection to be reused,
+and ChatGPT correctly amended the code:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">readWithContext</span><span class="p">(</span><span class="nx">ctx</span> <span class="nx">context</span><span class="p">.</span><span class="nx">Context</span><span class="p">,</span> <span class="nx">conn</span> <span class="nx">net</span><span class="p">.</span><span class="nx">Conn</span><span class="p">,</span> <span class="nx">buf</span> <span class="p">[]</span><span class="kt">byte</span><span class="p">)</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Same as before
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">select</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">ctx</span><span class="p">.</span><span class="nf">Done</span><span class="p">():</span> <span class="c1">// Context was canceled or timed out
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="c1">// Set a short deadline to unblock the Read()
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"> <span class="o">&lt;-</span><span class="nx">done</span> <span class="c1">// Wait for the read to finish
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Reset the deadline so the connection can be reused
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Time</span><span class="p">{})</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">ctx</span><span class="p">.</span><span class="nf">Err</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">done</span><span class="p">:</span> <span class="c1">// Read finished successfully
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Also the explanation on why this happens was good:</p>
+<blockquote>
+<p>When you set a read deadline with <code>conn.SetReadDeadline(time.Now())</code> to unblock
+the <code>Read()</code> call, this deadline remains in effect for future <code>Read()</code>
+operations. This means that if you attempt another read operation after this,
+it could immediately fail with a timeout error if the deadline is still in
+effect.
+To reuse the connection, you'll need to remove the deadline or set a new one.
+You can do this by calling <code>conn.SetReadDeadline(time.Time{})</code>, which clears
+any existing deadline.</p>
+</blockquote>
+<p>I had one last question that I kind already knew the answer:</p>
+<blockquote>
+<p>Do we need to defer the clearing?</p>
+</blockquote>
+<p>And ChatGPT correctly returned:</p>
+<blockquote>
+<p>Whether you need to defer the clearing of the read deadline depends on how
+your code is structured. If you want to ensure that the read deadline is
+always cleared after a context cancellation, even if the code panics or exits
+early, then deferring the <code>conn.SetReadDeadline(time.Time{})</code> call is a good
+idea.</p>
+</blockquote>
+<p>This whole interaction was one of the best ones I ever had in ChatGPT, one that
+it gave me an actual functional code with good explanation on what was
+happening. But still, it didn't talked at all about the gotcha of setting the
+read deadline and reusing the underlying connection, needing another prompt to
+give me this information.</p>
+<p>Also, there is one issue in ChatGPT solution though: we are discarding the
+values of the buffer once the context is done by returning <code>n = 0</code> instead of
+the number of bytes read. In this particular case this is what I wanted, but
+this is a possible issue that ChatGPT didn't talk.</p>
+<p>For comparison,
+<a href="https://stackoverflow.com/questions/61637359/how-to-use-context-context-with-tcp-connection-read">this</a>
+is the best that I got searching in both DuckDuckGo and Google, that is where I
+kind based my first solution on. I still not sure where ChatGPT could give me
+such a good answer for this question, because I just couldn't find anything
+remotely similar during my searches.</p>
+<h2>The amazing</h2>
+<p><a href="https://chatgpt.com/share/0c9a148f-4cfd-4b4e-aa84-7486e185125b">Chat history</a>.</p>
+<blockquote>
+<p>I want to write an extension to <a href="https://github.com/yuin/goldmark/">https://github.com/yuin/goldmark/</a> that allows
+me to rewrite <code>[link](../2024-07-30/post.md)</code> to
+<code>[link](https://kokada.capivaras.dev/slug)</code></p>
+</blockquote>
+<p>Here is the generated code:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">linkrewriter</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kn">import</span> <span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;fmt&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;path&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;strings&#34;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark/ast&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark/parser&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark/renderer&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark/util&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// LinkRewriter is the main struct for your extension
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">type</span> <span class="nx">LinkRewriter</span> <span class="kd">struct</span><span class="p">{}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// NewLinkRewriter returns a new instance of LinkRewriter
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="nf">NewLinkRewriter</span><span class="p">()</span> <span class="o">*</span><span class="nx">LinkRewriter</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="o">&amp;</span><span class="nx">LinkRewriter</span><span class="p">{}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// Extend will be called by Goldmark to add your extension
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="p">(</span><span class="nx">e</span> <span class="o">*</span><span class="nx">LinkRewriter</span><span class="p">)</span> <span class="nf">Extend</span><span class="p">(</span><span class="nx">m</span> <span class="nx">goldmark</span><span class="p">.</span><span class="nx">Markdown</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span><span class="p">.</span><span class="nf">Parser</span><span class="p">().</span><span class="nf">AddOptions</span><span class="p">(</span><span class="nx">parser</span><span class="p">.</span><span class="nf">WithASTTransformers</span><span class="p">(</span><span class="nx">util</span><span class="p">.</span><span class="nf">Prioritized</span><span class="p">(</span><span class="nx">e</span><span class="p">,</span> <span class="mi">0</span><span class="p">)))</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// Transform is the method that modifies the AST
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="p">(</span><span class="nx">e</span> <span class="o">*</span><span class="nx">LinkRewriter</span><span class="p">)</span> <span class="nf">Transform</span><span class="p">(</span><span class="nx">node</span> <span class="o">*</span><span class="nx">ast</span><span class="p">.</span><span class="nx">Document</span><span class="p">,</span> <span class="nx">reader</span> <span class="nx">text</span><span class="p">.</span><span class="nx">Reader</span><span class="p">,</span> <span class="nx">pc</span> <span class="nx">parser</span><span class="p">.</span><span class="nx">Context</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">ast</span><span class="p">.</span><span class="nf">Walk</span><span class="p">(</span><span class="nx">node</span><span class="p">,</span> <span class="kd">func</span><span class="p">(</span><span class="nx">n</span> <span class="nx">ast</span><span class="p">.</span><span class="nx">Node</span><span class="p">,</span> <span class="nx">entering</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">(</span><span class="nx">ast</span><span class="p">.</span><span class="nx">WalkStatus</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">!</span><span class="nx">entering</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">ast</span><span class="p">.</span><span class="nx">WalkContinue</span><span class="p">,</span> <span class="kc">nil</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">link</span><span class="p">,</span> <span class="nx">ok</span> <span class="o">:=</span> <span class="nx">n</span><span class="p">.(</span><span class="o">*</span><span class="nx">ast</span><span class="p">.</span><span class="nx">Link</span><span class="p">);</span> <span class="nx">ok</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nf">rewriteLink</span><span class="p">(</span><span class="nx">link</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">ast</span><span class="p">.</span><span class="nx">WalkContinue</span><span class="p">,</span> <span class="kc">nil</span>
+</span></span><span class="line"><span class="cl"> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// rewriteLink modifies the link URL
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="nf">rewriteLink</span><span class="p">(</span><span class="nx">link</span> <span class="o">*</span><span class="nx">ast</span><span class="p">.</span><span class="nx">Link</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">url</span> <span class="o">:=</span> <span class="nb">string</span><span class="p">(</span><span class="nx">link</span><span class="p">.</span><span class="nx">Destination</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">strings</span><span class="p">.</span><span class="nf">HasPrefix</span><span class="p">(</span><span class="nx">url</span><span class="p">,</span> <span class="s">&#34;../&#34;</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Modify this part according to your slug generation logic
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">slug</span> <span class="o">:=</span> <span class="nf">generateSlug</span><span class="p">(</span><span class="nx">url</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">link</span><span class="p">.</span><span class="nx">Destination</span> <span class="p">=</span> <span class="p">[]</span><span class="nb">byte</span><span class="p">(</span><span class="nx">fmt</span><span class="p">.</span><span class="nf">Sprintf</span><span class="p">(</span><span class="s">&#34;https://kokada.capivaras.dev/%s&#34;</span><span class="p">,</span> <span class="nx">slug</span><span class="p">))</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// generateSlug generates a slug from the given URL
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="nf">generateSlug</span><span class="p">(</span><span class="nx">url</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">string</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Assuming the slug is the last part of the URL without the extension
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nx">strings</span><span class="p">.</span><span class="nf">TrimSuffix</span><span class="p">(</span><span class="nx">path</span><span class="p">.</span><span class="nf">Base</span><span class="p">(</span><span class="nx">url</span><span class="p">),</span> <span class="nx">path</span><span class="p">.</span><span class="nf">Ext</span><span class="p">(</span><span class="nx">url</span><span class="p">))</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kn">import</span> <span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark/renderer/html&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">linkrewriter</span> <span class="s">&#34;path/to/your/linkrewriter&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">md</span> <span class="o">:=</span> <span class="nx">goldmark</span><span class="p">.</span><span class="nf">New</span><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">goldmark</span><span class="p">.</span><span class="nf">WithExtensions</span><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">linkrewriter</span><span class="p">.</span><span class="nf">NewLinkRewriter</span><span class="p">(),</span>
+</span></span><span class="line"><span class="cl"> <span class="p">),</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">goldmark</span><span class="p">.</span><span class="nf">WithRendererOptions</span><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">html</span><span class="p">.</span><span class="nf">WithHardWraps</span><span class="p">(),</span>
+</span></span><span class="line"><span class="cl"> <span class="p">),</span>
+</span></span><span class="line"><span class="cl"> <span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1">// Use `md.Convert` to convert your markdown to HTML as usual
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
+</span></span></code></pre><p>This one will need some context. <a href="https://github.com/yuin/goldmark/">Goldmark</a>,
+the Markdown renderer that <a href="https://kokada.dev/blog/making-a-blog-for-the-next-10-years">powers this
+blog</a>, does not
+have good examples or documentation (at least I didn't found neither).</p>
+<p>So I was not really hopeful I would get any answers in ChatGPT, but not only it
+put me in the correct path, the code was almost correct. It did had some unused
+and missing imports, and there were some compilation errors that were easily
+fixed. And when it registered the extension, it also added a
+<code>html.WithHardWraps()</code> renderer for no reason at all.</p>
+<p>But this is one of the experiences in LLM that most impressed me. I had no idea
+at all on how to solve this problem, and ChatGPT basically gave me the
+solution. A <a href="https://github.com/thiagokokada/blog/blob/3a2ea58a0638d1005617d25eabeae0626933db46/link_rewriter.go">modified version of the
+code</a>
+from this chat is still used to power this blog to this day, that also
+demonstrates that the code is not garbage (since now I understand what it does
+and I can even extend it).</p>
+<p>I am still not sure how the license situation of this code is though. Does
+licenses even make sense in AI generated code?</p>
+<h2>The bad</h2>
+<p><a href="https://chatgpt.com/share/95fcd777-b03c-4cfe-8d1d-12e53f5a4dfe">Chat history</a>.</p>
+<blockquote>
+<p>I want to configure VM options inside IntelliJ by project</p>
+</blockquote>
+<blockquote>
+<p>My project uses sbt, and I want to set this in a way that I can share with my
+colleagues</p>
+</blockquote>
+<blockquote>
+<p>I am using a build.sbt file, but IntelliJ is not loading it's JVM options and
+I need to set this up manually. I want to automate this</p>
+</blockquote>
+<p>This is an example of my most common interaction with ChatGPT: it generally
+gives some options that could work, but not in my specific case. So I start to
+ask for more information until it eventually starts to
+<a href="https://en.wikipedia.org/wiki/Hallucination_(artificial_intelligence)">hallucinate</a>.</p>
+<p>In this particular case, the hallucination was in:</p>
+<blockquote>
+<p>The sbt-idea-plugin can generate IntelliJ IDEA project files based on your
+SBT configuration, including JVM options. This allows you to ensure that
+IntelliJ loads the correct settings from the SBT configuration.</p>
+<p>Steps:</p>
+<ol>
+<li>Add the <code>sbt-idea-plugin</code> to your <code>project/plugins.sbt</code> file:</li>
+</ol>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="n">addSbtPlugin</span><span class="o">(</span><span class="s">&#34;com.github.mwz&#34;</span> <span class="o">%</span> <span class="s">&#34;sbt-idea&#34;</span> <span class="o">%</span> <span class="s">&#34;2.4.0&#34;</span><span class="o">)</span>
+</span></span></code></pre><ol start="2">
+<li>Run the following command in your terminal to regenerate IntelliJ IDEA
+project files:</li>
+</ol>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="go">sbt gen-idea
+</span></span></span></code></pre></blockquote>
+<p>Yes, there is a
+<a href="https://github.com/JetBrains/sbt-idea-plugin"><code>sbt-idea-plugin</code></a>, but no, it
+doesn't generate project files based in my SBT configuration. It is not even
+from the repository that it is supposed to be pointing too.</p>
+<p>I will just not say that this interaction was a waste of time because some of
+the other ideas can be applied, but this was the kind of case where I ended up
+just being disappointed because the thing that seemed to be a possible solution
+for my problem ended up not existing at all.</p>
+<h2>The ugly</h2>
+<p>There are lots of examples where ChatGPT just plain disappointed me. Here is a
+few:</p>
+<blockquote>
+<p>What is the language that is a fork of Go that has extra features like map?</p>
+</blockquote>
+<p><a href="https://chatgpt.com/share/2b854bbd-d376-4049-97fe-b47321c1ef07">Chat history</a>.</p>
+<p>This is one of those cases where I saw something once and was trying to
+remember. ChatGPT just gave me lots of answers that were not a fork of Go
+(<a href="https://vlang.io/">V</a>, <a href="https://github.com/gluon-lang/gluon">Gluon</a>,
+<a href="https://www.ponylang.io">Pony</a>), hallucinated a programming language (Gomini),
+and said that <a href="https://ziglang.org/">Zig</a> is focused in STEM.</p>
+<p>By the way, I eventually remember what the language was:
+<a href="https://goplus.org/">Go+</a>. To be fair with ChatGPT, I misremembered that the
+Go+ had map (as the <a href="https://en.wikipedia.org/wiki/Map_(higher-order_function)">high-order
+function</a>, not a
+hashmap that both Go and Go+ have). But still, Go+ explicit announces that it
+is a language for STEM everywhere in their website, and even them ChatGPT
+couldn't answer.</p>
+<blockquote>
+<p>In IntelliJ, I need to pass some VM options to the run configuration for my
+application to run tests, e.g.:</p>
+<pre><code>--add-exports=java.base/sun.security.x509=ALL-UNNAMED
+--add-opens=java.base/sun.security.ssl=ALL-UNNAMED
+-Dconfig.resource=api.test.conf
+</code></pre>
+<p>However, the <code>api.test.conf</code> may be <code>jobs.api.conf</code> or something else
+depending on the subproject I am running inside Idea. Can I parametrize this
+in some way?</p>
+</blockquote>
+<p><a href="https://chatgpt.com/share/aa9bd051-65de-49d9-8d56-0e28de94722c">Chat history</a></p>
+<p>So quick answer: you can't. IntelliJ macros are not powerful enough for this.
+ChatGPT itself said so when I asked about the IntelliJ macros
+<a href="https://chatgpt.com/share/7a057bf5-bcec-458b-9432-98e3f551ad28">directly</a>.</p>
+<p>But in this particular case, ChatGPT happily said &quot;yes, you can parameterize VM
+options in IntelliJ IDEA to make them more flexible depending on the subproject
+or other context&quot;. Thanks for wasting my time, I guess.</p>
+<h2>Conclusion</h2>
+<p>I do think that LLMs, in particular ChatGPT since this is the one I have more
+experience with, are improving. But still, if there is anything that I
+concluded after putting all those experiences in a post is that you still need
+someone that knows at least as much about whatever you're asking ChatGPT to
+actually validate the answer.</p>
+<p>Not only because LLMs hallucinates a lot, but also because even in the &quot;good&quot;
+example the LLM needed extra input to figure out about the possible drawback of
+the solution. The only case where I felt that ChatGPT outsmarted me was the
+&quot;amazing&quot; case, but this was literally the only example that I could find in
+all my chat history with ChatGPT that was like this.</p>
+<p>So yes, at least for now I still don't think AI will be our overlords. Maybe
+someday.</p></summary></entry><entry><title>Making a blog for the next 10 years</title><link href="https://kokada.dev/blog/making-a-blog-for-the-next-10-years/" rel="alternate"/><published>2024-08-24T00:00:00+00:00</published><id>https://kokada.dev/blog/making-a-blog-for-the-next-10-years/</id><summary type="html"><p>So one thing that I realise after starting writing this blog is that I care
+more about it than some of my other projects. For some reason or another I want
+to make sure that this blog will continue with me for a long time. This is one
+of the reasons why I use <a href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform">GitHub as mirror
+blog</a> and why I
+created a <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">bunch of
+automation</a>
+to make sure I never forget how to maintain this blog.</p>
+<p>Still, there are a bunch of dependencies that I need to make sure they're
+working so I can publish blog posts:</p>
+<ul>
+<li>Markdown</li>
+<li>A text editor</li>
+<li>Hosting and blog platform</li>
+<li>Shell script and
+<a href="https://kokada.dev/blog/abusing-makefiles-for-fun-and-profit">Makefile</a></li>
+<li>Go toolchain and modules</li>
+</ul>
+<p>Let's start with the most important one: the texts themselves, they're all
+written in <a href="https://www.markdownguide.org/">Markdown</a>. The nice thing about
+Markdown is that it is just plain text files with some special notation that
+allow you to format text, but the text itself is still legible even if you have
+no support to render Markdowns. So it means as long as I can read a plain text
+file, I can still read the posts, no issue there. Closely related issue here is
+the text editor, but the nice thing about Markdown is that if tomorrow I decide
+to change from <code>neovim</code> to, say, <a href="https://zed.dev/">Zed</a>, I can still write it
+Markdown files without issue. I also use a standardised Markdown implementation
+called <a href="https://commonmark.org/">CommonMark</a>, that fixes a bunch of ambiguities
+of the original Markdown spec.</p>
+<p>The next point is the host (<a href="capivaras.dev">capivaras.dev</a>) and the blog
+platform (<a href="https://github.com/mataroa-blog/mataroa">Mataroa</a>). One of the nice
+things about Mataroa is that it avoids platform lock-in by having multiple ways
+to <a href="https://mataroa.blog/export/">export your posts</a>. I could export everything
+to <a href="https://gohugo.io/">Hugo</a>, for example, and serve the blog from <a href="https://pages.github.com/">GitHub
+Pages</a>.</p>
+<p>This is especially nice consider how small <a href="capivaras.dev">capivaras.dev</a> is,
+so it is good to know that if I eventually have issues I could move to
+somewhere else. I also have an e-mail backup every month with all posts made
+(another <a href="https://hey.mataroa.blog/blog/monthly-auto-exports-via-email/">Mataroa
+feature</a>), and
+of course I have a <a href="https://github.com/thiagokokada/blog">Git repo</a> that also
+acts as a <a href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform">mirror of this
+blog</a>. So I would
+say the chance of losing access to the content is slim.</p>
+<p>One other issue is the URL of the posts that are indexed in many different
+places, like <a href="https://news.ycombinator.com/">Hacker News</a>,
+<a href="https://lobste.rs/">Lobte.rs</a>, etc. This is why I finally decide to bite the
+bullet and purchase a proper domain, and this website should now be available
+in <a href="kokada.dev">kokada.dev</a>. This means that in my eventual exit from
+<a href="capivaras.dev">capivaras.dev</a>, I can just point my new blog location to my own
+domain if needed (it is not as easy since I also need to preserve the post
+URLs, but shouldn't be difficult to fix this if I ever need to do so).</p>
+<p>Now for the tools that I use to publish from the original Markdown files to
+everything else. Let's start with shell script(s) and Makefile: I decided that
+they're less of an issue if they eventually stop working: they're only used to
+make my life easier, but I can still publish files manually if needed. Still, I
+tried to rewrite both the
+<a href="https://github.com/thiagokokada/blog/commit/a0d421ca90f3da059998295c5e3c6c7a6a3f0688">shell</a>
+and
+<a href="https://github.com/thiagokokada/blog/commit/074580065b21fbdaf930aa51968e69f015d49505">Makefile</a>
+to avoid GNUisms, so in the eventual case that I decide to e.g.: stop using a
+GNU/Linux system like NixOS and use a *BSD system instead, I am covered.</p>
+<p>In other projects I would probably add a <code>shell.nix</code> file and add the GNU
+versions of the tools that I am using, but I am trying to avoid Nix while
+building this blog as much as I can, mainly because it is not available
+everywhere (e.g.: *BSD systems).</p>
+<p>Go is the more important part: the tooling used to <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">publish this blog is
+written in
+Go</a>. Go
+is a good language when you want to ensure that things will work for a long
+time because of its <a href="https://go.dev/blog/compat">backwards compatibility
+guarantee</a>. Also I don't expect Google dropping Go
+development soon, but even if this happen (<a href="https://killedbygoogle.com/">&quot;killed by
+Google&quot;</a> is a thing after all), it is very likely
+some other group or company would adopt its development quickly, considering
+<a href="https://www.tiobe.com/tiobe-index/go/">how popular the language</a> is.</p>
+<p>However, the <a href="https://github.com/thiagokokada/blog/blob/main/go.mod">Go
+modules</a> that I depend
+are another story:</p>
+<ul>
+<li><a href="https://github.com/elliotchance/orderedmap/">elliotchance/orderedmap</a>: an
+ordered map implementation that I use until Go adds it in the <a href="https://kokada.dev/blog/an-unordered-list-of-things-i-miss-in-go">standard
+library</a></li>
+<li><a href="https://github.com/gorilla/feeds">gorilla/feeds</a>: a RSS generator library</li>
+<li><a href="https://github.com/gosimple/slug">gosimple/slug</a>: a
+<a href="https://developer.mozilla.org/en-US/docs/Glossary/Slug">slug</a> generator
+library</li>
+<li><a href="https://github.com/yuin/goldmark">yuin/goldmark</a>: a CommonMark parser and
+renderer</li>
+<li><a href="https://github.com/teekennedy/goldmark-markdown">teekennedy/goldmark-markdown</a>:
+a renderer for Goldmark to render back to Markdown (since Goldmark itself
+doesn't have this capacity)</li>
+</ul>
+<p>In common for all those modules are that they're clearly small projects
+maintained mostly by one developer. They're all very good, don't get me wrong,
+but they're still an reliability issue in the future. There is no guarantee
+those repositories will not be deleted tomorrow, for example.</p>
+<p>Yes, <a href="https://proxy.golang.org/">Go Proxy</a> exist, but from what I understood
+reading its page is that while it caches modules contents, this is not
+guarantee:</p>
+<blockquote>
+<p>proxy.golang.org does not save all modules forever. There are a number of
+reasons for this, but one reason is if proxy.golang.org is not able to detect
+a suitable license. In this case, only a temporarily cached copy of the
+module will be made available, and may become unavailable if it is removed
+from the original source and becomes outdated. The checksums will still
+remain in the checksum database regardless of whether or not they have become
+unavailable in the mirror.</p>
+</blockquote>
+<p>This is why this is the first project that made sense to me to use <a href="https://go.dev/ref/mod#go-mod-vendor"><code>go mod vendor</code></a>. Now I have a copy of the source
+code of all modules inside the
+<a href="https://github.com/thiagokokada/blog/tree/0b97630d6b30551ffe05b5d8124305b1065f729d/vendor">vendor</a>
+directory in the repository, avoiding the risks I commented above. This allows
+me to ensure that this blog will still be publishable in the future, as long as
+I have a working Go toolchain (and Go toolchain makes this
+<a href="https://kokada.dev/blog/quick-bits-go-automatically-downloads-a-newer-toolchain-if-needed">easy</a>).</p>
+<p>There are a few other things that can bitrot this blog, for example links going
+nowhere. I always try to use
+<a href="https://en.wikipedia.org/wiki/Permalink">permalinks</a> when it makes sense, but
+the only actual way to ensure those links would work in the future would be to
+point them to <a href="https://archive.org/">archive.org</a> (but even archive.org may not
+exist forever). Maybe something to fix in the future, hope not in the far
+future, before things start to break.</p></summary></entry><entry><title>An unordered list of hidden gems inside NixOS</title><link href="https://kokada.dev/blog/an-unordered-list-of-hidden-gems-inside-nixos/" rel="alternate"/><published>2024-08-21T00:00:00+00:00</published><id>https://kokada.dev/blog/an-unordered-list-of-hidden-gems-inside-nixos/</id><summary type="html"><p>After using <a href="https://nixos.org/">NixOS</a> for the last 5+ years as my main OS, I
+end up with a <a href="https://github.com/thiagokokada/nix-configs/">configuration</a>
+with many things that are interesting for one reason or another, but it is not
+listed anywhere (well, except if you are the kind of person that reads <code>man 5 configuration.nix</code> or the release notes in every release).</p>
+<p>So kind in the same spirit as my <a href="https://kokada.dev/blog/an-unordered-list-of-things-i-miss-in-go">list of things that I miss in
+Go</a>, here is
+a list of modules that I find neat in NixOS and are not default already. Again,
+the list is unordered since this makes it easier to update in the future if I
+find something else, but also I don't want to think too hard about an order
+here.</p>
+<p>With all above, let's start.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/6afb255d976f85f3359e4929abd6f5149c323a02/nixos/modules/services/networking/nftables.nix"><code>networking.nftables</code></a></h2>
+<p><a href="https://www.nftables.org/">nftables</a> is, accordingly to Wikipedia:</p>
+<blockquote>
+<p>nftables is a subsystem of the Linux kernel providing filtering and
+classification of network packets/datagrams/frames.</p>
+</blockquote>
+<p>It is basically a replacement of the venerable
+<a href="https://en.wikipedia.org/wiki/Iptables">iptables</a>, that still exist and is the
+default program to configure the famous <code>networking.firewall</code>, the declarative
+<a href="https://wiki.nixos.org/wiki/Firewall">Firewall</a> that NixOS enable by default.</p>
+<p>To enable, it is simple, just add to your configuration:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">networking</span><span class="o">.</span><span class="n">nftables</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>And thanks to the fact that NixOS's Firewall is declarative, everything should
+still work as expect: any service that you set <code>openFirewall = true</code> will still
+have its ports open, if you set <code>networking.firewall.allowPing = false</code> it will
+still disable pings like before, etc.</p>
+<p>If you look at the documentation of the above option, you will find the
+following warning:</p>
+<blockquote>
+<p>Note that if you have Docker enabled you will not be able to use nftables
+without intervention. Docker uses iptables internally to setup NAT for
+containers. This module disables the ip_tables kernel module, however Docker
+automatically loads the module. Please see
+<a href="https://github.com/NixOS/nixpkgs/issues/24318#issuecomment-289216273">https://github.com/NixOS/nixpkgs/issues/24318#issuecomment-289216273</a> for
+more information.</p>
+</blockquote>
+<p>I don't use Docker (switched to Podman instead for quite a long time), so I
+don't know how bad the situation is. Also keep in mind that <code>nftables</code> does
+offer <code>iptables-compat</code> for compatibility with old iptables scripts, so it is
+most likely Docker doing something weird here.</p>
+<p>Now, the actual advantage from the user here is not clear: the main advantage
+from my point of view (and the reason I used to use in other distros like Arch)
+is the improved syntax, however if you are using the declarative NixOS's
+Firewall you are not interacting with either <code>iptables</code> or <code>nftables</code> directly
+anyway. <code>nftables</code> is supposed to be more efficient, but not sure most users
+will care about this.</p>
+<p>However if you are the kind of person that needs custom rules, switching to
+<code>nftables</code> does bring a few benefits, including
+<code>networking.nftables.checkRuleset</code> (enabled by default), that checks if your
+ruleset has syntax errors during build time. Really valuable to avoid issues
+only after switch.</p>
+<p>Anyway, this is one of those options that I think it should be the default for
+a long time, since most of the new development in NixOS firewall seems to be
+focusing <code>nftables</code> for a while.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/877d19523edcac81b167e8fd716ad2658da2adca/nixos/modules/system/activation/switchable-system.nix#L30-L38"><code>system.switch.enableNg</code></a></h2>
+<p><a href="https://github.com/NixOS/nixpkgs/pull/308801">This one</a> I just discovered
+today, but it has been available for a while (~2 months if you're using
+<code>nixos-unstable</code>). Finally someone is rewriting
+<a href="https://github.com/NixOS/nixpkgs/blob/b1eff03c35aa7c90ab3a4d9f6ef297dae5fba37b/nixos/modules/system/activation/switch-to-configuration.pl"><code>switch-to-configuration.pl</code></a>,
+the Perl script that is called everytime you run <code>nixos-rebuild switch</code>.</p>
+<p>Now, I am not one of those &quot;rewrite in Rust&quot; zealots, but in this case this is
+definitely worth it: <code>switch-to-configuration.pl</code> is one of those pieces of
+code in NixOS that most people avoid touching at the fear of breaking
+something. There is a reason why
+<a href="https://github.com/NixOS/nixpkgs/commit/eeb2588a59c938042b74183ce1da7052a6ef7e59"><code>nixos-rebuild</code></a>
+is as convoluted as it is, because even if it is a messy shell script, most
+people preferred to workaround issues from the <code>switch-to-configuration.pl</code>
+inside it than trying to understand the mess that <code>switch-to-configuration.pl</code>
+is.</p>
+<p>Trying this one is easy:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">system</span><span class="o">.</span><span class="n">switch</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">enable</span> <span class="o">=</span> <span class="no">false</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">enableNg</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Yes, you need to explicit set <code>system.switch.enable = false</code>, since the default
+is <code>true</code>.</p>
+<p>By the way, what is the reason you would want to set <code>system.switch.enable = false</code> before the <code>enableNg</code> appeared you ask? For systems that are immutable
+and updated by e.g.: image upgrades instead of modifying root.</p>
+<p>Enabling <code>switch-to-configuration-ng</code> right now is mostly for testing purposes,
+but one of the advantages that I saw is that system switches are (slightly)
+faster:</p>
+<pre><code>$ hyperfine &quot;sudo nixos-rebuild switch&quot; # switch-to-configuration.pl
+Benchmark 1: sudo nixos-rebuild switch
+ Time (mean ± σ): 3.576 s ± 0.035 s [User: 0.004 s, System: 0.014 s]
+ Range (min … max): 3.522 s … 3.645 s 10 runs
+</code><p><code>$ hyperfine &quot;sudo nixos-rebuild switch&quot; # switch-to-configuration-ng
+Benchmark 1: sudo nixos-rebuild switch
+Time (mean ± σ): 3.394 s ± 0.080 s [User: 0.004 s, System: 0.013 s]
+Range (min … max): 3.325 s … 3.608 s 10 runs
+</code></p></pre><p></p>
+<p>But yes, the difference is not enough to make a significant impact, and it is
+not the objective anyway. The real reason for the rewrite is to make it easier
+to collaborate. I hope one day we also have someone brave enough to rewrite the
+<code>nixos-rebuild</code> script in something saner.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/cce9aef6fd8f010d288d685b9d2a38f3b6ac47e9/nixos/modules/system/boot/systemd/initrd.nix"><code>boot.initrd.systemd</code></a></h2>
+<p>A quick recap on how a modern Linux distro generally boots: the first thing
+that the bootloader (say <a href="https://www.gnu.org/software/grub/">GRUB</a> or
+<a href="https://systemd.io/BOOT/">systemd-boot</a>) loads is <code>initrd</code> (<em>initial
+ramdisk</em>), a small image that runs from RAM and includes the Linux kernel and
+some utilities that are responsible for setting up the main system. For
+example, one of the responsibilities of the <code>initrd</code> is to mount the disks and
+start init system (<code>systemd</code>).</p>
+<p>It may surprising that this <code>initrd</code> image does <strong>not</strong> generally include
+<code>systemd</code>. Traditionally <code>initrd</code> is composed by a bunch of shell scripts and a
+minimal runtime (e.g.: <a href="https://www.busybox.net/">busybox</a>), however <code>systemd</code>
+can also do this job since a long time ago. It is just the role of the distros
+to integrate <code>systemd</code> inside the <code>initrd</code>.</p>
+<p>This is what <code>boot.initrd.systemd</code> does: enable <code>systemd</code> inside the <code>initrd</code>.
+It make a few subtle changes:</p>
+<ul>
+<li>If you are using <a href="https://wiki.nixos.org/wiki/Full_Disk_Encryption">Full Disk Encryption via
+LUKS</a>, you will get a
+different password prompt at login</li>
+<li>You will get <code>initrd</code> time information if using <code>systemd-analyze</code> to measure
+boot time
+<ul>
+<li>You can get even more information (bootloader) if you also use
+<code>systemd-boot</code></li>
+</ul>
+</li>
+<li>You will also get <code>systemd</code> style status about services during <code>initrd</code> (not
+only afterwards)</li>
+</ul>
+<p>But I think the main reason is that since <code>systemd</code> is event-driven, it should
+make boot more reliable, especially in challenging situations (like booting
+from network). I can't say that I have any system like this to test if it is
+actually more reliable or not, but I don't remember having any issues since I
+set <code>boot.initrd.systemd.enable = true</code>, so there is that.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/b4a09f1f9d1599478afadffa782a02690550447c/pkgs/development/libraries/pipewire/default.nix"><code>services.pipewire</code></a></h2>
+<p>If there is something in that list that has a good chance that you're using
+already, it is this one, especially if you're using
+<a href="https://wayland.freedesktop.org/">Wayland</a>. Still, I think it is interesting
+to include in this list since <a href="https://www.pipewire.org/">PipeWire</a> is great.</p>
+<p>The experience with PipeWire until now for me was seamless: I never had any
+issues with it, all my applications still work exactly as it always worked. I
+also didn't had any issues with
+<a href="https://www.freedesktop.org/wiki/Software/PulseAudio/">PulseAudio</a> for a
+while, but I still remember when I first tried PulseAudio during the 0.x in
+Fedora and having tons of issues. So bonus points for PipeWire developers for
+polishing the experience of enough that most people will feel no difference.</p>
+<p>To enable PipeWire, I would recommend:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">services</span><span class="o">.</span><span class="n">pipewire</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">alsa</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pulse</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># jack.enable = true;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="n">security</span><span class="o">.</span><span class="n">rtkit</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This enables both ALSA and PulseAudio emulation support in PipeWire for maximum
+compatibility with desktop applications (you can also enable
+<a href="https://jackaudio.org/"><code>jack</code></a> if you use professional audio applications).
+It also enables <a href="https://github.com/heftig/rtkit"><code>rtkit</code></a>, allowing PipeWire
+to get (soft) realtime, helping avoiding cracks during high CPU load.</p>
+<p>I also recommend taking a look at the <a href="https://wiki.nixos.org/wiki/PipeWire">Wiki
+article</a>, that has multiple interesting
+configurations that can be added for low-latency setups or improved codecs for
+Bluetooth devices.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/c9ec8289781a3c4ac4dd5c42c8d50dd65360e79c/nixos/modules/services/networking/networkmanager.nix#L264-L271"><code>networking.networkmanager.wifi.backend = &quot;iwd&quot;</code></a></h2>
+<p>There is a good change that you're using
+<a href="https://www.networkmanager.dev/"><code>NetworkManager</code></a> to manage network,
+especially for Wi-Fi. And if that is the case, I can't recommend enough
+changing the backend from the default <code>wpa_supplicant</code> to
+<a href="https://iwd.wiki.kernel.org/"><code>iwd</code></a>.</p>
+<p>If you think that your Wi-Fi takes a long time to connect/re-connect, it may be
+because <code>wpa_supplicant</code>. <code>iwd</code> seems much more optimised in this regard, and
+since switching to it I never felt that my Wi-Fi was worse than other OSes (and
+generally slightly better than Windows, but keep in mind that this is a
+non-scientific comparison).</p>
+<p>Not saying that I never had Wi-Fi issues since switching to <code>iwd</code>, however
+switching back to <code>wpa_supplicant</code> in those cases never fixed the issue (it was
+the same or worse), so I assume either bad hardware or drivers in those cases.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/d5badef1e0416160298aad6dd8604eaf8b6e7e52/nixos/modules/system/boot/tmp.nix#L25-L32"><code>boot.tmp.useTmpfs</code></a></h2>
+<p><em>Added in 2024-08-22</em></p>
+<p>Most Linux distro nowadays mount <code>/tmp</code> inside
+<a href="https://en.wikipedia.org/wiki/Tmpfs">tmpfs</a>, storing the files inside RAM (and
+making them actually temporary, e.g.: does not persist between reboots). There
+is a <a href="https://lwn.net/Articles/499410/">long discussion</a> whether this makes
+sense or not, but it is a fact that using <code>/tmp</code> as an storage for small files
+generally makes sense.</p>
+<p>However, NixOS still stores <code>/tmp</code> inside <code>/</code> by default. The main reason for
+this is because Nix, by default, still builds everything in <code>TMPDIR</code> (that
+defaults to <code>/tmp</code> if not set). To fix the situation you can do:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">boot</span><span class="o">.</span><span class="n">tmp</span><span class="o">.</span><span class="n">useTmpfs</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">systemd</span><span class="o">.</span><span class="n">services</span><span class="o">.</span><span class="n">nix-daemon</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">environment</span><span class="o">.</span><span class="n">TMPDIR</span> <span class="o">=</span> <span class="s2">&#34;/var/tmp&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This ensures that Nix will build in <code>/var/tmp</code>, that is the temporary directory
+for large files.</p>
+<p>If you don't want to use <code>/tmp</code> inside tmpfs for some reason, I recommend at
+least setting <code>boot.tmp.cleanOnBoot = true</code>. This is to avoid issues with e.g.:
+mistakenly writing a program that depends in <code>/tmp</code> being persistent, because
+this is the behavior that most other distros expects.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/68142254d20256e617f596a5d50f9950f98fa36a/nixos/modules/config/zram.nix"><code>zramSwap</code></a></h2>
+<p><em>Added in 2024-08-22</em></p>
+<p>Have a system with small amounts of RAM? <del>You can download more RAM for free,
+just click this <a href="https://downloadmoreram.com/">link</a>.</del> Well, just kidding, but
+you can actually improve RAM usage by compressing it. This is what
+<a href="https://en.wikipedia.org/wiki/Zram"><code>zram</code></a> does: it will create a block
+device using part of your RAM that will be compressed.</p>
+<p>While this means that whatever is in the compressed part can't be used as-is
+(it needs to be decompressed first), it means you can store a lot more
+information. And since RAM is much faster than disk, this generally is a good
+trade-off. It is still recommended that you have some swap space though, e.g.:
+to swap pages that are unused.</p>
+<p>To enable it, you can do:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">zramSwap</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">algorithm</span> <span class="o">=</span> <span class="s2">&#34;zstd&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>You can play a little with the <code>zramSwap.algorithm</code> parameter, but I recommend
+either <code>lz4</code> or <code>zstd</code>. It is important for the compression algorithm to be
+fast, since you probably want to minimise CPU usage. Well, unless you have a
+very good CPU and small amounts of RAM, them it may make sense to use an
+algorithm that compress better but uses more CPU.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/5356420466c4d7901b63acc5e337c5bf30573f8a/nixos/modules/services/misc/fstrim.nix"><code>services.fstrim</code></a></h2>
+<p><em>Added in 2024-08-22</em></p>
+<p>Do you have a SSD? If so, you probably want to
+<a href="https://en.wikipedia.org/wiki/Trim_(computing)">trim</a> it regularly to keep a
+good performance. This should be as easy as:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">services</span><span class="o">.</span><span class="n">fstrim</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>One caveat though: if you are using Full Disk Encryption with LUKS, you also
+need to enable <code>boot.initrd.luks.devices.&lt;name&gt;.allowDiscards</code>, otherwise
+<code>fstrim</code> will not work. The reason that this is not enabled by default is
+because there are some <a href="https://asalor.blogspot.com/2011/08/trim-dm-crypt-problems.html">security
+implications</a>.
+It shouldn't be an issue for most people, but if you are paranoid please assess
+your risks first.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/e83fc891118e5e5660ccca000040e33b0a0a3080/nixos/modules/system/boot/binfmt.nix"><code>boot.binfmt.emulatedSystems</code></a></h2>
+<p><em>Added in 2024-08-22</em></p>
+<p>This is one of my favorites. Do you want to have the power to run binaries from
+other architectures like
+<a href="https://en.wikipedia.org/wiki/ARM_architecture_family">ARM</a> or
+<a href="https://en.wikipedia.org/wiki/RISC-V">RISC-V</a>? In NixOS it is easy:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">boot</span><span class="o">.</span><span class="n">binfmt</span><span class="o">.</span><span class="n">emulatedSystems</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;aarch64-linux&#34;</span> <span class="s2">&#34;riscv64-linux&#34;</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This will install a QEMU emulator for the target architectures, and configure
+<a href="https://en.wikipedia.org/wiki/Binfmt_misc"><code>binfmt</code></a> so that the kernel will
+automatically detect when a binary from another architecture is run,
+running it with the QEMU emulator instead.</p>
+<p>Now, keep in mind that you still need e.g.: libraries for the target
+architecture. However this is where the Nix magic comes in, you can easily
+compile something to another architecture as:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> uname -a
+</span></span><span class="line"><span class="cl"><span class="go">Linux sankyuu-nixos 6.10.3 #1-NixOS SMP PREEMPT_DYNAMIC Sat Aug 3 07:01:09 UTC 2024 x86_64 GNU/Linux
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="gp">$</span> <span class="nb">cd</span> nixpkgs
+</span></span><span class="line"><span class="cl"><span class="gp">$</span> nix build .#hello --system aarch64-linux
+</span></span><span class="line"><span class="cl"><span class="gp">$</span> file ./result/bin/hello
+</span></span><span class="line"><span class="cl"><span class="go">./result/bin/hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically linked, interpreter /nix/store/kz7xglxzhad64v667wwpn8vrxhjwcbna-glibc-2.39-52/lib/ld-linux-aarch64.so.1, for GNU/Linux 3.10.0, not stripped
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="gp">$</span> ./result/bin/hello
+</span></span><span class="line"><span class="cl"><span class="go">Hello, world!
+</span></span></span></code></pre><p>And since the binary will be linked with the libraries from the target
+architecture, everything works as expect.</p>
+<p>You also need to temper your expectations: QEMU emulation is slow. It is
+sufficient fast to build small programs, but if you need to build something
+bigger, I would recommend you to do it via <a href="https://kokada.dev/blog/building-static-binaries-in-nix">cross-compilation
+instead</a>.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/d9cf6ea6f809b862b73766705bdadb1236eeeff8/nixos/modules/services/system/dbus.nix#L40-L50"><code>services.dbus.implementation = &quot;broker&quot;</code></a></h2>
+<p><em>Added in 2024-08-22</em></p>
+<p>Someone in
+<a href="https://lobste.rs/s/ymmale/unordered_list_hidden_gems_inside_nixos#c_dz1hck">Lobste.rs</a>
+remembered me of this gem: <a href="https://github.com/bus1/dbus-broker">dbus-broker</a>,
+a high performance implementation of
+<a href="https://en.wikipedia.org/wiki/D-Bus">D-Bus</a>.</p>
+<p>For those who doesn't know, D-Bus is the <a href="https://en.wikipedia.org/wiki/Inter-process_communication">Inter-Process
+Communication</a>
+protocol used mostly in Linux desktop. And distros like
+<a href="https://archlinux.org/news/making-dbus-broker-our-default-d-bus-daemon/">Arch</a>
+and
+<a href="https://fedoraproject.org/wiki/Changes/DbusBrokerAsTheDefaultDbusImplementation">Fedora</a>
+already use it to default, so there aren't lots of reason to not use it.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/6afb255d976f85f3359e4929abd6f5149c323a02/nixos/modules/services/hardware/irqbalance.nix"><code>services.irqbalance</code></a></h2>
+<p><em>Added in 2024-08-23</em></p>
+<p>Here is one that I have no experience but got curious after this comment in
+<a href="https://lobste.rs/s/ymmale/unordered_list_hidden_gems_inside_nixos#c_aghpwy">Lobte.rs</a>:</p>
+<blockquote>
+<p>One more option to add is maybe <code>services.irqbalance.enable</code>. For my old
+laptop it’s a life savior: no more freezes of the DE or video playback during
+heavy operations like e.g. compilation.</p>
+</blockquote>
+<p>Never tried it before but will give a try!</p></summary></entry><entry><title>Quick bits: using forks with Go modules</title><link href="https://kokada.dev/blog/quick-bits-using-forks-with-go-modules/" rel="alternate"/><published>2024-08-20T00:00:00+00:00</published><id>https://kokada.dev/blog/quick-bits-using-forks-with-go-modules/</id><summary type="html"><p>There are 2 types of blog posts: the ones you write for others, and the ones
+that you write for yourself. This blog post is the latter kind. What I am going
+to talk here is probably something most people know, but I didn't, and the
+documentation is all scattered in the internet. So I am writing mostly to
+remember myself, in future, if I have the same kind of issue what I need to do.</p>
+<p>The context: <a href="https://mataroa.blog/">Mataroa</a>, the blog platform
+<a href="https://capivaras.dev">capivaras.dev</a> is hosted on, relies in
+<a href="https://python-markdown.github.io/">python-markdown</a>, predates
+<a href="https://commonmark.org/">CommonMark</a> specification and as such, has some
+incompatibilities. One of those incompatibilities with CommonMark is the way
+sub lists are handled. From the documentation:</p>
+<blockquote>
+<p>The syntax rules clearly state that when a list item consists of multiple
+paragraphs, “each subsequent paragraph in a list item must be indented by
+either 4 spaces or one tab” (emphasis added). However, many implementations
+do not enforce this rule and allow less than 4 spaces of indentation. The
+implementers of Python-Markdown consider it a bug to not enforce this rule.</p>
+</blockquote>
+<p>CommonMark <a href="https://spec.commonmark.org/0.31.2/#lists">relax those
+restrictions</a>, allowing a sublist to
+be defined with just 2 spaces of indentation.</p>
+<p>So I have automated all posts from this blog <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">using
+Go</a> and
+a CommonMark renderer called <a href="https://github.com/yuin/goldmark/">Goldmark</a>. I
+them re-render the Markdown to Mataroa using a <a href="https://github.com/teekennedy/goldmark-markdown">Markdown
+renderer</a> before publising to
+<a href="https://capivaras.dev">capivaras.dev</a>, because this allow me to do some
+transformations in the original Markdown. It mostly works fine except for sub
+lists, thanks to the fact that the Markdown renderer I am using renders sub
+lists with 2 spaces.</p>
+<p>The only reason sub lists are working right now is because
+<a href="https://gluer.org/">@ratsclub</a> fixed this issue in the fork that
+<a href="https://capivaras.dev">capivaras.dev</a> runs. But I want to be compatible with
+the official instance if I ever need to migrate.</p>
+<p>The solution? Let's fix this in a
+<a href="https://github.com/teekennedy/goldmark-markdown/pull/21">PR</a>. However now that
+I have code to fix the issue, how can I use it without waiting upstream to
+merge my code?</p>
+<p>If you are using Go modules it is easy, you just need to use the <a href="https://go.dev/ref/mod#go-mod-file-replace"><code>replace</code>
+directive</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="nx">module</span> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">thiagokokada</span><span class="o">/</span><span class="nx">blog</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="k">go</span> <span class="mf">1.23</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">require</span> <span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">elliotchance</span><span class="o">/</span><span class="nx">orderedmap</span><span class="o">/</span><span class="nx">v2</span> <span class="nx">v2</span><span class="mf">.4.0</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">gorilla</span><span class="o">/</span><span class="nx">feeds</span> <span class="nx">v1</span><span class="mf">.2.0</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">gosimple</span><span class="o">/</span><span class="nx">slug</span> <span class="nx">v1</span><span class="mf">.14.0</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">teekennedy</span><span class="o">/</span><span class="nx">goldmark</span><span class="o">-</span><span class="nx">markdown</span> <span class="nx">v0</span><span class="mf">.3.0</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">yuin</span><span class="o">/</span><span class="nx">goldmark</span> <span class="nx">v1</span><span class="mf">.7.4</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">yuin</span><span class="o">/</span><span class="nx">goldmark</span><span class="o">-</span><span class="nx">highlighting</span> <span class="nx">v0</span><span class="mf">.0.0</span><span class="o">-</span><span class="mi">20220208100518</span><span class="o">-</span><span class="mi">594</span><span class="nx">be1970594</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">require</span> <span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">alecthomas</span><span class="o">/</span><span class="nx">chroma</span> <span class="nx">v0</span><span class="mf">.10.0</span> <span class="c1">// indirect
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">dlclark</span><span class="o">/</span><span class="nx">regexp2</span> <span class="nx">v1</span><span class="mf">.11.4</span> <span class="c1">// indirect
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">gosimple</span><span class="o">/</span><span class="nx">unidecode</span> <span class="nx">v1</span><span class="mf">.0.1</span> <span class="c1">// indirect
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nx">replace</span> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">teekennedy</span><span class="o">/</span><span class="nx">goldmark</span><span class="o">-</span><span class="nx">markdown</span> <span class="p">=&gt;</span> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">thiagokokada</span><span class="o">/</span><span class="nx">goldmark</span><span class="o">-</span><span class="nx">markdown</span> <span class="nx">v0</span><span class="mf">.0.0</span><span class="o">-</span><span class="mi">20240820111219</span><span class="o">-</span><span class="nx">f30775d8ed15</span>
+</span></span></code></pre><p>This will replace all usages of <code>github.com/teekennedy/goldmark-markdown</code> to my
+fork in <code>github.com/thiagokokada/goldmark-markdown</code>. You even get all the
+reproducibility of modules since Go automatically pins the commit.</p>
+<p>Since the Go format for versions is quite unique, you can just set to the
+desired branch (e.g.: instead of <code>v0.0.0-20240820111219-f30775d8ed15</code>, you can
+use <code>add-sublist-length-opt</code> that is the branch name) and run <code>go mod tidy</code> to
+fix the format.</p></summary></entry><entry><title>Quick bits: Go automatically downloads a newer toolchain if needed</title><link href="https://kokada.dev/blog/quick-bits-go-automatically-downloads-a-newer-toolchain-if-needed/" rel="alternate"/><published>2024-08-19T00:00:00+00:00</published><id>https://kokada.dev/blog/quick-bits-go-automatically-downloads-a-newer-toolchain-if-needed/</id><summary type="html"><p>I am using
+<a href="https://github.com/elliotchance/orderedmap/">elliotchance/orderedmap</a> as my
+choice of ordered maps (since Go <a href="https://kokada.dev/blog/an-unordered-list-of-things-i-miss-in-go">doesn't have
+one</a> in
+standard library yet). I recently did a
+<a href="https://github.com/elliotchance/orderedmap/pull/41">PR</a> to implement Go 1.23
+iterators, because I find them neat, however I was avoiding to use it in the
+code that generates this <a href="https://github.com/thiagokokada/blog">blog</a> since Go
+1.23 was just released and is still not the default Go in
+<a href="https://github.com/NixOS/nixpkgs">nixpkgs</a>.</p>
+<p>I decided that I would create a
+<a href="https://github.com/thiagokokada/blog/pull/2">branch</a> and leave there for a few
+months, until I decided to try to run the code locally and got this:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> go build
+</span></span><span class="line"><span class="cl"><span class="go">go: downloading go1.23.0 (darwin/arm64)
+</span></span></span></code></pre><p>Nice. And before you ask, yes, the compiled binary works perfectly:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make
+</span></span><span class="line"><span class="cl"><span class="go">./blog &gt; README.md
+</span></span></span><span class="line"><span class="cl"><span class="go">./blog -rss &gt; rss.xml
+</span></span></span></code></pre><p>So how does this work? Take a look at the documentation in the official <a href="https://tip.golang.org/doc/toolchain">Golang
+page</a>:</p>
+<blockquote>
+<p>Starting in Go 1.21, the Go distribution consists of a go command and a
+bundled Go toolchain, which is the standard library as well as the compiler,
+assembler, and other tools. The go command can use its bundled Go toolchain
+as well as other versions that it finds in the local PATH or downloads as
+needed.</p>
+</blockquote>
+<p>There are a bunch of rules here that I am not going to enter in detail (I
+recommend you to read the official documentation), but a quick summary:</p>
+<ul>
+<li>
+<p>Go will download a toolchain when either <code>go</code> or <code>toolchain</code> lines <code>go.mod</code>
+is set to a Go version higher than your current <code>go</code> binary</p>
+<ul>
+<li>But only if your <code>go</code> binary is at least version 1.21, since this is the
+version that introduces this behavior</li>
+</ul>
+</li>
+<li>
+<p>You can force a specific toolchain with <code>GOTOOLCHAIN</code> environment setting,
+e.g.: <code>GOTOOLCHAIN=1.23</code></p>
+<ul>
+<li>The default value for <code>GOTOOLCHAIN</code> is <code>auto</code>, that basically has the
+behavior described in this post</li>
+<li>You can also set to <code>local</code> to always use the current <code>go</code> binary, or the
+previous behaviour pre-1.21 Go</li>
+<li>There is also <code>&lt;name&gt;+auto</code> and <code>path</code> options, that can be seen in the
+docs</li>
+</ul>
+</li>
+<li>
+<p>The downloaded toolchains go to whatever your <code>GOPATH</code> is, inside
+<code>golang.org/toolchain</code> module, and version <code>v0.0.1-goVERSION.GOOS-GOARCH</code>, for
+example:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ls -lah <span class="nv">$GOPATH</span>/pkg/mod/golang.org/toolchain@v0.0.1-go1.23.0.darwin-arm64
+</span></span><span class="line"><span class="cl"><span class="go">total 64
+</span></span></span><span class="line"><span class="cl"><span class="go">dr-xr-xr-x 14 user staff 448B 19 Aug 12:01 .
+</span></span></span><span class="line"><span class="cl"><span class="go">drwxr-xr-x 4 user staff 128B 19 Aug 12:01 ..
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 1.3K 19 Aug 12:01 CONTRIBUTING.md
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 1.4K 19 Aug 12:01 LICENSE
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 1.3K 19 Aug 12:01 PATENTS
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 1.4K 19 Aug 12:01 README.md
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 426B 19 Aug 12:01 SECURITY.md
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 35B 19 Aug 12:01 VERSION
+</span></span></span><span class="line"><span class="cl"><span class="go">dr-xr-xr-x 4 user staff 128B 19 Aug 12:01 bin
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 52B 19 Aug 12:01 codereview.cfg
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 505B 19 Aug 12:01 go.env
+</span></span></span><span class="line"><span class="cl"><span class="go">dr-xr-xr-x 3 user staff 96B 19 Aug 12:01 lib
+</span></span></span><span class="line"><span class="cl"><span class="go">dr-xr-xr-x 4 user staff 128B 19 Aug 12:01 pkg
+</span></span></span><span class="line"><span class="cl"><span class="go">dr-xr-xr-x 77 user staff 2.4K 19 Aug 12:02 src
+</span></span></span></code></pre></li>
+</ul>
+<p>By the way, this only works well because Go toolchain binaries are static.</p>
+<p>While I don't like a program downloading random binaries from the internet, I
+like what Go is doing here. It makes the whole bootstrapping process for a Go
+project much easier: as long as you have a reasonable up-to-date <code>go</code> binary in
+your <code>PATH</code>, you should be ready to go (pun intended). And Go modules are
+already reasonable secure, ensuring that each module have a proper checksum. As
+long as nobody else can publish modules in <code>golang.org/toolchain</code> namespace I
+can't see much of a security issue here, but I am not a security expert.</p>
+<p>But if you don't like this behavior, you can always disable it by setting
+<code>GOTOOLCHAIN=local</code>. And just do not forget to set this in your
+<a href="https://brandur.org/fragments/go-version-matrix">CI</a>, unless you don't care
+about Go versions.</p></summary></entry><entry><title>An unordered list of things I miss in Go</title><link href="https://kokada.dev/blog/an-unordered-list-of-things-i-miss-in-go/" rel="alternate"/><published>2024-08-17T00:00:00+00:00</published><id>https://kokada.dev/blog/an-unordered-list-of-things-i-miss-in-go/</id><summary type="html"><p>I like Go. I think it is a <a href="https://kokada.dev/blog/go-a-reasonable-good-language">reasonable good
+language</a>, and has some
+good qualities that makes up for its flaws. However, this doesn't mean I think
+the language couldn't be better, far from it.</p>
+<p>This blog post is a list of things that I miss from Go from other languages.
+Some of the things here could probably be implemented soon, some other would
+probably need a major revision of the language. The list is unordered, because
+this makes it easier for me to update in the future if I found something else,
+but also because I don't want to think too hard about giving each point here a
+rank.</p>
+<p>With all above, let's start.</p>
+<h2>Ordered maps in standard library</h2>
+<p>When I first learned about
+<a href="https://docs.python.org/3/library/stdtypes.html#typesmapping">dictionaries</a> in
+Python it quickly became one of my favorite data structures ever. They're
+extremely versatile, and most modern programming languages have something
+similar in its standard library. Go isn't different, it has
+<a href="https://go.dev/blog/maps"><code>map</code></a>, that is Go implementation of a <a href="https://en.wikipedia.org/wiki/Hash_table">hash
+table</a>. However <code>map</code> in Go are
+quirky, for example:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span> <span class="o">:=</span> <span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kt">bool</span><span class="p">{</span><span class="s">&#34;foo&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span> <span class="s">&#34;bar&#34;</span><span class="p">:</span> <span class="kc">false</span><span class="p">,</span> <span class="s">&#34;baz&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span> <span class="s">&#34;qux&#34;</span><span class="p">:</span> <span class="kc">false</span><span class="p">,</span> <span class="s">&#34;quux&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nx">k</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">m</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">println</span><span class="p">(</span><span class="nx">k</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> go run ./test.go
+</span></span><span class="line"><span class="cl"><span class="go">bar
+</span></span></span><span class="line"><span class="cl"><span class="go">baz
+</span></span></span><span class="line"><span class="cl"><span class="go">qux
+</span></span></span><span class="line"><span class="cl"><span class="go">quux
+</span></span></span><span class="line"><span class="cl"><span class="go">foo
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> go run ./test.go
+</span></span><span class="line"><span class="cl"><span class="go">foo
+</span></span></span><span class="line"><span class="cl"><span class="go">bar
+</span></span></span><span class="line"><span class="cl"><span class="go">baz
+</span></span></span><span class="line"><span class="cl"><span class="go">qux
+</span></span></span><span class="line"><span class="cl"><span class="go">quux
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> go run ./test.go
+</span></span><span class="line"><span class="cl"><span class="go">qux
+</span></span></span><span class="line"><span class="cl"><span class="go">quux
+</span></span></span><span class="line"><span class="cl"><span class="go">foo
+</span></span></span><span class="line"><span class="cl"><span class="go">bar
+</span></span></span><span class="line"><span class="cl"><span class="go">baz
+</span></span></span></code></pre><p>Now, I don't expect any hash table implementation to keep the order of the
+elements, but Go actually <a href="https://victoriametrics.com/blog/go-map/">randomise each map
+instance</a>:</p>
+<blockquote>
+<p>But here’s the deal, while the hash function used for maps in Go is
+consistent across all maps with <strong>the same key type</strong>, the <code>seed</code> used by
+that hash function is different for each map instance. So, when you create a
+new map, Go generates a random seed just for that map.</p>
+</blockquote>
+<p>While I understand the reason for this (i.e.: to avoid developers relying in a
+specific iteration order), I still find it weird, and I think this is something
+unique for Go. This decision means that even if you don't care about a specific
+order, you will still need to sort the map before doing something else if you
+want reproducibility, something that I care a lot.</p>
+<p>The fix for this? Go could offer an ordered map implementation inside the
+standard library. An ordered map ensure that the iteration order of the map is
+the same as the insertion order (that is, by the way, a powerful property that
+allow maps to be used in other contexts, not just my pet peeve above).</p>
+<p>Python actually does this for any dictionaries since <a href="https://stackoverflow.com/a/39980744">Python
+3.6</a>, but it offered an
+<a href="https://docs.python.org/3/library/collections.html#collections.OrderedDict">OrderedDict</a>
+before it (and <code>OrderedDict</code> still has some methods that normal <code>dict</code> doesn't,
+that maybe useful in specific cases).</p>
+<p>Before generics it would be impossible to have a type-safe API for such data
+structure without introducing a new data type in the language (like <code>slices</code>),
+but now Go has generics so it is not an issue anymore. The other issue is that
+you would be forced to iterate manually in this new data structure, but thanks
+to the new <a href="https://tip.golang.org/doc/go1.23#language"><code>range-over-func</code></a> in
+Go 1.23, it means we can iterate in an ordered map as a library almost exactly
+like we can do as a <code>map</code>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">import</span> <span class="s">&#34;orderedmap&#34;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span> <span class="o">:=</span> <span class="nx">orderedmap</span><span class="p">.</span><span class="nx">New</span><span class="p">[</span><span class="kt">string</span><span class="p">,</span> <span class="kt">bool</span><span class="p">]()</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span><span class="p">.</span><span class="nf">Set</span><span class="p">(</span><span class="s">&#34;foo&#34;</span><span class="p">,</span> <span class="kc">true</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span><span class="p">.</span><span class="nf">Set</span><span class="p">(</span><span class="s">&#34;bar&#34;</span><span class="p">,</span> <span class="kc">false</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span><span class="p">.</span><span class="nf">Set</span><span class="p">(</span><span class="s">&#34;baz&#34;</span><span class="p">,</span> <span class="kc">true</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nx">k</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">m</span><span class="p">.</span><span class="nf">Iterator</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">println</span><span class="p">(</span><span class="nx">k</span><span class="p">)</span> <span class="c1">// Order always will be: foo, bar, baz
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Now, of course the lack of Ordered Map in the standard library can be filled
+with third party implementations, e.g.: I am using this
+<a href="https://github.com/elliotchance/orderedmap">one</a> in one of my projects. But
+being in standard library reduces the friction: if there was some
+implementation in standard library, I would generally prefer it unless I have
+some specific needs. However when the standard library doesn't offer what I
+need, I need to find it myself a suitable library, and this ends up taking time
+since generally there are lots of alternatives.</p>
+<h2>Keyword and default arguments for functions</h2>
+<p>Something that comes straight from Python that I miss sometimes in Go is that
+you can do things like this when declaring a function:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">hello</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s2">&#34;World&#34;</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;Hello, </span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="n">hello</span><span class="p">(</span><span class="s2">&#34;Foo&#34;</span><span class="p">)</span> <span class="c1"># &#34;normal&#34; function call</span>
+</span></span><span class="line"><span class="cl"><span class="n">hello</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s2">&#34;Bar&#34;</span><span class="p">)</span> <span class="c1"># calling with keyword arguments</span>
+</span></span><span class="line"><span class="cl"><span class="n">hello</span><span class="p">()</span> <span class="c1"># calling with default arguments</span>
+</span></span></code></pre><pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> python hello.py
+</span></span><span class="line"><span class="cl"><span class="go">Hello, Foo
+</span></span></span><span class="line"><span class="cl"><span class="go">Hello, Bar
+</span></span></span><span class="line"><span class="cl"><span class="go">Hello, World
+</span></span></span></code></pre><p>The lack of default arguments especially affects even some of the API decisions
+for Go standard library, for example, <code>string.Replace</code>:</p>
+<blockquote>
+<p><code>func Replace(s, old, new string, n int) string</code></p>
+<p>Replace returns a copy of the string s with the first n non-overlapping
+instances of old replaced by new. If old is empty, it matches at the
+beginning of the string and after each UTF-8 sequence, yielding up to k+1
+replacements for a k-rune string. If n &lt; 0, there is no limit on the number
+of replacements.</p>
+</blockquote>
+<p>If Go had default arguments, <code>Replace</code> could have e.g.: <code>func Replace(s, old, new string, n int = -1)</code> signature, that would mean we don't need
+<code>strings.ReplaceAll</code> (since this is basically what this function does, call
+<code>strings.Replace(s, old, new, -1)</code>).</p>
+<h2>Nullability (or nillability)</h2>
+<p>I talked I little about this in <a href="https://kokada.dev/blog/go-a-reasonable-good-language">my previous post about
+Go</a>, but I want to
+expand here.</p>
+<p>First, I don't think the language needs to support the generic solution for
+nullability, that would be either having proper Union or Sum types. Kotlin
+AFAIK doesn't support neither, but my 2 years experience with Kotlin showed
+that just having nullable types already helped a lot in ensuring type safety.</p>
+<p>Second, I do feel that Go has less issues with <code>nil</code> values, than say, Java,
+because its decision of using zero values instead of <code>nil</code> in many cases. So
+for example, a string can never be <code>nil</code>, however a string pointer can be. This
+means that this is fine:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span><span class="p">(</span><span class="nx">s</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// do something with s
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
+</span></span></code></pre><p>However:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span><span class="p">(</span><span class="nx">s</span> <span class="o">*</span><span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// s maybe nil here, better check first
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
+</span></span></code></pre><p>Still, I get more <code>panic</code> for <code>nil</code> pointer deference than I get in other
+languages that offer nullables (heck, even Python with
+<a href="https://www.mypy-lang.org/"><code>mypy</code></a> is safer).</p>
+<p>Sadly this is the change in this post that is more likely to need a completely
+new revision of the language.
+<a href="https://github.com/golang/go/issues/49202">nillability</a> was proposed before,
+but it is really unlikely it can be done without breaking backwards
+compatibility.</p>
+<p>It could be done the Java way by adding a <code>nullable</code> type to the standard
+library (<a href="https://jcp.org/en/jsr/detail?id=305">JSR305</a>), but the fact that
+<a href="https://stackoverflow.com/questions/2289694/what-is-the-status-of-jsr-305">JSR305 is considerd
+dead</a>
+by many shows how difficult it is to do something like this without a major
+change in the language. Dart is the only language that I know that <a href="https://dart.dev/null-safety/understanding-null-safety">did this
+successfully</a>, but
+definitely it was not without its pains. And the fact that most people that
+program in Dart probably does because of Flutter (that eventually required
+newer versions with null-safety) is not a good sign.</p>
+<h2>Lambdas</h2>
+<p><em>Added in 2024-08-18</em></p>
+<p>Go is a surprising good language for some functional code, thanks to having
+first class functions and closures. Sadly the syntax doesn't help, since the
+only way you can use anonymous functions in Go is using <code>func</code>. Especially if
+the types are complex, this can result in some convoluted code. Take the
+example from the <a href="https://go.dev/wiki/RangefuncExperiment"><code>range-over-func</code>
+experiment</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">slices</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">Backward</span><span class="p">[</span><span class="nx">E</span> <span class="nx">any</span><span class="p">](</span><span class="nx">s</span> <span class="p">[]</span><span class="nx">E</span><span class="p">)</span> <span class="kd">func</span><span class="p">(</span><span class="kd">func</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="nx">E</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="kd">func</span><span class="p">(</span><span class="nx">yield</span> <span class="kd">func</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="nx">E</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">--</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">!</span><span class="nf">yield</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">s</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>If Go had a syntax for lambdas, especially if we could elide the types, this
+could be simplified a lot:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">slices</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">Backward</span><span class="p">[</span><span class="nx">E</span> <span class="nx">any</span><span class="p">](</span><span class="nx">s</span> <span class="p">[]</span><span class="nx">E</span><span class="p">)</span> <span class="kd">func</span><span class="p">(</span><span class="kd">func</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="nx">E</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="p">(</span><span class="nx">yield</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">--</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">!</span><span class="nf">yield</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">s</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Or even something like this would already help, no special syntax but allowing
+the types to be elided in an unnamed function:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">slices</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">Backward</span><span class="p">[</span><span class="nx">E</span> <span class="nx">any</span><span class="p">](</span><span class="nx">s</span> <span class="p">[]</span><span class="nx">E</span><span class="p">)</span> <span class="kd">func</span><span class="p">(</span><span class="kd">func</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="nx">E</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="kd">func</span><span class="p">(</span><span class="nx">yield</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">--</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">!</span><span class="nf">yield</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">s</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This feature I am still somewhat hopeful that may become a reality in some
+future version of the language, since they didn't close the
+<a href="https://github.com/golang/go/issues/21498">issue</a> yet, and the discussion
+about the possibility of this feature is still ongoing.</p>
+<h2>Error on unused return values</h2>
+<p><em>Added in 2024-09-12</em></p>
+<p>In a <a href="https://kokada.dev/blog/my-coding-experience-with-llm">recent post about
+LLMs</a>, I talked about
+this function that I asked ChatGPT to generate to create a socket that accepted
+a <a href="https://pkg.go.dev/context">context</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">readWithContext</span><span class="p">(</span><span class="nx">ctx</span> <span class="nx">context</span><span class="p">.</span><span class="nx">Context</span><span class="p">,</span> <span class="nx">conn</span> <span class="nx">net</span><span class="p">.</span><span class="nx">Conn</span><span class="p">,</span> <span class="nx">buf</span> <span class="p">[]</span><span class="kt">byte</span><span class="p">)</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kd">struct</span><span class="p">{})</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">n</span> <span class="kt">int</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">err</span> <span class="kt">error</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1">// Start a goroutine to perform the read
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">Read</span><span class="p">(</span><span class="nx">buf</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">close</span><span class="p">(</span><span class="nx">done</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}()</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">select</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">ctx</span><span class="p">.</span><span class="nf">Done</span><span class="p">():</span> <span class="c1">// Context was canceled or timed out
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="c1">// Set a short deadline to unblock the Read()
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"> <span class="o">&lt;-</span><span class="nx">done</span> <span class="c1">// Wait for the read to finish
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">ctx</span><span class="p">.</span><span class="nf">Err</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">done</span><span class="p">:</span> <span class="c1">// Read finished successfully
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>However while reading <a href="https://joeduffyblog.com/2016/02/07/the-error-model/">this blog
+post</a> about &quot;The Error
+Model&quot;, I realised that this function is lacking error check during
+<code>conn.SetReadDeadline()</code> calls:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">readWithContext</span><span class="p">(</span><span class="nx">ctx</span> <span class="nx">context</span><span class="p">.</span><span class="nx">Context</span><span class="p">,</span> <span class="nx">conn</span> <span class="nx">net</span><span class="p">.</span><span class="nx">Conn</span><span class="p">,</span> <span class="nx">buf</span> <span class="p">[]</span><span class="kt">byte</span><span class="p">)</span> <span class="p">(</span><span class="nx">n</span> <span class="kt">int</span><span class="p">,</span> <span class="nx">err</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kd">struct</span><span class="p">{})</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1">// Start a goroutine to perform the read
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">Read</span><span class="p">(</span><span class="nx">buf</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">close</span><span class="p">(</span><span class="nx">done</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}()</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">select</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">done</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">ctx</span><span class="p">.</span><span class="nf">Done</span><span class="p">():</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Set a short deadline to unblock the Read()
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Reset read deadline
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">defer</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Time</span><span class="p">{});</span> <span class="nx">e</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">err</span> <span class="p">=</span> <span class="nx">errors</span><span class="p">.</span><span class="nf">Join</span><span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">e</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}()</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Make sure that the goroutine is done to avoid leaks
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="o">&lt;-</span><span class="nx">done</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">errors</span><span class="p">.</span><span class="nf">Join</span><span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">ctx</span><span class="p">.</span><span class="nf">Err</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>I could blame the LLM on this, but this is the type of mistake that I could see
+happening even in a Pull Request done by an actual human.</p>
+<p>Ignoring errors is bad, especially because once the error is ignored it is
+gone, forever. You may have strange issues in the code that are impossible to
+debug because you can't know about something that doesn't exist. This is one of
+the reasons I think exceptions are better, since this is the kind of error that
+would be impossible to ignore if the language had exceptions, and the exception
+would eventually propagate in your stack until it is captured or you get a
+crash (with a stack trace to debug the issue).</p>
+<p>Now, I don't think this is a fault of using error as values instead of
+exceptions. Go has the tools to encapsulate the errors and propagate them
+properly, like it is shown in the fixed code. But the fact that someone can do
+this mistake without any warning or error from the compiler is bad.</p>
+<p>If Go had a warning or error for unused return values, this would be different:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">foo</span><span class="p">(</span><span class="nx">conn</span> <span class="o">*</span><span class="nx">net</span><span class="p">.</span><span class="nx">Conn</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// ...
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">_</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Now in this case it is clear: I am ignoring the error explicitly, probably for
+a good reason. I can ask during a Pull Request why the committer is ignoring if
+it is lacking appropriate context, and maybe even ask for some comments to be
+added why this would be safe. What can't happen is this being ignored by
+mistake.</p>
+<p>I am not completely sure if I want this only for errors or for any unused value
+though. There are lots of cases where ignoring non-error values is ok, but I
+also don't see the issue of having something like:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">foo</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// ...
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">_</span><span class="p">,</span> <span class="nx">_</span> <span class="p">=</span> <span class="nf">FuncThatReturnIntAndError</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>If anything, it is clear for whoever is reading this code later that you're
+only calling this function only for its side-effects.</p>
+<p>By the way, yes, <a href="https://github.com/kisielk/errcheck">errcheck</a> linter exists,
+but if the language itself doesn't enforce this it means that there are lots of
+libraries that are probably mistakenly ignoring errors. And if the library is
+ignoring errors by mistake, you can't do much when you actually have them.</p></summary></entry><entry><title>Quick bits: NixOS's boot.kernelPackages is a attrset</title><link href="https://kokada.dev/blog/quick-bits-nixoss-boot-kernelpackages-is-a-attrset/" rel="alternate"/><published>2024-08-15T00:00:00+00:00</published><id>https://kokada.dev/blog/quick-bits-nixoss-boot-kernelpackages-is-a-attrset/</id><summary type="html"><p>I don't know if this is just something that got me by surprise or not, but
+<a href="https://github.com/NixOS/nixpkgs/blob/bb16119a4a7639ebbc91ad0f516b324b0f7c9b68/nixos/modules/system/boot/kernel.nix#L40-L71"><code>boot.kernelPackages</code></a>
+option does not receive a derivation like most other packages, but instead
+receives a function and returns an attribute set with all packages. Here is the
+documentation:</p>
+<blockquote>
+<p>This option allows you to override the Linux kernel used by NixOS. Since
+things like external kernel module packages are tied to the kernel you’re
+using, it also overrides those. This option is a function that takes Nixpkgs
+as an argument (as a convenience), and returns an attribute set containing at
+the very least an attribute kernel. Additional attributes may be needed
+depending on your configuration. For instance, if you use the NVIDIA X
+driver, then it also needs to contain an attribute <code>nvidia_x11</code>.</p>
+</blockquote>
+<p>The kernel package itself is referenced by the
+<a href="https://github.com/NixOS/nixpkgs/blob/bb16119a4a7639ebbc91ad0f516b324b0f7c9b68/nixos/modules/system/boot/kernel.nix#L331-L332"><code>kernel</code></a>
+derivation inside this attribute set:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="go">nix-repl&gt; nixosConfigurations.sankyuu-nixos.config.boot.kernelPackages.kernel
+</span></span></span><span class="line"><span class="cl"><span class="go">«derivation /nix/store/5zyjvf3qgfk52qmgxh36l4dkr9lf100x-linux-6.10.3.drv»
+</span></span></span></code></pre><p>The reason for this is because it ensure that things like modules are built
+with the same kernel version you are booting.</p>
+<p>However one less obvious consequence about this is that if you want packages
+that come from <code>linuxPackages</code>, say for example
+<a href="https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/os-specific/linux/cpupower/default.nix"><code>cpupower</code></a>
+or
+<a href="https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/os-specific/linux/cpupower/default.nix"><code>turbostat</code></a>,
+it is better to do:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span> <span class="n">config</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">environment</span><span class="o">.</span><span class="n">systemPackages</span> <span class="o">=</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="n">config</span><span class="o">.</span><span class="n">boot</span><span class="o">.</span><span class="n">kernelPackages</span><span class="o">.</span><span class="n">cpupower</span>
+</span></span><span class="line"><span class="cl"> <span class="n">config</span><span class="o">.</span><span class="n">boot</span><span class="o">.</span><span class="n">kernelPackages</span><span class="o">.</span><span class="n">turbostat</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Instead of:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span> <span class="n">pkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">environment</span><span class="o">.</span><span class="n">systemPackages</span> <span class="o">=</span> <span class="k">with</span> <span class="n">pkgs</span><span class="p">;</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="n">linuxPackages</span><span class="o">.</span><span class="n">cpupower</span>
+</span></span><span class="line"><span class="cl"> <span class="n">linuxPackages</span><span class="o">.</span><span class="n">turbostat</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Now, I used the later for a long time and never had issues. But technically
+those packages depends in a specific kernel version for a reason, so getting
+them from <code>config.boot.kernelPackages</code> reduces the chance of you having some
+compatibility issue in the future.</p></summary></entry><entry><title>Abusing Makefiles for fun and profit</title><link href="https://kokada.dev/blog/abusing-makefiles-for-fun-and-profit/" rel="alternate"/><published>2024-08-13T00:00:00+00:00</published><id>https://kokada.dev/blog/abusing-makefiles-for-fun-and-profit/</id><summary type="html"><p>If you are following this blog for a while, it should be no surprise that most
+of the workflow in this blog is <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">automated using
+Go</a>. I
+basically write Markdown files with some special rules inside the
+<a href="https://github.com/thiagokokada/blog">repository</a>, commit and push it. In
+seconds, the CI (currently <a href="https://github.com/thiagokokada/blog/blob/4e3f25485c6682f3e066b219df2290934bc0d256/.github/workflows/go.yml">GitHub
+Actions</a>)
+will take the latest commit, generate some files (since I use the <a href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform">repository
+itself</a> as a
+backup blog) and publish to the <a href="https://kokada.capivaras.dev/">capivaras.dev
+website</a>.</p>
+<p>Now, considering how much about <a href="https://nixos.org/">Nix</a> I talk in this blog,
+it should be a surprise that the workflow above has <strong>zero</strong> Nix code inside
+it. I am not saying this blog will never have it, but I am only going to add if
+this is necessary, for example if I start using a tool to build this blog that
+I generally don't expect it to be installed by the machine I am currently
+using. Go is an exception of this rule since it is relatively straightfoward to
+install (just download the <a href="https://go.dev/doc/install">binary</a>) and because
+its <a href="https://go.dev/doc/go1compat">stability guarantee</a> means (hopefully) no
+breakage. But most other things I consider moving targets, and I wouldn't be
+comfortable to use unless I have Nix to ensure reproducibility.</p>
+<p>This is why the other tool that this blog (ab)uses during its workflow is
+<a href="https://en.wikipedia.org/wiki/Make_(software)"><code>Make</code></a>, one of the oldest
+build automation tool that exist. It is basically available in any *nix (do not
+confuse with <a href="https://nixos.org/">Nix</a>) system, from most Linux distros to
+macOS, by default. So it is the tool I choose to automatise some tasks in this
+blog, even if I consider writing a <code>Makefile</code> (the domain-specific language
+that <code>Make</code> uses) kind of a lost, dark art.</p>
+<p>To be clear, the idea of this post is not to be a <code>Makefile</code> tutorial. I will
+explain some basic concepts, but if you want an actual tutorial a good one can
+be found <a href="https://makefiletutorial.com/">here</a>. Also, while I am using <code>Make</code>
+thanks to the reasons above, you can use many other tools for a similar
+objective, like <a href="https://github.com/casey/just">Justfiles</a>,
+<a href="https://taskfile.dev/">Taskfiles</a> (sadly it uses
+<a href="https://kokada.dev/blog/generating-yaml-files-with-nix">YAML</a>), or even a
+small script written in any language you want. The reason that I am writing
+this post is why you should do it, not how.</p>
+<p>A quick recap on how this blog works: inside the
+<a href="https://github.com/thiagokokada/blog">repository</a>, a post is basically a
+Markdown post following the directory structure below
+(<a href="https://github.com/thiagokokada/blog/tree/894a388c61ca3a38dfc9d4cbe88dc684fd964bb7">permalink</a>
+for the current version of this blog):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="go">.
+</span></span></span><span class="line"><span class="cl"><span class="go">&lt;...&gt;
+</span></span></span><span class="line"><span class="cl"><span class="go">├── 2024-08-07
+</span></span></span><span class="line"><span class="cl"><span class="go">│ ├── 01-quick-bits-is-crostini-a-microvm.md
+</span></span></span><span class="line"><span class="cl"><span class="go">│ └── 02-meta-are-quick-bits-really-quick.md
+</span></span></span><span class="line"><span class="cl"><span class="go">├── 2024-08-11
+</span></span></span><span class="line"><span class="cl"><span class="go">│ └── 01-building-static-binaries-in-nix.md
+</span></span></span><span class="line"><span class="cl"><span class="go">├── 2024-08-12
+</span></span></span><span class="line"><span class="cl"><span class="go">│ ├── 01-things-i-dont-like-in-my-chromebook-duet-3.md
+</span></span></span><span class="line"><span class="cl"><span class="go">│ └── Screenshot_2024-08-12_20.50.42.png
+</span></span></span><span class="line"><span class="cl"><span class="go">├── 2024-08-13
+</span></span></span><span class="line"><span class="cl"><span class="go">│ ├── 01-abusing-makefiles-for-fun-and-profit.md &lt;-- this file
+</span></span></span><span class="line"><span class="cl"><span class="go">├── .github
+</span></span></span><span class="line"><span class="cl"><span class="go">│ └── workflows
+</span></span></span><span class="line"><span class="cl"><span class="go">│ └── go.yml
+</span></span></span><span class="line"><span class="cl"><span class="go">├── .gitignore
+</span></span></span><span class="line"><span class="cl"><span class="go">├── go.mod
+</span></span></span><span class="line"><span class="cl"><span class="go">├── go.sum
+</span></span></span><span class="line"><span class="cl"><span class="go">├── LICENSE
+</span></span></span><span class="line"><span class="cl"><span class="go">├── link_rewriter.go
+</span></span></span><span class="line"><span class="cl"><span class="go">├── Makefile
+</span></span></span><span class="line"><span class="cl"><span class="go">├── mataroa.go
+</span></span></span><span class="line"><span class="cl"><span class="go">├── README.md
+</span></span></span><span class="line"><span class="cl"><span class="go">├── rss.xml
+</span></span></span><span class="line"><span class="cl"><span class="go">└── .scripts
+</span></span></span><span class="line"><span class="cl"><span class="go"> └── gen-post.sh
+</span></span></span></code></pre><p>So I just create a new Markdown file following the
+<code>YYYY-MM-DD/XX-title-slug.md</code> format. It <strong>must</strong> start with a <code>h1</code> header,
+that will be automatically extract to be used as the post title, but otherwise
+there is no other formatting rules. It is a highly optionated structure, but
+the nice thing about being optionated is that we can extract lots of
+information just from how the files are organised in the filesystem.</p>
+<p>Most of the magic that converts those Markdown files to actual blog posts are
+in the Go files that you can see above: <code>blog.go</code> is the main logic that walks
+in the repository and extracts the necessary information, <code>mataroa.go</code> is
+responsible for the <a href="https://capivaras.dev/">capivaras.dev</a> integration (that
+uses <a href="https://mataroa.blog/">Mataroa</a> platform), while <code>link_rewriter.go</code> is
+responsible to do some transformations in the Markdown files before posting.</p>
+<p>While I could manage everything by just using <code>go</code> CLI and a few other *nix
+commands, to make it easier to manager everything I have the following
+<a href="https://github.com/thiagokokada/blog/blob/527466a2a7c8baae532281bff5db3f0695f018cb/Makefile"><code>Makefile</code></a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="nv">MARKDOWN</span> <span class="o">:=</span> <span class="k">$(</span>wildcard ./**/*.md<span class="k">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">all</span>
+</span></span><span class="line"><span class="cl"><span class="nf">all</span><span class="o">:</span> <span class="n">README</span>.<span class="n">md</span> <span class="n">rss</span>.<span class="n">xml</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">blog</span><span class="o">:</span> *.<span class="n">go</span> <span class="n">go</span>.*
+</span></span><span class="line"><span class="cl"> go build
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">README.md</span><span class="o">:</span> <span class="n">blog</span> <span class="k">$(</span><span class="nv">MARKDOWN</span><span class="k">)</span>
+</span></span><span class="line"><span class="cl"> ./blog &gt; README.md
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">rss.xml</span><span class="o">:</span> <span class="n">blog</span> <span class="k">$(</span><span class="nv">MARKDOWN</span><span class="k">)</span>
+</span></span><span class="line"><span class="cl"> ./blog -rss &gt; rss.xml
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">publish</span>
+</span></span><span class="line"><span class="cl"><span class="nf">publish</span><span class="o">:</span> <span class="n">blog</span>
+</span></span><span class="line"><span class="cl"> ./blog -publish
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nv">DAY</span> <span class="o">:=</span> <span class="k">$(</span>shell date<span class="k">)</span>
+</span></span><span class="line"><span class="cl"><span class="nv">_PARSED_DAY</span> <span class="o">:=</span> <span class="k">$(</span>shell date <span class="s1">&#39;+%Y-%m-%d&#39;</span> -d <span class="s1">&#39;$(DAY)&#39;</span><span class="k">)</span>
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">day</span>
+</span></span><span class="line"><span class="cl"><span class="nf">day</span><span class="o">:</span>
+</span></span><span class="line"><span class="cl"> mkdir -p <span class="s1">&#39;$(_PARSED_DAY)&#39;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nv">TITLE</span> <span class="o">=</span> <span class="k">$(</span>error TITLE is not defined<span class="k">)</span>
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">post</span>
+</span></span><span class="line"><span class="cl"><span class="nf">post</span><span class="o">:</span> <span class="n">blog</span> <span class="n">day</span>
+</span></span><span class="line"><span class="cl"> ./.scripts/gen-post.sh <span class="s1">&#39;$(_PARSED_DAY)&#39;</span> <span class="s1">&#39;$(TITLE)&#39;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nv">FILE</span> <span class="o">=</span> <span class="k">$(</span>error FILE is not defined<span class="k">)</span>
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">draft</span>
+</span></span><span class="line"><span class="cl"><span class="nf">draft</span><span class="o">:</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">cd</span> <span class="s1">&#39;$(dir $(FILE))&#39;</span> <span class="o">&amp;&amp;</span> mv <span class="s1">&#39;$(notdir $(FILE))&#39;</span> <span class="s1">&#39;.$(notdir $(FILE))&#39;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">undraft</span>
+</span></span><span class="line"><span class="cl"><span class="nf">undraft</span><span class="o">:</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">cd</span> <span class="s1">&#39;$(dir $(FILE))&#39;</span> <span class="o">&amp;&amp;</span> mv <span class="s1">&#39;$(notdir $(FILE))&#39;</span> <span class="s1">&#39;$(patsubst .%,%,$(notdir $(FILE)))&#39;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">clean</span>
+</span></span><span class="line"><span class="cl"><span class="nf">clean</span><span class="o">:</span>
+</span></span><span class="line"><span class="cl"> rm -rf blog
+</span></span></code></pre><p>For those unfamiliar with <code>Makefile</code>, a quick explanation on how it works from
+<a href="https://en.wikipedia.org/wiki/Make_(software)#Makefile">Wikipedia</a>:</p>
+<blockquote>
+<p>Each rule begins with a <em>dependency line</em> which consists of the rule's target
+name followed by a colon (:) and optionally a list of targets on which the
+rule's target depends, its prerequisites.</p>
+</blockquote>
+<p>So if we look for example at the <code>blog</code> binary, the dependencies are all the
+<code>.go</code> files and Go module files like <code>go.mod</code> and <code>go.sum</code>. We can make the
+<code>blog</code> binary by running:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make blog
+</span></span><span class="line"><span class="cl"><span class="go">go build
+</span></span></span></code></pre><p>One nice thing about <code>Makefile</code> is that they track if any of the source files
+has a newer timestamp than the target file, and only trigger the build again if
+there are changes, for example:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make blog
+</span></span><span class="line"><span class="cl"><span class="go">make: &#39;blog&#39; is up to date.
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> touch blog.go
+</span></span><span class="line"><span class="cl"><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> make blog
+</span></span><span class="line"><span class="cl"><span class="go">go build
+</span></span></span></code></pre><p>But sometimes this property is undesirable. In those cases we can declare a
+target as <code>.PHONY</code>, that basically instructs <code>Makefile</code> to always make the
+target. One classic example is <code>clean</code> target, that removes build artifacts:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make clean
+</span></span><span class="line"><span class="cl"><span class="go">rm -rf blog
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> make clean
+</span></span><span class="line"><span class="cl"><span class="go">rm -rf blog
+</span></span></span></code></pre><p>By the way, it is better to declare a target as <code>.PHONY</code> than declaring
+dependencies incorrectly, especially in languages that has fast build times
+like e.g.: Go. The worst thing that can happen is something not being rebuild
+when it needs to. So my recomendation if you are writing your first <code>Makefile</code>
+is to just declare everything as <code>.PHONY</code>. You can always improve it later.</p>
+<p>One last basic concept that I want to explain about <code>Makefile</code> is the default
+target: it is the target that is run if you just run <code>make</code> without arguments
+inside the directory that contains a <code>Makefile</code>. The default target is
+generally the first target in the <code>Makefile</code>. It is common to have an <code>all</code>
+target (that is also marked as <code>.PHONY</code>) that has as dependencies all the
+targets that you want to build by default. In this particular case I declare
+the <code>README.md</code> and <code>rss.xml</code> files to be build by default, and they themselves
+depends in <code>blog</code> binary being build. So once I run <code>make</code> you get as result:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make
+</span></span><span class="line"><span class="cl"><span class="go">go build
+</span></span></span><span class="line"><span class="cl"><span class="go">./blog &gt; README.md
+</span></span></span><span class="line"><span class="cl"><span class="go">./blog -rss &gt; rss.xml
+</span></span></span></code></pre><p>And this result above highlights the first reason I think you should have a
+<code>Makefile</code> or something similar in your projects: you don't need to remember
+the exactly steps that you need to get things working. If I see one project of
+mine having a <code>Makefile</code>, I can be reasonably confident that I can get it
+working by just running <code>make</code>.</p>
+<p>But now let's focus in the other targets that I have in the <code>Makefile</code> that are
+not related to the build process but are there to help me manage my blog posts.
+Remember the rules I explained above? Maybe not, but it should be no problem,
+because:</p>
+<pre><code>$ make post TITLE=&quot;My new blog post&quot;
+mkdir -p &quot;2024-08-13&quot;
+./.scripts/gen-post.sh &quot;2024-08-13&quot; &quot;My new blog post&quot;
+Creating file: 2024-08-13/02-my-new-blog-post.md
+<p>$ cat 2024-08-13/02-my-new-blog-post.md</p>
+<h1>My new blog post</h1>
+</code><p><code></code></p></pre><p></p>
+<p>This command, <code>make post</code>, is responsible for:</p>
+<ol>
+<li>Create a new directory for today, if it doesn't exist</li>
+<li>Run the
+<a href="https://github.com/thiagokokada/blog/blob/6a3b06970729f7650e5bee5fb0e1f9f2541ffea8/.scripts/gen-post.sh"><code>gen-post.sh</code></a>
+script, that:
+<ol>
+<li>Enumerates all posts from the day, so we can number the new post correctly
+<ul>
+<li>We already had this post planned for 2024-08-13, so the new post is 02</li>
+</ul>
+</li>
+<li>Slugify the title, so we can create each Markdown file with the correct
+filename</li>
+<li>Creates a new Markdown file with the title as a <code>h1</code> header</li>
+</ol>
+</li>
+</ol>
+<p>The steps above may or may not seen trivial, and for a while I was doing them
+manually. But not having to think what is the current date or if I already
+posted that day or what is the slug is for the title make (pun intended) my
+like much easier.</p>
+<p>Yes, the code is ugly. The way variables works in <code>Make</code> is that you can
+declare then inside the <code>Makefile</code>, but they can be overwritten in the terminal
+if you pass them. I used this to allow <code>make post</code> to also work for future
+posts:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make post <span class="nv">TITLE</span><span class="o">=</span><span class="s2">&#34;Another new blog post&#34;</span> <span class="nv">DAY</span><span class="o">=</span>2024-12-12
+</span></span><span class="line"><span class="cl"><span class="go">mkdir -p &#34;2024-12-12&#34;
+</span></span></span><span class="line"><span class="cl"><span class="go">./.scripts/gen-post.sh &#34;2024-12-12&#34; &#34;Another new blog post&#34;
+</span></span></span><span class="line"><span class="cl"><span class="go">Creating file: 2024-12-12/01-another-new-blog-post.md
+</span></span></span></code></pre><p>So in the above case, <code>DAY</code> is filled with the value passed in the terminal
+instead of default (that would be the current day), and <code>_PARSED_DAY</code> is the
+day we use to actually create the directory. We can actually pass any date
+format recognised by
+<a href="https://www.gnu.org/software/coreutils/manual/html_node/Examples-of-date.html"><code>date</code></a>,
+not just <code>YYYY-MM-DD</code>.</p>
+<p>I have 2 other phony targets that I want to talk, <code>draft</code> and <code>undraft</code>. They
+expect a <code>FILE</code> to be passed, and I use them to either hide or unhide a file:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make draft <span class="nv">FILE</span><span class="o">=</span>2024-12-12/01-another-new-blog-post.md
+</span></span><span class="line"><span class="cl"><span class="go">mv &#34;2024-12-12/01-another-new-blog-post.md&#34; &#34;2024-12-12/.01-another-new-blog-post.md&#34;
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> make undraft <span class="nv">FILE</span><span class="o">=</span>2024-12-12/.01-another-new-blog-post.md
+</span></span><span class="line"><span class="cl"><span class="go">mv &#34;2024-12-12/.01-another-new-blog-post.md&#34; &#34;2024-12-12/01-another-new-blog-post.md&#34;
+</span></span></span></code></pre><p>Why? Because hidden files are <a href="https://github.com/thiagokokada/blog/blob/894a388c61ca3a38dfc9d4cbe88dc684fd964bb7/blog.go#L101-L104">explicit
+ignored</a>
+during my directory parser to mean they're a draft post and not ready to be
+published. And the reason I created those targets is because I was tired of
+trying to hide or unhide a file manually.</p>
+<p>So that's it, for the same reason you <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">should probably automate
+everything</a>,
+you also need to have some way to automate your tasks. <code>Makefile</code> is one way to
+do it, maybe not the best way to do it, but it works and it is available
+anywhere.</p></summary></entry><entry><title>Things I don't like in my Chromebook Duet 3</title><link href="https://kokada.dev/blog/things-i-dont-like-in-my-chromebook-duet-3/" rel="alternate"/><published>2024-08-12T00:00:00+00:00</published><id>https://kokada.dev/blog/things-i-dont-like-in-my-chromebook-duet-3/</id><summary type="html"><p>So this is kind of a continuation from my <a href="https://kokada.dev/blog/my-favorite-device-is-a-chromebook">previous
+post</a> talking why
+my favorite device is a Chromebook. In this post I want to talk about what
+makes me this device unhappy, and comment about things that if changed would
+make it a much better device.</p>
+<p>But before talking about the negative aspects, let me talk about a positive
+aspect that I just briefly talked in the previous post: the screen. It is a
+HiDPI screen (2000x1200 resolution in 10.95''), that is unexpected bright (400
+nits according to the
+<a href="https://www.lenovo.com/us/en/p/laptops/lenovo/lenovo-edu-chromebooks/ideapad-duet-3-chromebook-11-inch,-qlc/len101i0034">specs</a>).
+It is difficult to find laptops at the same price with a screen that good. At
+10.95'' in its default resolution I find it too small (like 1250x750), but I
+find the font size acceptable at 115% scale (1087x652). Yes, it result in a
+small workspace, but this is not a big issue for what I do in this device. It
+is also only 60Hz, but I thought I would miss high refresh rate more than I
+actually miss in this device.</p>
+<p>Update: I forgot to say one thing about the screen: it scratches really easy. I
+got my screen scratched after the first day of usage, and considering the price
+I don't think the screen has a hardened glass. I bought a cheap glass screen
+protector and this did the trick though, even hiding the previous scratch, and
+I have zero issues with the screen now.</p>
+<p>Now the first aspect that I don't like: the speakers. They sound tiny and even
+at maximum volume it is not really loud. The speakers is the only reason why I
+still keep my <a href="https://www.gsmarena.com/xiaomi_pad_5-11042.php">Xiaomi Pad 5</a>,
+because I like to watch animes/videos before sleep and having good speakers is
+a must.</p>
+<p>The keyboard has that issue that I mentioned in the previous post: sometimes
+the key get stuck, and I get duplicated characters. But it also has some minor
+issues that I didn't talked about: the first one is the UK layout that has some
+extra keys that I have no use for, but this also makes the keys that I use
+smaller. Very much a &quot;me&quot; problem, since if I had got a US version I wouldn't
+have those issues, but an issue nonetheless that gets worse considering how
+small the keyboard is. I am actually suprised how fast I can type considering
+how many issues this keyboard has, so maybe this is a testament that this
+keyboard is not actually that bad.</p>
+<p>The other keyboard issue is a problem that affects all Chromebooks: its custom
+layout. Google replaced a few keys like Fn keys with shortcuts and replaced the
+Caps Lock with a
+<a href="https://chromeunboxed.com/chromebook-launcher-now-everything-button">&quot;Everything&quot;</a>
+key (that is similar to the Windows Key), while removing Windows Key from its
+place. I actually have less issue with this than I initially though: I don't
+care too much about Fn keys (except when using IntelliJ, but that is something
+that I only use at <code>$CURRENT_JOB</code>), and ChromeOS is surprisingly powerful in
+its customisation, allowing you to swap key functionality. I remap Everything
+key with Esc, and Esc for the Everything key, and I can get productive in my
+<code>neovim</code> setup.</p>
+<p>And finally, let me talk more about the performance: yes, it is bad, but
+bearable once you get used to. The issue is both the CPU and IO. While the CPU,
+a <a href="https://www.qualcomm.com/products/mobile/snapdragon/laptops-and-tablets/snapdragon-mobile-compute-platforms/snapdragon-7c-gen-2-compute-platform">Snapdragon 7c Gen
+2</a>
+is octa-core, it has only 2 high performance CPU cores vs 6 low performance
+ones (2xARM Cortex A76 vs 6xARM Cortex A55). If it was something like 4x4, it
+would be much better. The fact that the cores are old doesn't help either.</p>
+<p>But the worst part is the IO. Not only it uses a eMMC module, it is slow:</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-12/Screenshot_2024-08-12_20.50.42.png"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-12/Screenshot_2024-08-12_20.50.42.png" alt="CPDT Benchmark results from Chromebook Duet 3."></a></p>
+<p>I don't know how much more expensive it would be to put a
+<a href="https://en.wikipedia.org/wiki/Universal_Flash_Storage">UFS</a> instead of eMMC in
+this device, but this is probably the choice that would most increase
+performance in this device, especially considering how aggressive Chromebooks
+use (z)swap.</p>
+<p>Update 2: I forgot to talk about the fact that the exterior of the device is
+covered in cloth. I thought I would hate this at first, but nowadays I kind
+like it. And it is also nice that it will never get scratched, I don't care too
+much about the exterior of this device and it is the only device that I have at
+home that doesn't have additional protection (except the screen protector
+mentioned above).</p></summary></entry><entry><title>Building static binaries in Nix</title><link href="https://kokada.dev/blog/building-static-binaries-in-nix/" rel="alternate"/><published>2024-08-11T00:00:00+00:00</published><id>https://kokada.dev/blog/building-static-binaries-in-nix/</id><summary type="html"><p>I recently had laser eye surgery for my near-sightedness, and while evaluating
+if I could have the surgery I discovered that I was suffering from dry eyes.
+Thanks to this, my ophthalmologist recommended that every 20 minutes while
+using screens, I look somewhere 20 feet away for 20 seconds, a technique known
+as <a href="https://www.healthline.com/health/eye-health/20-20-20-rule">20-20-20 rule</a>.</p>
+<p>I had issues following this rule because I never remembered to do the pauses. I
+initially tried to setup an alarm, but this became annoying, so I decided to
+try to find a program. I found
+<a href="https://tonyh4156.github.io/20-20-20.github.io/">this</a> one for macOS that
+worked fine, but it bothered me that it was compiled for x86_64 while I was
+using a M1 MacBook Pro at the time, and also I needed something that worked in
+Linux.</p>
+<p>Since I never found a good multi-platform alternative, I decided to write my
+own. This became
+<a href="https://github.com/thiagokokada/twenty-twenty-twenty/">twenty-twenty-twenty</a>,
+the first <a href="https://kokada.dev/blog/go-a-reasonable-good-language">Go</a> program
+that I ever wrote. I wrote it in Go because I wanted to learn the language, but
+also because Go made it easy to build static binaries. And the first version I
+could build static binaries without issues because I was using
+<a href="https://github.com/gen2brain/beeep">beeep</a>, that uses pure Go code in all
+supported platforms. However, it also meant that the notifications in macOS
+looked ugly, since it used
+<a href="https://github.com/gen2brain/beeep/blob/master/beep_darwin.go#L20">osascript</a>.</p>
+<p>I wanted better integration with macOS, so this meant switching libraries.
+After searching for a while, the
+<a href="https://pkg.go.dev/gioui.org/x/notify">notify</a> library from
+<a href="https://gioui.org/">GioUI</a> is the one that seemed to work better. It
+implements notification in macOS using its native framework, so it works much
+better, but sadly it meant losing static binaries because it depends in CGO.</p>
+<p>Not a big loss initially, because I am only depending in Foundation inside
+macOS (that should always be available), and in Linux I could still statically
+compile. However I eventually added more features like sound
+(via <a href="https://github.com/gopxl/beep">beep</a>) and tray icon (via
+<a href="https://github.com/fyne-io/systray">systray</a>), that meant I needed CGO in both
+macOS and Linux.</p>
+<p>Losing static binaries in Linux is a much bigger deal, since Linux is a moving
+target. The general recommendation for building CGO binaries statically is
+using
+<a href="https://eli.thegreenplace.net/2024/building-static-binaries-with-go-on-linux/">musl</a>,
+but this also means building all dependencies that we need using musl (e.g.:
+<a href="https://github.com/ebitengine/oto?tab=readme-ov-file#linux"><code>ALSA</code></a> for
+[beep/oto]). This generally means pain, but Nix makes it easy.</p>
+<p>Let's start by creating a <a href="https://github.com/thiagokokada/twenty-twenty-twenty/blob/main/twenty-twenty-twenty.nix">Nix
+file</a>
+that builds our Go module (simplified below for brevity):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span> <span class="n">lib</span>
+</span></span><span class="line"><span class="cl"><span class="o">,</span> <span class="n">stdenv</span>
+</span></span><span class="line"><span class="cl"><span class="o">,</span> <span class="n">alsa-lib</span>
+</span></span><span class="line"><span class="cl"><span class="o">,</span> <span class="n">buildGoModule</span>
+</span></span><span class="line"><span class="cl"><span class="o">,</span> <span class="n">pkg-config</span>
+</span></span><span class="line"><span class="cl"><span class="o">,</span> <span class="n">withStatic</span> <span class="o">?</span> <span class="no">false</span>
+</span></span><span class="line"><span class="cl"><span class="p">}:</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="n">buildGoModule</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pname</span> <span class="o">=</span> <span class="s2">&#34;twenty-twenty-twenty&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">version</span> <span class="o">=</span> <span class="s2">&#34;1.0.0&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">src</span> <span class="o">=</span> <span class="n">lib</span><span class="o">.</span><span class="n">cleanSource</span> <span class="sr">./.</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">vendorHash</span> <span class="o">=</span> <span class="s2">&#34;sha256-NzDhpJRogIfL2IYoqAUHoPh/ZdNnvnhEQ+kn8A+ZyBw=&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">CGO_ENABLED</span> <span class="o">=</span> <span class="s2">&#34;1&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">nativeBuildInputs</span> <span class="o">=</span> <span class="n">lib</span><span class="o">.</span><span class="n">optionals</span> <span class="p">(</span><span class="n">stdenv</span><span class="o">.</span><span class="n">hostPlatform</span><span class="o">.</span><span class="n">isLinux</span><span class="p">)</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkg-config</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">buildInputs</span> <span class="o">=</span> <span class="n">lib</span><span class="o">.</span><span class="n">optionals</span> <span class="p">(</span><span class="n">stdenv</span><span class="o">.</span><span class="n">hostPlatform</span><span class="o">.</span><span class="n">isLinux</span><span class="p">)</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="n">alsa-lib</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">ldflags</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;-X=main.version=</span><span class="si">${</span><span class="n">version</span><span class="si">}</span><span class="s2">&#34;</span> <span class="s2">&#34;-s&#34;</span> <span class="s2">&#34;-w&#34;</span> <span class="p">]</span>
+</span></span><span class="line"><span class="cl"> <span class="o">++</span> <span class="n">lib</span><span class="o">.</span><span class="n">optionals</span> <span class="n">withStatic</span> <span class="p">[</span> <span class="s2">&#34;-linkmode external&#34;</span> <span class="s1">&#39;&#39;-extldflags &#34;-static&#34;&#39;&#39;</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">meta</span> <span class="o">=</span> <span class="k">with</span> <span class="n">lib</span><span class="p">;</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">description</span> <span class="o">=</span> <span class="s2">&#34;Alerts every 20 minutes to look something at 20 feet away for 20 seconds&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">homepage</span> <span class="o">=</span> <span class="s2">&#34;https://github.com/thiagokokada/twenty-twenty-twenty&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">license</span> <span class="o">=</span> <span class="n">licenses</span><span class="o">.</span><span class="n">mit</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">mainProgram</span> <span class="o">=</span> <span class="s2">&#34;twenty-twenty-twenty&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>And we can build it with the following <code>flake.nix</code>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">description</span> <span class="o">=</span> <span class="s2">&#34;twenty-twenty-twenty&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">inputs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">url</span> <span class="o">=</span> <span class="s2">&#34;nixpkgs/nixpkgs-unstable&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">flake-compat</span><span class="o">.</span><span class="n">url</span> <span class="o">=</span> <span class="s2">&#34;github:edolstra/flake-compat&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">outputs</span> <span class="o">=</span> <span class="p">{</span> <span class="n">self</span><span class="o">,</span> <span class="n">nixpkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">supportedSystems</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;x86_64-linux&#34;</span> <span class="s2">&#34;aarch64-linux&#34;</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Helper function to generate an attrset &#39;{ x86_64-linux = f &#34;x86_64-linux&#34;; ... }&#39;.</span>
+</span></span><span class="line"><span class="cl"> <span class="n">forAllSystems</span> <span class="o">=</span> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">lib</span><span class="o">.</span><span class="n">genAttrs</span> <span class="n">supportedSystems</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Nixpkgs instantiated for supported system types.</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgsFor</span> <span class="o">=</span> <span class="n">forAllSystems</span> <span class="p">(</span><span class="n">system</span><span class="p">:</span> <span class="kn">import</span> <span class="n">nixpkgs</span> <span class="p">{</span> <span class="k">inherit</span> <span class="n">system</span><span class="p">;</span> <span class="p">});</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">packages</span> <span class="o">=</span> <span class="n">forAllSystems</span> <span class="p">(</span><span class="n">system</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span> <span class="n">pkgs</span> <span class="o">=</span> <span class="n">nixpkgsFor</span><span class="o">.</span><span class="si">${</span><span class="n">system</span><span class="si">}</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">default</span> <span class="o">=</span> <span class="n">self</span><span class="o">.</span><span class="n">packages</span><span class="o">.</span><span class="si">${</span><span class="n">system</span><span class="si">}</span><span class="o">.</span><span class="n">twenty-twenty-twenty</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">twenty-twenty-twenty</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">callPackage</span> <span class="sr">./twenty-twenty-twenty.nix</span> <span class="p">{</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="n">twenty-twenty-twenty-static</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">pkgsStatic</span><span class="o">.</span><span class="n">callPackage</span> <span class="sr">./twenty-twenty-twenty.nix</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">withStatic</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">});</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>I think this shows how powerful Nix is: the only difference between the normal
+build and a static build the usage of <code>pkgs.pkgsStatic</code> instead of <code>pkgs</code>. This
+automatically builds all packages statically with <code>musl</code>. Also we need pass
+some <a href="https://honnef.co/articles/statically-compiled-go-programs-always-even-with-cgo-using-musl/">extra
+flags</a>
+to the Go compiler (i.e.: <code>-linkmode external -extldflags &quot;-static&quot;</code>), but this
+is a requirement from Go.</p>
+<p>So, does it work? Let's test:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix build .#twenty-twenty-twenty-static
+</span></span><span class="line"><span class="cl"><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> file result/bin/twenty-twenty-twenty
+</span></span><span class="line"><span class="cl"><span class="go">result/bin/twenty-twenty-twenty: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, stripped
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> ./result/bin/twenty-twenty-twenty
+</span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/dhn51w2km4fyf9ivi00rz03qs8q4mpng-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/ly9d7llymzjyf6gi1455qzayqipk2kab-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/dhn51w2km4fyf9ivi00rz03qs8q4mpng-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/ly9d7llymzjyf6gi1455qzayqipk2kab-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/dhn51w2km4fyf9ivi00rz03qs8q4mpng-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/ly9d7llymzjyf6gi1455qzayqipk2kab-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">2024-08-11T19:26:33+01:00 INFO Running twenty-twenty-twenty every 20.0 minute(s), with 20 second(s) duration and sound set to true
+</span></span></span></code></pre><p>There are some warns and sadly the sound doesn't work. I think the issue is
+related because of my usage of PipeWire and the binary may work in a pure ALSA
+system, but I don't have access to one. Maybe adding <code>pipewire</code> to
+<code>buildInputs</code> would fix this issue, but I can't get <code>pipewire</code> to be compiled
+statically (because of its dependencies). I think this is a good show how easy
+it is to statically compilation is in Nix, but also how complex static binaries
+are to get correctly.</p>
+<p>Bonus points for
+<a href="https://nix.dev/tutorials/cross-compilation.html">cross-compilation</a>. We can
+easily cross-compile by using <code>pkgsCross</code>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"> <span class="n">outputs</span> <span class="o">=</span> <span class="p">{</span> <span class="n">self</span><span class="o">,</span> <span class="n">nixpkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">packages</span> <span class="o">=</span> <span class="n">forAllSystems</span> <span class="p">(</span><span class="n">system</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span> <span class="n">pkgs</span> <span class="o">=</span> <span class="n">nixpkgsFor</span><span class="o">.</span><span class="si">${</span><span class="n">system</span><span class="si">}</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">twenty-twenty-twenty-static-aarch64</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">pkgsCross</span><span class="o">.</span><span class="n">aarch64-multiplatform</span><span class="o">.</span><span class="n">pkgsStatic</span><span class="o">.</span><span class="n">callPackage</span> <span class="sr">./twenty-twenty-twenty.nix</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">withStatic</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">});</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>The idea of <code>pkgsCross</code> is to select a target platform (e.g.:
+<code>aarch64-multiplatform</code>) and use it as any other <code>pkgs</code>. We can even chain
+<code>pkgsStatic</code> to statically cross compile binaries:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix build .#twenty-twenty-twenty-static-aarch64
+</span></span><span class="line"><span class="cl"><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> file result/bin/twenty-twenty-twenty
+</span></span><span class="line"><span class="cl"><span class="go">result/bin/twenty-twenty-twenty: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, stripped
+</span></span></span></code></pre></summary></entry><entry><title>Meta: are quick bits really quick?</title><link href="https://kokada.dev/blog/meta-are-quick-bits-really-quick/" rel="alternate"/><published>2024-08-07T00:00:00+00:00</published><id>https://kokada.dev/blog/meta-are-quick-bits-really-quick/</id><summary type="html"><p>When I wrote my first <a href="https://kokada.dev/blog/quick-bits-nix-shell-is-cursed">quick
+bits</a> post in this
+blog, I gave that title prefix without much thought: I knew it was supposed to
+be a quicker post than my previous one, but I never thought too deeply about
+it. But after:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ls -lah **/*quick-bits*.md <span class="p">|</span> wc -l
+</span></span><span class="line"><span class="cl"><span class="go">4
+</span></span></span></code></pre><p>Well, 4 blog posts starting with the same prefix, I was curious: are those
+quick bits really quick, or at least quicker? Let's see:</p>
+<pre><code>$ wc -w **/*.md
+ 1107 2024-07-26/01-writing-nixos-tests-for-fun-and-profit.md
+ 1220 2024-07-26/02-using-github-as-a-bad-blog-platform.md
+ 286 2024-07-27/01-quick-bits-nix-shell-is-cursed.md
+ 387 2024-07-29/01-quick-bits-why-you-should-automate-everything.md
+ 1060 2024-07-29/02-go-a-reasonable-good-language.md
+ 1380 2024-07-30/01-first-impressions-fpgbc.md
+ 1238 2024-07-31/01-generating-yaml-files-with-nix.md
+ 2308 2024-08-01/01-troubleshooting-zsh-lag-and-solutions-with-nix.md
+ 504 2024-08-01/02-quick-bits-realise-nix-symlinks.md
+ 834 2024-08-04/01-make-nixd-modules-completion-work-anywhere-with-flakes.md
+ 1147 2024-08-05/01-my-favorite-device-is-a-chromebook.md
+ 394 2024-08-07/01-quick-bits-is-crostini-a-microvm.md
+ 120 README.md
+11985 total
+</code></pre>
+<p>While using <code>wc</code> is probably not the best way to measure word count (especially
+in this blog, since I tend to write lots of code snippets), I think this at
+least it gives me a good insight: yes, quick bits are quicker, and they're
+basically posts with a soft limit around 500 words. So expect in future this
+limit to be used.</p>
+<p>By the way, at:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> wc -w 2024-08-07/02-meta-are-quick-bits-really-quick.md
+</span></span><span class="line"><span class="cl"><span class="go">220 2024-08-07/02-meta-are-quick-bits-really-quick.md
+</span></span></span></code></pre><p>This post is also technically a quick bits post, but &quot;quick bits meta&quot; would be
+too much. And yes, that last block of code is also meta ;).</p></summary></entry><entry><title>Quick bits: is Crostini a micro VM?</title><link href="https://kokada.dev/blog/quick-bits-is-crostini-a-micro-vm/" rel="alternate"/><published>2024-08-07T00:00:00+00:00</published><id>https://kokada.dev/blog/quick-bits-is-crostini-a-micro-vm/</id><summary type="html"><p><strong>Disclaimer</strong>: I am not a Virtual Machine specialist, this post is mainly the
+conclusion I got after some searching.</p>
+<p>Someone asked me in my <a href="https://kokada.dev/blog/my-favorite-device-is-a-chromebook">previous
+post</a> about my
+Chromebook if Crostini could be considered a micro VM. This was a interesting
+question, so I decided to do another post.</p>
+<p>To start, it is really difficult to get a good definition of what a &quot;micro VM&quot;
+is. <a href="https://firecracker-microvm.github.io/">Firecracker</a> defines itself as a
+micro VM, and describes itself in its website as:</p>
+<blockquote>
+<p>Firecracker is a virtual machine monitor (VMM) that uses the Linux
+Kernel-based Virtual Machine (KVM) to create and manage microVMs. Firecracker
+has a minimalist design. It excludes unnecessary devices and guest
+functionality to reduce the memory footprint and attack surface area of each
+microVM. This improves security, decreases the startup time, and increases
+hardware utilization.</p>
+</blockquote>
+<p>Now looking at Crostini, its heart is a VMM called
+<a href="https://crosvm.dev/">crosvm</a>. It is described in its
+<a href="https://chromium.googlesource.com/chromiumos/platform/crosvm/+/HEAD/README.md">README</a>
+as:</p>
+<blockquote>
+<p>crosvm is a virtual machine monitor (VMM) based on Linux’s KVM hypervisor,
+with a focus on simplicity, security, and speed. crosvm is intended to run
+Linux guests, originally as a security boundary for running native
+applications on the ChromeOS platform. Compared to QEMU, crosvm doesn’t
+emulate architectures or real hardware, instead concentrating on
+paravirtualized devices, such as the virtio standard.</p>
+</blockquote>
+<p>Similar descriptions right? Actually Firecracker website says it &quot;started from
+Chromium OS's Virtual Machine Monitor, crosvm, an open source VMM written in
+Rust&quot;. So I would say it is safe to say crosvm itself is a micro VM.</p>
+<p>But
+<a href="https://www.chromium.org/chromium-os/developer-library/guides/containers/containers-and-vms/">Crostini</a>
+itself is a combination of virtualization AND containerization. Basically
+inside the VM it runs a Linux kernel and <a href="https://linuxcontainers.org/">LXC</a>,
+that can start arbitrary containers inside it. From the Crostini documentation
+this choice seems to be to keep startup times down, and also to increase
+security (e.g.: in case of a security issue inside the container).</p>
+<p>This is definitely an interesting choice, since containers allow the overhead
+of each distro that you run inside Crostini to be low, and the main VM itself
+(called
+<a href="https://chromium.googlesource.com/chromiumos/overlays/board-overlays/+/HEAD/project-termina/">Termina</a>)
+should have low overhead too thanks to crosvm.</p>
+<p>By the way, if you want to learn more how &quot;devices&quot; works inside a micro VM
+like crosvm, I recommend <a href="https://prilik.com/blog/post/crosvm-paravirt/">this blog
+post</a> talking about
+paravirtualized devices in crosvm.</p></summary></entry><entry><title>My favorite device is a Chromebook</title><link href="https://kokada.dev/blog/my-favorite-device-is-a-chromebook/" rel="alternate"/><published>2024-08-05T00:00:00+00:00</published><id>https://kokada.dev/blog/my-favorite-device-is-a-chromebook/</id><summary type="html"><p>Most of the posts in this blog (including this one) and most of I would call
+&quot;personal computing&quot; that I do nowadays is mostly done in one of the most
+unremarkable devices that I own: a cheap <a href="https://www.lenovo.com/us/en/p/laptops/lenovo/lenovo-edu-chromebooks/ideapad-duet-3-chromebook-11-inch,-qlc/len101i0034">Chromebook Duet
+3</a>,
+that I bought for around EUR300. I was thinking why, because it is woefully
+underpowered: a <a href="https://www.anandtech.com/show/16696/qualcomm-announces-snapdragon-7c-gen-2-entrylevel-pc-and-chromebook-refresh">Snapdragon 7c Gen
+2</a>,
+a CPU that was already considered slow 3 years ago, coupled with an eMMC for
+storage, that is not much faster than a HDD. At least I have the 8GB RAM
+version instead of the 4GB one.</p>
+<p>It is a hybrid device, one that can be used as either a tablet or laptop, but
+it is compromised experience in both cases: as a tablet, it lacks the better
+touch optimised interface from iOS or Android; as a laptop, you have to depend
+on the stand to adjust the screen, and the detachable keyboard is worse than
+any laptop I have ever owned: getting keys stucked and characters being
+duplicated as a result is a common occurence. It is not so bad that I can't get
+things done though. About the trackpad: its biggest quality is that I never
+feel the need to use the touchscreen in laptop mode, that is to say that it is
+acceptable. Just crank up the pointer speed in ChromeOS settings, otherwise you
+never get anywhere since the trackpad is so small. There is also an active
+stylus, that helped me sometimes when I needed to sign something but otherwise
+I can't comment too much.</p>
+<p>But I really love this device. It is generally the only device that I bring in
+trips nowadays, because while it is compromised it works well enough: I can use
+to consume media in tablet mode (the fact that ChromeOS supports Android apps
+is a plus in those cases), browse the web and even do Linux stuff (more about
+this later). The fact that it is small (the size remembers me of a
+<a href="https://en.wikipedia.org/wiki/Netbook">netbook</a>), lightweight (~1KG, including
+the keyboard), has a good screen (that is bright and HiDPI) and good battery
+life (I don't have numbers but I almost never worry about it) is what makes
+this device the perfect companion to trips.</p>
+<p>Also, it has 2 USB-C ports and supports DisplayPort alt-mode, so it means you
+can charge it, connect to a external display and peripherals, all at the same
+time. Sadly, the maximum output resolution I got was 1080p (2560x1080),
+although some people at Reddit <a href="https://www.reddit.com/r/chromeos/comments/zh27tg/comment/izku724/?utm_source=share&amp;utm_medium=web3x&amp;utm_name=web3xcss&amp;utm_term=1&amp;utm_content=share_button">seems to have
+success</a>
+at 1440p, and the specs suggests it supports 4k. It may be my Dell S3423DWC
+monitor being wonky, the fact that it is Ultrawide or the cable, who knows? I
+even tried to change the monitor to &quot;High Resolution&quot; mode in settings, but to
+no avail.</p>
+<p><em>Update:</em> looking at the <a href="https://www.qualcomm.com/content/dam/qcomm-martech/dm-assets/documents/prod_brief_qcom_sd7c_gen2.pdf">product
+brief</a>
+for Snapdragon 7c Gen 2, it seems it supports up to QHD@60Hz (1440p) for the
+external display, and not 4k. This explains why it doesn't work at maximum
+resolution in my Dell S3423DWC, since while it is 1440p it is Ultrawide, so the
+resolution is bigger than QHD (3440x1440 vs 2560x1440).</p>
+<p>ChromeOS is also really interesting nowadays. To start, it is designed from the
+ground up to be a <a href="https://support.google.com/chromebook/answer/3438631">secure computing
+environment</a>, probably
+the most secure OS for consumers right now. Being a Chrome-first OS makes it a
+compromised experience, for example, it is the only device that I use Chrome as
+my main browser (since I personally prefer Firefox). But having a OS that boots
+fast is great: I never worry about OS updates because I know the device will be
+ready in seconds after a reboot. And the whole desktop experience inside the
+ChromeOS desktop is good, having shortcuts for many operations so you can get
+things done fast, and support for virtual desktops (ChromeOS call it &quot;desks&quot;)
+means you can organise your windows as much as you want.</p>
+<p>And what I think makes ChromeOS really powerful is
+<a href="https://chromeos.dev/en/linux">Crostini</a>, a full Linux VM that you can run
+inside ChromeOS. It runs Debian (it seems you can <a href="https://www.reddit.com/r/Crostini/wiki/howto/run-other-distros/">run other
+distros</a>
+though) with a deep integration with ChromeOS, so you can run even graphical
+programs without issues (including OpenGL!):</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-05/Screenshot_2024-08-05_21.22.29.png"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-05/Screenshot_2024-08-05_21.22.29.png" alt="Fastfetch inside Crostini with gitk running side-by-side."></a></p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-05/Screenshot_2024-08-05_21.39.58.png"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-05/Screenshot_2024-08-05_21.39.58.png" alt="Running glxgears inside Crostini."></a></p>
+<p>This is all thanks to
+<a href="https://chromium.googlesource.com/chromiumos/platform2/+/HEAD/vm_tools/sommelier/README.md">Sommelier</a>,
+a nested Wayland compositor that runs inside Crostini and allow both Wayland
+and X11 applications to be forwarded to ChromeOS. The integration is so good
+that I can run Firefox inside Crostini and works well enough, but sadly Firefox
+is too slow in this device (I am not sure if the issue is ChromeOS or Firefox,
+but I suspect the later since Google does some optimisation per device).</p>
+<p>One interesting tidbit about the OpenGL situation in this device: this seems to
+be the first Chromebook to ship with open source drivers, thanks to Freedreno.
+There is <a href="https://www.youtube.com/watch?v=8mnjSmN03VM">this</a> very interesting
+presentation done by Rob Clark in XDC 2021, that I recommended anyone
+interested in free drivers to watch (the reference design of Duet 3 is
+<a href="https://chromeunboxed.com/chromebook-tablet-snapdragon-7c-homestar-coachz-strongbad">Strongbad</a>).</p>
+<p>The Crostini integration is probably the best VM integration with Linux I ever
+saw in an OS: you can manage files inside the VM, share directories between the
+OS and VM, copy and paste works between the two, GUI applications installed
+inside the VM appear in the ChromeOS menu, memory allocation inside the VM is
+transparent, etc. Even the themes for Linux GUI applications are customised to
+match ChromeOS. It is unironically one of the best Linux desktop experiences I
+ever had.</p>
+<p>Of course I am using Nix, but since the Crostini integration depends on some
+services being configured and installed, I decided to run Nix inside Debian
+instead of NixOS and run <a href="https://nix-community.github.io/home-manager/index.xhtml#sec-install-standalone">Home-Manager
+standalone</a>.
+I recommend checking the official <a href="https://wiki.nixos.org/wiki/Installing_Nix_on_Crostini">NixOS Wiki article about
+Crostini</a>, that details
+how to register applications in ChromeOS (so desktop applications appear in
+menu) and use <a href="https://github.com/nix-community/nixGL">nixGL</a> to make OpenGL
+applications work.</p>
+<p>Like I said at the start of the article, the device is woefully slow thanks to
+its CPU and eMMC. It does mean that, for example, activating my Home-Manager
+configuration takes a while (around 1 minute, vs a few seconds in my laptop).
+But it is much faster than say,
+<a href="https://github.com/nix-community/nix-on-droid-app">nix-on-droid</a>, that the
+last time I tried in a much more powerful device (<a href="https://www.gsmarena.com/xiaomi_pad_5-11042.php">Xiaomi Pad
+5</a>), took 30 minutes until I
+just decided to cancel the operation. Having a proper VM instead of
+<a href="https://wiki.termux.com/wiki/PRoot">proot</a> makes all the difference here.</p>
+<p>I can even do some light programming here: using my
+<a href="https://kokada.dev/blog/troubleshoting-zsh-lag-and-solutions-with-nix">ZSH</a>
+and neovim configuration (including LSP for coding) is reasonable fast. For
+example, I did most of the code that <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">powers this
+blog</a>
+using this Chromebook. If I need more power, I can use the <a href="https://tailscale.com/kb/1267/install-chromebook">Tailscale app for
+Android</a> to connect to any
+other of my hosts via SSH. Yes, the Tailscale app works in Crostini, sadly
+without MagicDNS, so you need to use the internal Tailscale IPs instead.</p>
+<p>Until Google decides to give us a proper VM or user namespaces in Android or
+release a hybrid Chromebook device with better specs, this small Chromebook
+will probably stay as my travel companion, and is one of my favorite devices.</p></summary></entry><entry><title>Make nixd module completion to work anywhere (with Flakes)</title><link href="https://kokada.dev/blog/make-nixd-module-completion-to-work-anywhere-with-flakes/" rel="alternate"/><published>2024-08-04T00:00:00+00:00</published><id>https://kokada.dev/blog/make-nixd-module-completion-to-work-anywhere-with-flakes/</id><summary type="html"><p>If you want the TL;DR, go to the bottom of the post (search for &quot;final
+result&quot;).</p>
+<p>I recently switched from <a href="https://github.com/oxalica/nil">nil</a> to
+<a href="https://github.com/nix-community/nixd">nixd</a> as my LSP of choice for Nix. I
+was curious in <code>nixd</code> for a long time since the fact that it can eval Nix code
+means it can offer much more powerful completion than the <code>nil</code>'s static
+analysis, however it used to be difficult to setup. Nowadays it is much easier,
+basically doing the right thing as long as you have <code>NIX_PATH</code> setup, and you
+get both package and NixOS modules completion.</p>
+<p>Getting Home-Manager modules though needs some setup. The recommended way to
+setup accordingly to the <a href="https://github.com/nix-community/nixd/blob/fe202307eaf7e89c4366ed927af761482a6065c8/nixd/docs/configuration.md">official
+documentation</a>
+is to use the following for Flake based configurations (using neovim
+configuration here, but it should be easy to adapt to other editors):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s2">&#34;import &lt;nixpkgs&gt; { }&#34;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="n">options</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixos</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;(builtins.getFlake (&#34;git+file://&#34; + toString ./.)).nixosConfigurations.miku-nixos.options&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="n">home_manager</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;(builtins.getFlake (&#34;git+file://&#34; + toString ./.)).homeConfigurations.home-linux.options&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">-- ...</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This works, but it should be pretty clear the limitations of using <code>./.</code>: this
+will only work if you open your editor in your <a href="https://github.com/thiagokokada/nix-configs">Nix configuration
+repository</a>. For any other
+repository, <code>nixosConfigurations.miku-nixos</code> or <code>homeConfigurations.home-linux</code>
+will not exist and the completion will not work.</p>
+<p>It may look like this is easy to fix if you have
+<a href="https://nixos.org/manual/nixos/unstable/options#opt-_module.args"><code>specialArgs</code></a>
+(or <code>extraSpecialArgs</code> in Home-Manager) set to have your
+Flakes inputs, but:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1"># By the way, ${self} does not exist in the Flake output by default, you need</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># to explicit add `inherit self` to your outputs:</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># https://discourse.nixos.org/t/who-is-self-in-flake-outputs/31859/4</span>
+</span></span><span class="line"><span class="cl"><span class="n">nix-repl</span><span class="o">&gt;</span> <span class="p">(</span><span class="nb">builtins</span><span class="o">.</span><span class="n">getFlake</span> <span class="s2">&#34;git+file://</span><span class="si">${</span><span class="n">self</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">nixosConfigurations</span><span class="o">.</span><span class="n">miku-linux</span><span class="o">.</span><span class="n">options</span>
+</span></span><span class="line"><span class="cl"><span class="n">error</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="err">…</span> <span class="n">while</span> <span class="n">calling</span> <span class="n">the</span> <span class="err">&#39;</span><span class="n">getFlake&#39;</span> <span class="n">builtin</span>
+</span></span><span class="line"><span class="cl"> <span class="n">at</span> <span class="err">«</span><span class="n">string</span><span class="err">»</span><span class="p">:</span><span class="mi">1</span><span class="p">:</span><span class="mi">2</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="mi">1</span><span class="err">|</span> <span class="p">(</span><span class="nb">builtins</span><span class="o">.</span><span class="n">getFlake</span> <span class="s2">&#34;git+file://</span><span class="si">${</span><span class="n">self</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="err">|</span> <span class="err">^</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="err">…</span> <span class="n">while</span> <span class="n">evaluating</span> <span class="n">the</span> <span class="n">argument</span> <span class="n">passed</span> <span class="n">to</span> <span class="nb">builtins</span><span class="o">.</span><span class="n">getFlake</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">error</span><span class="p">:</span> <span class="n">the</span> <span class="n">string</span> <span class="err">&#39;</span><span class="sd">git+file:///nix/store/avr1lcmznj8ghynh5vj1kakgfdf0zrxx-source&#39;</span> <span class="n">is</span> <span class="n">not</span> <span class="n">allowed</span> <span class="n">to</span> <span class="n">refer</span> <span class="n">to</span> <span class="n">a</span> <span class="n">store</span> <span class="n">path</span> <span class="p">(</span><span class="n">such</span> <span class="n">as</span> <span class="err">&#39;</span><span class="n">avr1lcmznj8ghynh5vj1kakgfdf0zrxx-source&#39;</span><span class="p">)</span>
+</span></span></code></pre><p>Well, it was worth a try. Another option would be to:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">(</span><span class="nb">builtins</span><span class="o">.</span><span class="n">getFlake</span> <span class="s2">&#34;github:thiagokokada/nix-configs&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">nixosConfigurations</span><span class="o">.</span><span class="n">miku-linux</span><span class="o">.</span><span class="n">options</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># Or even something like this</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># However, using ${rev} means this wouldn&#39;t work in dirty Flake repos, since</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># ${rev} is not set in those cases</span>
+</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nb">builtins</span><span class="o">.</span><span class="n">getFlake</span> <span class="s2">&#34;github:thiagokokada/nix-configs/</span><span class="si">${</span><span class="n">rev</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">nixosConfigurations</span><span class="o">.</span><span class="n">miku-linux</span><span class="o">.</span><span class="n">options</span>
+</span></span></code></pre><p>But while it works, it is slow, because it needs network to evaluate (and it is
+impure, since there is no <code>flake.lock</code>).</p>
+<p>The default configuration for <code>nixd</code> makes NixOS completion work even outside
+of my configuration repo, and it is fast. How? I decided to take a look at the
+<code>nixd</code> source code and found
+<a href="https://github.com/nix-community/nixd/blob/d938026c55c7c36a6e79afd9627459160b4924ed/nixd/lib/Controller/LifeTime.cpp#L33C11-L35C76">this</a>
+(formatted here for legibility):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="sr">&lt;nixpkgs&gt;</span> <span class="p">{</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">(</span><span class="n">pkgs</span><span class="o">.</span><span class="n">lib</span><span class="o">.</span><span class="n">evalModules</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">modules</span> <span class="o">=</span> <span class="p">(</span><span class="kn">import</span> <span class="sr">&lt;nixpkgs/nixos/modules/module-list.nix&gt;</span><span class="p">)</span> <span class="o">++</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="p">({</span> <span class="o">...</span> <span class="p">}:</span> <span class="p">{</span> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">hostPlatform</span> <span class="o">=</span> <span class="nb">builtins</span><span class="o">.</span><span class="n">currentSystem</span><span class="p">;</span> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span><span class="o">.</span><span class="n">options</span>
+</span></span></code></pre><p>Interesting, so they're manually loading the modules using <code>evalModules</code>. As I
+said above, it depends in <code>NIX_PATH</code> being correctly set. Can we fix this to
+use our Flake inputs instead? After some tries in the Nix REPL, I got the
+following:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="s2">&#34;</span><span class="si">${</span><span class="n">inputs</span><span class="o">.</span><span class="n">nixpkgs</span><span class="si">}</span><span class="s2">&#34;</span> <span class="p">{</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">(</span><span class="n">pkgs</span><span class="o">.</span><span class="n">lib</span><span class="o">.</span><span class="n">evalModules</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">modules</span> <span class="o">=</span> <span class="p">(</span><span class="kn">import</span> <span class="s2">&#34;</span><span class="si">${</span><span class="n">inputs</span><span class="o">.</span><span class="n">nixpkgs</span><span class="si">}</span><span class="s2">/nixos/modules/module-list.nix&#34;</span><span class="p">)</span> <span class="o">++</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="p">({</span> <span class="o">...</span> <span class="p">}:</span> <span class="p">{</span> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">hostPlatform</span> <span class="o">=</span> <span class="nb">builtins</span><span class="o">.</span><span class="n">currentSystem</span><span class="p">;</span> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span><span class="o">.</span><span class="n">options</span>
+</span></span></code></pre><p>So we can adapt this to the neovim configuration:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">options</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixos</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;(let pkgs = import &#34;${inputs.nixpkgs}&#34; { }; in (pkgs.lib.evalModules { modules = (import &#34;${inputs.nixpkgs}/nixos/modules/module-list.nix&#34;) ++ [ ({...}: { nixpkgs.hostPlatform = builtins.currentSystem;} ) ] ; })).options&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This was easy. But the main issue is Home-Manager. How can we fix it? I needed
+to take a look at the Home-Manager <a href="https://github.com/nix-community/home-manager/blob/master/docs/default.nix#L161-L169">source
+code</a>
+to find the answer:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="s2">&#34;</span><span class="si">${</span><span class="n">inputs</span><span class="o">.</span><span class="n">nixpkgs</span><span class="si">}</span><span class="s2">&#34;</span> <span class="p">{</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="n">lib</span> <span class="o">=</span> <span class="kn">import</span> <span class="s2">&#34;</span><span class="si">${</span><span class="n">inputs</span><span class="o">.</span><span class="n">home-manager</span><span class="si">}</span><span class="s2">/modules/lib/stdlib-extended.nix&#34;</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">lib</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">(</span><span class="n">lib</span><span class="o">.</span><span class="n">evalModules</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">modules</span> <span class="o">=</span> <span class="p">(</span><span class="kn">import</span> <span class="s2">&#34;</span><span class="si">${</span><span class="n">inputs</span><span class="o">.</span><span class="n">home-manager</span><span class="si">}</span><span class="s2">/modules/modules.nix&#34;</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">inherit</span> <span class="n">lib</span> <span class="n">pkgs</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">check</span> <span class="o">=</span> <span class="no">false</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span><span class="o">.</span><span class="n">options</span>
+</span></span></code></pre><p>The interesting part is: Home-Manager has its own extension of the module
+system (including <code>evalModules</code>). This includes e.g.: extra types used in
+Home-Manager only. Also, we need to disable <code>checks</code>, otherwise we will hit
+some validations (e.g.: missing <code>stateVersion</code>). I am not sure if this causes
+any issue for module completion yet, I may set it in the future.</p>
+<p>And for the final result:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;import &#34;${flake.inputs.nixpkgs}&#34; { }&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="n">options</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixos</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;(let pkgs = import &#34;${inputs.nixpkgs}&#34; { }; in (pkgs.lib.evalModules { modules = (import &#34;${inputs.nixpkgs}/nixos/modules/module-list.nix&#34;) ++ [ ({...}: { nixpkgs.hostPlatform = builtins.currentSystem;} ) ] ; })).options&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="n">home_manager</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;(let pkgs = import &#34;${inputs.nixpkgs}&#34; { }; lib = import &#34;${inputs.home-manager}/modules/lib/stdlib-extended.nix&#34; pkgs.lib; in (lib.evalModules { modules = (import &#34;${inputs.home-manager}/modules/modules.nix&#34;) { inherit lib pkgs; check = false; }; })).options&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Yes, it is quite a mouthful, but it makes module completion work in any
+repository, as long as you're using Flakes. And it is fast, since it doesn't
+need any network access. Since we are already here, let's define <code>nixpkgs</code> to
+not depend in the <code>NIX_PATH</code> being set too.</p></summary></entry><entry><title>Troubleshooting: ZSH lag and solutions with Nix</title><link href="https://kokada.dev/blog/troubleshoting-zsh-lag-and-solutions-with-nix/" rel="alternate"/><published>2024-08-01T00:00:00+00:00</published><id>https://kokada.dev/blog/troubleshoting-zsh-lag-and-solutions-with-nix/</id><summary type="html"><p>Inspired by this <a href="https://lock.cmpxchg8b.com/slowterm.html">blog post from
+Tavis</a>, I decided to document my own
+recent journey of reducing terminal (ZSH) lag startup. This post is way less
+interesting than the one from Tavis that uses a debugger to patch applications
+on the fly, but should still be interesting for some. And it also shows how
+powerful Nix can be for some things.</p>
+<p>For context, I have basically 3 systems where I interact with terminal
+frequently:</p>
+<ul>
+<li><a href="https://www.notebookcheck.net/Lenovo-ThinkPad-P14s-Gen-1-Laptop-Review-AMD-workstation-sans-dedicated-GPU.528746.0.html">Thinkpad P14s Gen 1</a>
+running NixOS, with a reasonable fast CPU (<a href="https://www.notebookcheck.net/AMD-Ryzen-7-PRO-4750U-Processor-Benchmarks-and-Specs.464396.0.html">AMD Ryzen 7 PRO
+4750U</a>)
+and disk (NVMe)</li>
+<li><a href="https://everymac.com/systems/apple/macbook_pro/specs/macbook-pro-m1-pro-10-core-cpu-16-core-gpu-16-2021-specs.html">MacBook
+Pro</a>
+with a really fast CPU (M1 Pro) and disk, but of course running macOS, being
+phased-out since this is a job owned machine and I am changing jobs right
+now, but should be replaced with another one soon™</li>
+<li><a href="https://chromeunboxed.com/lenovo-chromebook-duet-3-review-perfect-sequel">Chromebook Duet
+3</a>
+running ChromeOS, with slow CPU (<a href="https://www.notebookcheck.net/Qualcomm-Snapdragon-7c-Gen-2-Processor-Benchmarks-and-Specs.554426.0.html">Snapdragon 7c Gen
+2</a>)
+and disk (eMMC, really?)</li>
+</ul>
+<p>My experience is similar to Tavis, at around 300ms of startup time I don't care
+too much, but around 500ms+ is where I start to notice. I never had any issues
+with startup time in NixOS itself (I had issues with macOS before, but it was
+not actually the fault of macOS), but in the Chromebook it was awful: 600ms+
+with <a href="https://www.instabug.com/blog/understanding-cold-hot-and-warm-app-launch-time">hot
+start</a>,
+while cold start it could take multiple seconds.</p>
+<p>We can check how long ZSH takes to start by using:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> <span class="nb">time</span> zsh -ci <span class="nb">exit</span>
+</span></span><span class="line"><span class="cl"><span class="go">zsh -ic exit 0.04s user 0.10s system 100% cpu 0.143 total
+</span></span></span></code></pre><p>The <code>-i</code> flag here is important, because we are interested in the interactive
+use of ZSH. Without this flag ZSH will ignore your <code>~/.zshrc</code> file, and the
+results will be meaningless.</p>
+<p>To do a more interesting benchmark, we can use
+<a href="https://github.com/sharkdp/hyperfine"><code>hyperfine</code></a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine <span class="s2">&#34;zsh -ic exit&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: zsh -ic exit
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 145.4 ms ± 4.2 ms [User: 49.8 ms, System: 97.3 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 138.6 ms … 155.3 ms 19 runs
+</span></span></span></code></pre><p>Hyperfine will run the command multiple times and take care of things like
+shell startup time. A really great tool to have in your toolbox by the way, but
+I digress.</p>
+<p>So let's do a little time travelling. Going back to commit
+<a href="https://github.com/thiagokokada/nix-configs/tree/b12757f90889653e359a1ab0a8cfd2f90cfabf31"><code>b12757f</code></a>
+from <a href="https://github.com/thiagokokada/nix-configs/">nix-configs</a>. Running
+<code>hyperfine</code> like above from my NixOS laptop, we have:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine <span class="s2">&#34;zsh -ic exit&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: zsh -ic exit
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 218.6 ms ± 5.1 ms [User: 70.6 ms, System: 151.5 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 210.3 ms … 227.0 ms 13 runs
+</span></span></span></code></pre><p>This doesn't look that bad, but let's see the same commit in my Chromebook:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine <span class="s2">&#34;zsh -ic exit&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: zsh -ic exit
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 679.7 ms ± 40.2 ms [User: 230.8 ms, System: 448.5 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 607.3 ms … 737.0 ms 10 runs
+</span></span></span></code></pre><p>Yikes, this is much worse. And those are the results after I retried the
+benchmark (so it is a hot start). The cold start times were above 3s. So let's
+investigate what is happening here. We can profile what is taking time during
+the startup of ZSH using <a href="https://www.bigbinary.com/blog/zsh-profiling">zprof</a>.
+You can add the following in your <code>~/.zshrc</code>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1"># At the top of your ~/.zshrc file</span>
+</span></span><span class="line"><span class="cl">zmodload zsh/zprof
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># At the end of your ~/.zshrc file</span>
+</span></span><span class="line"><span class="cl">zprof
+</span></span></code></pre><p>Or if using Home-Manager, use the
+<a href="https://nix-community.github.io/home-manager/options.xhtml#opt-programs.zsh.zprof.enable"><code>programs.zsh.zprof.enable</code></a>
+option. Once we restart ZSH, we will have something like:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="go">num calls time self name
+</span></span></span><span class="line"><span class="cl"><span class="go">-----------------------------------------------------------------------------------
+</span></span></span><span class="line"><span class="cl"><span class="go"> 1) 1 36.91 36.91 34.29% 30.47 30.47 28.31% (anon) [/home/thiagoko/.zsh/plugins/zim-completion/init.zsh:13]
+</span></span></span><span class="line"><span class="cl"><span class="go"> 2) 1 25.43 25.43 23.63% 25.43 25.43 23.63% (anon) [/home/thiagoko/.zsh/plugins/zim-ssh/init.zsh:6]
+</span></span></span><span class="line"><span class="cl"><span class="go"> 3) 1 22.00 22.00 20.45% 21.92 21.92 20.36% _zsh_highlight_load_highlighters
+</span></span></span><span class="line"><span class="cl"><span class="go"> 4) 1 12.32 12.32 11.45% 12.32 12.32 11.45% autopair-init
+</span></span></span><span class="line"><span class="cl"><span class="go"> 5) 1 6.44 6.44 5.98% 6.44 6.44 5.98% compinit
+</span></span></span><span class="line"><span class="cl"><span class="go"> 6) 1 3.56 3.56 3.31% 3.48 3.48 3.23% prompt_pure_state_setup
+</span></span></span><span class="line"><span class="cl"><span class="go"> 7) 2 3.79 1.89 3.52% 2.85 1.43 2.65% async
+</span></span></span><span class="line"><span class="cl"><span class="go"> 8) 1 0.93 0.93 0.87% 0.93 0.93 0.87% async_init
+</span></span></span><span class="line"><span class="cl"><span class="go"> 9) 6 0.93 0.15 0.86% 0.93 0.15 0.86% is-at-least
+</span></span></span><span class="line"><span class="cl"><span class="go">10) 6 0.67 0.11 0.63% 0.67 0.11 0.63% add-zle-hook-widget
+</span></span></span><span class="line"><span class="cl"><span class="go">11) 1 8.25 8.25 7.66% 0.61 0.61 0.57% prompt_pure_setup
+</span></span></span><span class="line"><span class="cl"><span class="go">12) 1 0.40 0.40 0.37% 0.40 0.40 0.37% (anon) [/nix/store/p1zqypy7600fvfyl1v571bljx2l8zhay-zsh-autosuggestions-0.7.0/share/zsh-autosuggestions/zsh-autosuggestions.zsh:458]
+</span></span></span><span class="line"><span class="cl"><span class="go">13) 5 0.31 0.06 0.29% 0.31 0.06 0.29% add-zsh-hook
+</span></span></span><span class="line"><span class="cl"><span class="go">14) 1 0.60 0.60 0.56% 0.29 0.29 0.27% (anon) [/home/thiagoko/.zsh/plugins/zim-input/init.zsh:5]
+</span></span></span><span class="line"><span class="cl"><span class="go">15) 1 0.21 0.21 0.20% 0.21 0.21 0.20% compdef
+</span></span></span><span class="line"><span class="cl"><span class="go">16) 1 0.10 0.10 0.09% 0.10 0.10 0.09% _zsh_highlight__function_is_autoload_stub_p
+</span></span></span><span class="line"><span class="cl"><span class="go">17) 1 0.26 0.26 0.24% 0.08 0.08 0.08% _zsh_highlight__function_callable_p
+</span></span></span><span class="line"><span class="cl"><span class="go">18) 1 0.08 0.08 0.08% 0.08 0.08 0.08% prompt_pure_is_inside_container
+</span></span></span><span class="line"><span class="cl"><span class="go">19) 1 0.07 0.07 0.07% 0.07 0.07 0.07% _zsh_highlight__is_function_p
+</span></span></span><span class="line"><span class="cl"><span class="go">20) 1 0.01 0.01 0.01% 0.01 0.01 0.01% __wezterm_install_bash_prexec
+</span></span></span><span class="line"><span class="cl"><span class="go">21) 1 0.00 0.00 0.00% 0.00 0.00 0.00% _zsh_highlight_bind_widgets
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="gp">#</span> ...
+</span></span></code></pre><p>I ommited some output for brevit. The first 2 things that shows are from the
+<a href="https://github.com/zimfw/zimfw">zimfw</a>, the framework that I use to configure
+my ZSH (similar to Oh-My-Zsh). I actually don't use <code>zimfw</code> directly, instead I
+just load some modules that I find useful, like the <code>zim-completion</code> and
+<code>zim-ssh</code> that we can see above. By the way, Zim is generally really well
+optimised for startup time, but those 2 modules are kind slow.</p>
+<p>For <a href="https://github.com/zimfw/completion"><code>zim-completion</code></a>, after taking a
+look at it, there isn't much I could do. It seems that the reason
+<code>zim-completion</code> takes so long during startup is because it is trying to decide
+if it needs to recompile the completions (and replacing it with just a naive
+<code>autoload -U compinit &amp;&amp; compinit</code> is even worse for startup performance). I
+may eventually replace it for something else, but I really like what Zim brings
+here, so I decided to not touch it for now.</p>
+<p>However <a href="https://github.com/zimfw/ssh"><code>zim-ssh</code></a> is another history. The only
+reason I used it is to start a <code>ssh-agent</code> and keep it between multiple ZSH
+sessions. It shouldn't have that much influence in startup time. So I took a
+look the code (since it is small, I am reproducing it here):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1">#</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># Set up ssh-agent</span>
+</span></span><span class="line"><span class="cl"><span class="c1">#</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># Don&#39;t do anything unless we can actually use ssh-agent</span>
+</span></span><span class="line"><span class="cl"><span class="o">((</span> <span class="si">${</span><span class="p">+commands[ssh-agent]</span><span class="si">}</span> <span class="o">))</span> <span class="o">&amp;&amp;</span> <span class="o">()</span> <span class="o">{</span>
+</span></span><span class="line"><span class="cl"> ssh-add -l <span class="p">&amp;</span>&gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">((</span> ? <span class="o">==</span> <span class="m">2</span> <span class="o">))</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Unable to contact the authentication agent</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Load stored agent connection info</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">local</span> -r <span class="nv">ssh_env</span><span class="o">=</span><span class="si">${</span><span class="nv">HOME</span><span class="si">}</span>/.ssh-agent
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">[[</span> -r <span class="si">${</span><span class="nv">ssh_env</span><span class="si">}</span> <span class="o">]]</span> <span class="nb">source</span> <span class="si">${</span><span class="nv">ssh_env</span><span class="si">}</span> &gt;/dev/null
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> ssh-add -l <span class="p">&amp;</span>&gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">((</span> ? <span class="o">==</span> <span class="m">2</span> <span class="o">))</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Start agent and store agent connection info</span>
+</span></span><span class="line"><span class="cl"> <span class="o">(</span><span class="nb">umask</span> 066<span class="p">;</span> ssh-agent &gt;! <span class="si">${</span><span class="nv">ssh_env</span><span class="si">}</span><span class="o">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">source</span> <span class="si">${</span><span class="nv">ssh_env</span><span class="si">}</span> &gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Load identities</span>
+</span></span><span class="line"><span class="cl"> ssh-add -l <span class="p">&amp;</span>&gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">((</span> ? <span class="o">==</span> <span class="m">1</span> <span class="o">))</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">local</span> -a zssh_ids
+</span></span><span class="line"><span class="cl"> zstyle -a <span class="s1">&#39;:zim:ssh&#39;</span> ids <span class="s1">&#39;zssh_ids&#39;</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">((</span> <span class="si">${#</span><span class="nv">zssh_ids</span><span class="si">}</span> <span class="o">))</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> ssh-add <span class="si">${</span><span class="nv">HOME</span><span class="si">}</span>/.ssh/<span class="si">${</span><span class="p">^zssh_ids</span><span class="si">}</span> 2&gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">else</span>
+</span></span><span class="line"><span class="cl"> ssh-add 2&gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl"><span class="o">}</span>
+</span></span></code></pre><p>Well, this is bad. Let's assume the common path, where the <code>ssh-agent</code> is
+already running but you open a new shell instance (that doesn't have the
+connection info yet so it will need to load). This will run <code>ssh-add</code> at 4
+times. How long does <code>ssh-add</code> takes to run?</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine -Ni <span class="s2">&#34;ssh-add -l&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: ssh-add -l
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 4.6 ms ± 1.1 ms [User: 2.0 ms, System: 2.0 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 3.4 ms … 8.7 ms 619 runs
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="go"> Warning: Ignoring non-zero exit code.
+</span></span></span></code></pre><p>For those curious, <code>-N</code> disables the Shell usage, that works better when the
+command being tested is too fast.</p>
+<p>In average we have 4x4ms=16ms of startup time. But keep in mind the worst case
+can be much worse. The question is, how can we improve the situation here?</p>
+<p>After taking a look, I decided to write my own code, based in some ideas stolen
+from <a href="https://github.com/ohmyzsh/ohmyzsh/blob/67581c53c6458566e174620361e84b364b9034d2/plugins/ssh-agent/ssh-agent.plugin.zsh">Oh-My-Zsh ssh-agent
+plugin</a>.
+Here is final version of my
+<a href="https://github.com/thiagokokada/nix-configs/blob/e45a888f2bf3ce5644c3966f0b6371414d0291e2/home-manager/cli/ssh/ssh-agent.zsh">code</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl">zmodload zsh/net/socket
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl">_check_agent<span class="o">(){</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">[[</span> -S <span class="s2">&#34;</span><span class="nv">$SSH_AUTH_SOCK</span><span class="s2">&#34;</span> <span class="o">]]</span> <span class="o">&amp;&amp;</span> zsocket <span class="s2">&#34;</span><span class="nv">$SSH_AUTH_SOCK</span><span class="s2">&#34;</span> 2&gt;/dev/null<span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="m">0</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="m">1</span>
+</span></span><span class="line"><span class="cl"><span class="o">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl">_start_agent<span class="o">()</span> <span class="o">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Test if $SSH_AUTH_SOCK is visible, in case we start e.g.: ssh-agent via</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># systemd service</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> _check_agent<span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="m">0</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Get the filename to store/lookup the environment from</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">local</span> -r <span class="nv">ssh_env_cache</span><span class="o">=</span><span class="s2">&#34;</span><span class="nv">$HOME</span><span class="s2">/.ssh-agent&#34;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Check if ssh-agent is already running</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">[[</span> -f <span class="s2">&#34;</span><span class="nv">$ssh_env_cache</span><span class="s2">&#34;</span> <span class="o">]]</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">source</span> <span class="s2">&#34;</span><span class="nv">$ssh_env_cache</span><span class="s2">&#34;</span> &gt; /dev/null
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Test if $SSH_AUTH_SOCK is visible, e.g.: the ssh-agent is still alive</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> _check_agent<span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="m">0</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># start ssh-agent and setup environment</span>
+</span></span><span class="line"><span class="cl"> <span class="o">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">umask</span> <span class="m">066</span>
+</span></span><span class="line"><span class="cl"> ssh-agent -s &gt;! <span class="s2">&#34;</span><span class="nv">$ssh_env_cache</span><span class="s2">&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="o">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">source</span> <span class="s2">&#34;</span><span class="nv">$ssh_env_cache</span><span class="s2">&#34;</span> &gt; /dev/null
+</span></span><span class="line"><span class="cl"><span class="o">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl">_start_agent
+</span></span><span class="line"><span class="cl">unfunction _check_agent _start_agent
+</span></span></code></pre><p>The idea here is simple: using
+<a href="https://zsh.sourceforge.io/Doc/Release/Zsh-Modules.html#The-zsh_002fnet_002fsocket-Module"><code>zsocket</code></a>
+module from ZSH itself to check if the <code>ssh-agent</code> is working instead of
+executing <code>ssh-add -l</code>. The only case we run any program now is to start the
+agent itself if needed. Let's run <code>hyperfine</code> again:</p>
+<pre><code>$ hyperfine &quot;zsh -ic exit&quot;
+Benchmark 1: zsh -ic exit
+ Time (mean ± σ): 188.3 ms ± 8.2 ms [User: 61.1 ms, System: 130.0 ms]
+ Range (min … max): 170.9 ms … 198.4 ms 16 runs
+</code></pre>
+<p>Got a good improvement here already. Let's see <code>zprof</code> again:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="go">num calls time self name
+</span></span></span><span class="line"><span class="cl"><span class="go">-----------------------------------------------------------------------------------
+</span></span></span><span class="line"><span class="cl"><span class="go"> 1) 1 41.23 41.23 48.66% 33.52 33.52 39.56% (anon) [/home/thiagoko/.zsh/plugins/zim-completion/init.zsh:13]
+</span></span></span><span class="line"><span class="cl"><span class="go"> 2) 1 22.23 22.23 26.24% 22.12 22.12 26.10% _zsh_highlight_load_highlighters
+</span></span></span><span class="line"><span class="cl"><span class="go"> 3) 1 8.90 8.90 10.51% 8.90 8.90 10.51% Gautopair-init
+</span></span></span><span class="line"><span class="cl"><span class="go"> 4) 1 7.71 7.71 9.10% 7.71 7.71 9.10% compinit
+</span></span></span><span class="line"><span class="cl"><span class="go"> 5) 1 5.74 5.74 6.77% 5.60 5.60 6.60% prompt_pure_state_setup
+</span></span></span><span class="line"><span class="cl"><span class="go"> 6) 6 1.19 0.20 1.41% 1.19 0.20 1.41% add-zle-hook-widget
+</span></span></span><span class="line"><span class="cl"><span class="go"> 7) 2 1.97 0.99 2.33% 1.14 0.57 1.34% async
+</span></span></span><span class="line"><span class="cl"><span class="go"> 8) 6 0.87 0.15 1.03% 0.87 0.15 1.03% is-at-least
+</span></span></span><span class="line"><span class="cl"><span class="go"> 9) 1 0.84 0.84 0.99% 0.84 0.84 0.99% async_init
+</span></span></span><span class="line"><span class="cl"><span class="go">10) 1 9.30 9.30 10.97% 0.72 0.72 0.84% prompt_pure_setup
+</span></span></span><span class="line"><span class="cl"><span class="go">11) 5 0.63 0.13 0.75% 0.63 0.13 0.75% add-zsh-hook
+</span></span></span><span class="line"><span class="cl"><span class="go">12) 1 0.41 0.41 0.48% 0.41 0.41 0.48% _start_agent
+</span></span></span><span class="line"><span class="cl"><span class="go">13) 1 0.31 0.31 0.37% 0.31 0.31 0.37% (anon) [/nix/store/p1zqypy7600fvfyl1v571bljx2l8zhay-zsh-autosuggestions-0.7.0/share/zsh-autosuggestions/zsh-autosuggestions.zsh:458]
+</span></span></span><span class="line"><span class="cl"><span class="go">14) 1 0.55 0.55 0.64% 0.24 0.24 0.28% (anon) [/home/thiagoko/.zsh/plugins/zim-input/init.zsh:5]
+</span></span></span><span class="line"><span class="cl"><span class="go">15) 1 0.14 0.14 0.16% 0.14 0.14 0.16% prompt_pure_is_inside_container
+</span></span></span><span class="line"><span class="cl"><span class="go">16) 1 0.14 0.14 0.16% 0.14 0.14 0.16% compdef
+</span></span></span><span class="line"><span class="cl"><span class="go">17) 1 0.09 0.09 0.11% 0.09 0.09 0.11% _zsh_highlight__function_is_autoload_stub_p
+</span></span></span><span class="line"><span class="cl"><span class="go">18) 1 0.25 0.25 0.29% 0.08 0.08 0.09% _zsh_highlight__function_callable_p
+</span></span></span><span class="line"><span class="cl"><span class="go">19) 1 0.07 0.07 0.09% 0.07 0.07 0.09% _zsh_highlight__is_function_p
+</span></span></span><span class="line"><span class="cl"><span class="go">20) 1 0.01 0.01 0.01% 0.01 0.01 0.01% __wezterm_install_bash_prexec
+</span></span></span><span class="line"><span class="cl"><span class="go">21) 1 0.01 0.01 0.01% 0.01 0.01 0.01% _zsh_highlight_bind_widgets
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="gp">#</span> ...
+</span></span></code></pre><p>Well, there is nothing interesting here anymore. I mean, <code>zim-completion</code> is
+still the main culprit, but nothing to do for now. Instead of looking at
+<code>zproof</code>, let's take a look at my <code>~/.zshrc</code> instead:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="o">[[</span> <span class="nv">$options</span><span class="o">[</span>zle<span class="o">]</span> <span class="o">=</span> on <span class="o">]]</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">eval</span> <span class="s2">&#34;</span><span class="k">$(</span>/nix/store/sk6wsgp4h477baxypksz9rl8ldwwh9yg-fzf-0.54.0/bin/fzf --zsh<span class="k">)</span><span class="s2">&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="k">fi</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl">/nix/store/x3yblr73r5x76dmaanjk3333mvzxc49r-any-nix-shell-1.2.1/bin/any-nix-shell zsh <span class="p">|</span> <span class="nb">source</span> /dev/stdin
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"><span class="nb">eval</span> <span class="s2">&#34;</span><span class="k">$(</span>/nix/store/330d6k81flfs6w46b44afmncxk57qggv-zoxide-0.9.4/bin/zoxide init zsh <span class="k">)</span><span class="s2">&#34;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"><span class="nb">eval</span> <span class="s2">&#34;</span><span class="k">$(</span>/nix/store/8l9j9kdv9m0z0s30lp4yvrc9s5bcbgmx-direnv-2.34.0/bin/direnv hook zsh<span class="k">)</span><span class="s2">&#34;</span>
+</span></span></code></pre><p>So you see, starting all those programs during ZSH startup can hurt the shell
+startup considerable. Not necessary for commands fast like <code>fzf</code> (that is
+written in Go), but let's see
+<a href="https://github.com/haslersn/any-nix-shell"><code>any-nix-shell</code></a>, that is written
+in shell script:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine <span class="s2">&#34;any-nix-shell zsh&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: any-nix-shell zsh
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 16.0 ms ± 1.8 ms [User: 5.6 ms, System: 10.5 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 11.3 ms … 20.3 ms 143 runs
+</span></span></span></code></pre><p>This is bad, consistently bad actually. Even for commands that are fast, keep
+in mind that there is a difference between the cold and hot start again. For
+example, <code>fzf</code>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine -N <span class="s2">&#34;fzf --zsh&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: fzf --zsh
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 2.9 ms ± 0.9 ms [User: 0.6 ms, System: 2.3 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 1.7 ms … 6.8 ms 1113 runs
+</span></span></span></code></pre><p>See the range? While 1.7ms is something that is probably difficult to notice,
+6.8ms can be noticiable, especially if this accumulates with other slow
+starting apps.</p>
+<p>And the thing is, all those commands are just generating in the end a fixed
+output, at least for the current version of the program. Can we pre-generate
+them instead? If using Nix, of course we can:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1"># You need to disable the default integration</span>
+</span></span><span class="line"><span class="cl"><span class="n">programs</span><span class="o">.</span><span class="n">direnv</span><span class="o">.</span><span class="n">enableZshIntegration</span> <span class="err">=</span> <span class="no">false</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="n">programs</span><span class="o">.</span><span class="n">fzf</span><span class="o">.</span><span class="n">enableZshIntegration</span> <span class="err">=</span> <span class="no">false</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="n">programs</span><span class="o">.</span><span class="n">zoxide</span><span class="o">.</span><span class="n">enableZshIntegration</span> <span class="err">=</span> <span class="no">false</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="n">programs</span><span class="o">.</span><span class="n">zsh</span><span class="o">.</span><span class="n">initExtra</span> <span class="err">=</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># bash</span>
+</span></span><span class="line"><span class="cl"> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> # any-nix-shell
+</span></span></span><span class="line"><span class="cl"><span class="s1"> source </span><span class="si">${</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span><span class="o">.</span><span class="n">runCommand</span> <span class="s2">&#34;any-nix-shell-zsh&#34;</span> <span class="p">{</span> <span class="p">}</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> </span><span class="si">${</span><span class="n">lib</span><span class="o">.</span><span class="n">getExe</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">any-nix-shell</span><span class="si">}</span><span class="s1"> zsh &gt; $out
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span>
+</span></span><span class="line"><span class="cl"> <span class="si">}</span><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> # fzf
+</span></span></span><span class="line"><span class="cl"><span class="s1"> source </span><span class="si">${</span><span class="n">config</span><span class="o">.</span><span class="n">programs</span><span class="o">.</span><span class="n">fzf</span><span class="o">.</span><span class="n">package</span><span class="si">}</span><span class="s1">/share/fzf/completion.zsh
+</span></span></span><span class="line"><span class="cl"><span class="s1"> source </span><span class="si">${</span><span class="n">config</span><span class="o">.</span><span class="n">programs</span><span class="o">.</span><span class="n">fzf</span><span class="o">.</span><span class="n">package</span><span class="si">}</span><span class="s1">/share/fzf/key-bindings.zsh
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> # zoxide
+</span></span></span><span class="line"><span class="cl"><span class="s1"> source </span><span class="si">${</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span><span class="o">.</span><span class="n">runCommand</span> <span class="s2">&#34;zoxide-init-zsh&#34;</span> <span class="p">{</span> <span class="p">}</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> </span><span class="si">${</span><span class="n">lib</span><span class="o">.</span><span class="n">getExe</span> <span class="n">config</span><span class="o">.</span><span class="n">programs</span><span class="o">.</span><span class="n">zoxide</span><span class="o">.</span><span class="n">package</span><span class="si">}</span><span class="s1"> init zsh &gt; $out
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span>
+</span></span><span class="line"><span class="cl"> <span class="si">}</span><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> # direnv
+</span></span></span><span class="line"><span class="cl"><span class="s1"> source </span><span class="si">${</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span><span class="o">.</span><span class="n">runCommand</span> <span class="s2">&#34;direnv-hook-zsh&#34;</span> <span class="p">{</span> <span class="p">}</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> </span><span class="si">${</span><span class="n">lib</span><span class="o">.</span><span class="n">getExe</span> <span class="n">config</span><span class="o">.</span><span class="n">programs</span><span class="o">.</span><span class="n">direnv</span><span class="o">.</span><span class="n">package</span><span class="si">}</span><span class="s1"> hook zsh &gt; $out
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span>
+</span></span><span class="line"><span class="cl"> <span class="si">}</span><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span></code></pre><p>So we can use <code>pkgs.runCommand</code> to run those commands during build time and
+<code>source</code> the result. <code>fzf</code> actually doesn't need this since we have the files
+already generated in the package. I think this is one of those things that
+really shows the power of Nix: I wouldn't do something similar if I didn't use
+Nix because the risk of breaking something later is big (e.g.: forgetting to
+update the generated files), but Nix makes those things trivial.</p>
+<p>Let's run <code>hyperfine</code> again:</p>
+<pre><code>$ hyperfine &quot;zsh -ic exit&quot;
+Benchmark 1: zsh -ic exit
+ Time (mean ± σ): 162.3 ms ± 4.9 ms [User: 52.7 ms, System: 111.1 ms]
+ Range (min … max): 153.0 ms … 173.4 ms 19 runs
+</code></pre>
+<p>Another good improvement. The last change I did is switching between
+<a href="https://github.com/zsh-users/zsh-syntax-highlighting"><code>zsh-syntax-highlighting</code></a>
+to
+<a href="https://github.com/zdharma-continuum/fast-syntax-highlighting"><code>zsh-fast-syntax-highlighting</code></a>,
+that is supposed to be faster and have better highlighting too. I got that from
+<code>_zsh_highlight_load_highlighters</code> using 26% of the time from my <code>zprof</code> above.
+And for the final <code>hyperfine</code> in my laptop:</p>
+<pre><code>$ hyperfine &quot;zsh -ic exit&quot;
+Benchmark 1: zsh -ic exit
+ Time (mean ± σ): 138.3 ms ± 7.1 ms [User: 47.5 ms, System: 91.9 ms]
+ Range (min … max): 123.8 ms … 157.9 ms 21 runs
+</code></pre>
+<p>A ~36% improvement, not bad. Let's see how it fares in my Chromebook:</p>
+<pre><code>$ hyperfine &quot;zsh -ic exit&quot;
+Benchmark 1: zsh -ic exit
+ Time (mean ± σ): 278.2 ms ± 46.9 ms [User: 88.0 ms, System: 184.8 ms]
+ Range (min … max): 204.7 ms … 368.5 ms 11 runs
+</code></pre>
+<p>An even more impressive ~59% improvement. And yes, the shell startup now feels
+much better.</p></summary></entry><entry><title>Quick bits: realise Nix symlinks</title><link href="https://kokada.dev/blog/quick-bits-realise-nix-symlinks/" rel="alternate"/><published>2024-08-01T00:00:00+00:00</published><id>https://kokada.dev/blog/quick-bits-realise-nix-symlinks/</id><summary type="html"><p>When you are using Nix, especially with
+<a href="https://github.com/nix-community/home-manager/">Home-Manager</a>, there are times
+when you want to test something or maybe debug some issue in your
+configuration. Those times it would be really convenient if you could avoid a
+rebuild of your Home-Manager configuration, since this takes time until
+evaluation and activation.</p>
+<p>For those times I have this small script in my Nix configuration called
+<code>realise-symlinks</code>, that is defined as:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span> <span class="n">pkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"><span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">realise-symlink</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">writeShellApplication</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;realise-symlink&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">runtimeInputs</span> <span class="o">=</span> <span class="k">with</span> <span class="n">pkgs</span><span class="p">;</span> <span class="p">[</span> <span class="n">coreutils</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="n">text</span> <span class="o">=</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> for file in &#34;$@&#34;; do
+</span></span></span><span class="line"><span class="cl"><span class="s1"> if [[ -L &#34;$file&#34; ]]; then
+</span></span></span><span class="line"><span class="cl"><span class="s1"> if [[ -d &#34;$file&#34; ]]; then
+</span></span></span><span class="line"><span class="cl"><span class="s1"> tmpdir=&#34;</span><span class="se">&#39;&#39;$</span><span class="s1">{file}.tmp&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> mkdir -p &#34;$tmpdir&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> cp --verbose --recursive &#34;$file&#34;/* &#34;$tmpdir&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> unlink &#34;$file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> mv &#34;$tmpdir&#34; &#34;$file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> chmod --changes --recursive +w &#34;$file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> else
+</span></span></span><span class="line"><span class="cl"><span class="s1"> cp --verbose --remove-destination &#34;$(readlink &#34;$file&#34;)&#34; &#34;$file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> chmod --changes +w &#34;$file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> fi
+</span></span></span><span class="line"><span class="cl"><span class="s1"> else
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &gt;&amp;2 echo &#34;Not a symlink: $file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> exit 1
+</span></span></span><span class="line"><span class="cl"><span class="s1"> fi
+</span></span></span><span class="line"><span class="cl"><span class="s1"> done
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="k">in</span>
+</span></span><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">home</span><span class="o">.</span><span class="n">packages</span> <span class="o">=</span> <span class="p">[</span> <span class="n">realise-symlink</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>The idea of this script is that you can call it against a symlink against Nix
+store and it will realise, e.g.: convert to an &quot;actual&quot; file, e.g.:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ls -lah .zshrc
+</span></span><span class="line"><span class="cl"><span class="go">lrwxrwxrwx 1 thiagoko users 69 Aug 1 00:10 .zshrc -&gt; /nix/store/glz018yyh0qfqc9lywx1yhr7c3l96lv7-home-manager-files/.zshrc
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> realise-symlink .zshrc
+</span></span><span class="line"><span class="cl"><span class="go">removed &#39;.zshrc&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">&#39;/nix/store/glz018yyh0qfqc9lywx1yhr7c3l96lv7-home-manager-files/.zshrc&#39; -&gt; &#39;.zshrc&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;.zshrc&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> ls -lah .zshrc
+</span></span><span class="line"><span class="cl"><span class="go">-rw-r--r-- 1 thiagoko users 5.8K Aug 1 00:16 .zshrc
+</span></span></span></code></pre><p>It also add write permissions to the resulting file, to make it easier to edit.
+By the way, it also works with directories:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ls -lah zim-completion
+</span></span><span class="line"><span class="cl"><span class="go">lrwxrwxrwx 1 thiagoko users 90 Aug 1 00:10 zim-completion -&gt; /nix/store/glz018yyh0qfqc9lywx1yhr7c3l96lv7-home-manager-files/.zsh/plugins/zim-completion
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> realise-symlink zim-completion
+</span></span><span class="line"><span class="cl"><span class="go">&#39;zim-completion/init.zsh&#39; -&gt; &#39;zim-completion.tmp/init.zsh&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">&#39;zim-completion/init.zsh.zwc&#39; -&gt; &#39;zim-completion.tmp/init.zsh.zwc&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">&#39;zim-completion/LICENSE&#39; -&gt; &#39;zim-completion.tmp/LICENSE&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">&#39;zim-completion/README.md&#39; -&gt; &#39;zim-completion.tmp/README.md&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;zim-completion/init.zsh&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;zim-completion/init.zsh.zwc&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;zim-completion/LICENSE&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;zim-completion/README.md&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> ls -lah zim-completion
+</span></span><span class="line"><span class="cl"><span class="go">total 28K
+</span></span></span><span class="line"><span class="cl"><span class="go">drwxr-xr-x 1 thiagoko users 72 Aug 1 00:18 .
+</span></span></span><span class="line"><span class="cl"><span class="go">drwxr-xr-x 1 thiagoko users 130 Aug 1 00:18 ..
+</span></span></span><span class="line"><span class="cl"><span class="go">-rw-r--r-- 1 thiagoko users 5.3K Aug 1 00:18 init.zsh
+</span></span></span><span class="line"><span class="cl"><span class="go">-rw-r--r-- 1 thiagoko users 12K Aug 1 00:18 init.zsh.zwc
+</span></span></span><span class="line"><span class="cl"><span class="go">-rw-r--r-- 1 thiagoko users 1.3K Aug 1 00:18 LICENSE
+</span></span></span><span class="line"><span class="cl"><span class="go">-rw-r--r-- 1 thiagoko users 2.2K Aug 1 00:18 README.md
+</span></span></span></code></pre><p>After you finish whatever you are testing, to return to your configuration you
+can just delete those files and re-run your Home-Manager activation:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> rm -rf .zshrc
+</span></span><span class="line"><span class="cl"><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> sudo systemctl restart home-manager-&lt;user&gt;.service <span class="c1"># or `home-manager switch`</span>
+</span></span><span class="line"><span class="cl"><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> ls -lah .zshrc
+</span></span><span class="line"><span class="cl"><span class="go">lrwxrwxrwx 1 thiagoko users 69 Aug 1 00:20 .zshrc -&gt; /nix/store/glz018yyh0qfqc9lywx1yhr7c3l96lv7-home-manager-files/.zshrc
+</span></span></span></code></pre><p>It even works with system files (i.e.: NixOS):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> sudo realise-symlink /etc/nix/nix.conf
+</span></span><span class="line"><span class="cl"><span class="go">[sudo] password for thiagoko:
+</span></span></span><span class="line"><span class="cl"><span class="go">removed &#39;nix.conf&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">&#39;/etc/static/nix/nix.conf&#39; -&gt; &#39;nix.conf&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;nix.conf&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span></code></pre><p>But I never needed for this case since it is more rare to me to experiment with
+OS level configuration.</p></summary></entry><entry><title>Generating YAML files with Nix</title><link href="https://kokada.dev/blog/generating-yaml-files-with-nix/" rel="alternate"/><published>2024-07-31T00:00:00+00:00</published><id>https://kokada.dev/blog/generating-yaml-files-with-nix/</id><summary type="html"><p>I hate YAML. Instead of writing an essay on why I hate YAML, I can just link to
+<a href="https://noyaml.com/">noyaml.com</a>. In my personal projects I will never use it,
+preferring either JSON, <a href="https://toml.io/en/">TOML</a> or even plain old
+<a href="https://en.wikipedia.org/wiki/INI_file">INI</a> files depending on the use case.
+However the ship has sailed already, there are tons of projects everywhere that
+uses YAML: from most CI systems (<a href="https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions">GitHub
+Actions</a>,
+<a href="https://circleci.com/docs/introduction-to-yaml-configurations/">CircleCI</a>,
+<a href="https://docs.travis-ci.com/user/build-config-yaml">Travis</a>, <em>et tu</em>
+<a href="https://man.sr.ht/builds.sr.ht/">builds.sr.ht</a>), to
+<a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/">Kubernetes</a>,
+or in almost every
+<a href="https://guides.rubyonrails.org/configuring.html#configuring-a-database">Rails</a>
+application.</p>
+<p>One way to avoid at least some issues with the language is to write YAML in
+another language. I will show my solution in one of my <a href="https://github.com/thiagokokada/nix-configs/">personal
+repositories</a>, writing Nix to
+generate GitHub Actions configuration files. Bonus points for validating the
+result against the schema of GitHub Actions, so the famous &quot;this is supposed to
+be string instead of a list of strings&quot; is gone.</p>
+<p>Let's start with the basics: YAML is supposed to be a <a href="https://stackoverflow.com/a/1729545">superset of
+JSON</a>. What that means is that a JSON file
+<a href="https://yaml.org/spec/1.2-old/spec.html#id2759572">can be parsed</a> by a YAML
+parser. And Nix itself generates JSON natively, after all, Nix can be imagined
+as <a href="https://nix.dev/tutorials/nix-language.html">&quot;JSON with functions&quot;</a>.</p>
+<p>To make things easier, I will assume that you have the <code>nix-commands</code> and
+<code>flakes</code> enabled as <code>experimental-features</code> in your Nix configuration. If not,
+go <a href="https://wiki.nixos.org/wiki/Flakes">here</a>.</p>
+<p>Using the <code>nix eval</code> command, we can generate a JSON expression from Nix by:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix <span class="nb">eval</span> --expr <span class="s1">&#39;{ foo = &#34;bar&#34;; }&#39;</span> --json
+</span></span><span class="line"><span class="cl"><span class="go">{&#34;foo&#34;:&#34;bar&#34;}
+</span></span></span></code></pre><p>However, typing long excerpts of Nix code inside the console would be
+impractical. We can write the following code inside a <code>foo.nix</code> file instead:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">foo</span> <span class="o">=</span> <span class="s2">&#34;bar&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>And:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix <span class="nb">eval</span> --file foo.nix --json
+</span></span><span class="line"><span class="cl"><span class="go">{&#34;foo&#34;:&#34;bar&#34;}
+</span></span></span></code></pre><p>While you can use a JSON output as an input for YAML parsers, it is probably
+not the <a href="https://metacpan.org/pod/JSON::XS#JSON-and-YAML">best idea</a>. Sadly (or
+maybe not), Nix has no native functionality to export data to YAML. However,
+since we are using Nix, it is trivial to use <code>nixpkgs</code> to use some program to
+convert from JSON to YAML.</p>
+<p>To start, let's create a new directory, move our <code>foo.nix</code> file to it, create a
+new <code>flake.nix</code> file and put the following contents:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">description</span> <span class="o">=</span> <span class="s2">&#34;Generate YAML files with Nix&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">inputs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">url</span> <span class="o">=</span> <span class="s2">&#34;github:NixOS/nixpkgs/nixos-unstable&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">outputs</span> <span class="o">=</span> <span class="p">{</span> <span class="n">nixpkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">packages</span><span class="o">.</span><span class="n">x86_64-linux</span> <span class="o">=</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="k">inherit</span> <span class="p">(</span><span class="n">nixpkgs</span><span class="p">)</span> <span class="n">lib</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="n">nixpkgs</span> <span class="p">{</span> <span class="n">system</span> <span class="o">=</span> <span class="s2">&#34;x86_64-linux&#34;</span><span class="p">;</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">toYAML</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">runCommand</span> <span class="s2">&#34;toYAML&#34;</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">buildInputs</span> <span class="o">=</span> <span class="k">with</span> <span class="n">pkgs</span><span class="p">;</span> <span class="p">[</span> <span class="n">yj</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="n">json</span> <span class="o">=</span> <span class="nb">builtins</span><span class="o">.</span><span class="n">toJSON</span> <span class="p">(</span><span class="kn">import</span> <span class="sr">./go.nix</span><span class="p">);</span>
+</span></span><span class="line"><span class="cl"> <span class="n">passAsFile</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;json&#34;</span> <span class="p">];</span> <span class="c1"># will be available as `$jsonPath`</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> mkdir -p $out
+</span></span></span><span class="line"><span class="cl"><span class="s1"> yj -jy &lt; &#34;$jsonPath&#34; &gt; $out/go.yaml
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>We are loading the <code>./foo.nix</code> as a Nix file, converting it to JSON with
+<code>builtins.toJSON</code> function, and finally, using <code>pkgs.runCommand</code> and its
+<code>passAsFile</code> option to load the contents of the JSON file into
+<a href="https://github.com/sclevine/yj">yj</a>, that converts between serialisation
+formats (<code>-jy</code> flag means &quot;JSON to YAML&quot;). The reason I choose <code>yj</code> is mostly
+because it is a single binary Go program, but you can use whatever you prefer.</p>
+<p>By the way, there is a
+<a href="https://github.com/NixOS/nixpkgs/blob/9f918d616c5321ad374ae6cb5ea89c9e04bf3e58/lib/generators.nix#L805"><code>lib.generators.toYAML</code></a>
+inside <code>nixpkgs.lib</code>, but as of the day of this post it only calls
+<code>lib.strings.toJSON</code> (that in turn, calls <code>builtins.toJSON</code>). So it doesn't
+really help here. Another option would be <code>pkgs.formats.yaml.generate</code>, that
+converts between formats, but it calls
+<a href="https://github.com/NixOS/nixpkgs/blob/008ceae1a2b47a84d7aa01e55f8468272c70b9ee/pkgs/pkgs-lib/formats.nix#L77-L84"><code>remarshal</code></a>
+(in Python), so not my favorite choice.</p>
+<p>If we run the following commands, we can see the result:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix build .#packages.x86_64-linux.toYAML
+</span></span><span class="line"><span class="cl"><span class="gp">$</span> cat result/foo.yaml
+</span></span><span class="line"><span class="cl"><span class="go">foo: bar
+</span></span></span></code></pre><p>That is the basic idea. To have a more realistic example, let's convert the
+<a href="https://github.com/thiagokokada/blog/blob/4e3f25485c6682f3e066b219df2290934bc0d256/.github/workflows/go.yml"><code>go.yml</code></a>,
+that builds this blog, to Nix:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;Go&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">on</span><span class="o">.</span><span class="n">push</span><span class="o">.</span><span class="n">branches</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;main&#34;</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">jobs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">build</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">runs-on</span> <span class="o">=</span> <span class="s2">&#34;ubuntu-latest&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">permissions</span><span class="o">.</span><span class="n">contents</span> <span class="o">=</span> <span class="s2">&#34;write&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">steps</span> <span class="o">=</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span> <span class="n">uses</span> <span class="o">=</span> <span class="s2">&#34;actions/checkout@v4&#34;</span><span class="p">;</span> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;Set up Go&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">uses</span> <span class="o">=</span> <span class="s2">&#34;actions/checkout@v4&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;with&#34;</span><span class="o">.</span><span class="n">go-version</span> <span class="o">=</span> <span class="s2">&#34;1.21&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;Update&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">run</span> <span class="o">=</span> <span class="s2">&#34;make&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;Publish&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">run</span> <span class="o">=</span> <span class="s2">&#34;make publish&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">env</span><span class="o">.</span><span class="n">MATAROA_TOKEN</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span><span class="se">&#39;&#39;$</span><span class="s1">{{ secrets.MATAROA_TOKEN }}&#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;Commit&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">uses</span> <span class="o">=</span> <span class="s2">&#34;stefanzweifel/git-auto-commit-action@v5&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;with&#34;</span><span class="o">.</span><span class="n">commit_message</span> <span class="o">=</span> <span class="s2">&#34;README/rss:update&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Some interesting things to highlight: <code>with</code> is a reserved word in Nix, so we
+need to quote it. Not a problem, but something to be aware. And the template
+string in GitHub Actions uses the same <code>${}</code> that Nix uses, so we need to
+escape.</p>
+<p>And after running the following commands:</p>
+<pre><code>$ nix build .#packages.x86_64-linux.toYAML
+$ cat result/go.yaml
+jobs:
+ build:
+ permissions:
+ contents: write
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set up Go
+ uses: actions/checkout@v4
+ with:
+ go-version: &quot;1.21&quot;
+ - name: Update
+ run: make
+ - env:
+ MATAROA_TOKEN: ${{ secrets.MATAROA_TOKEN }}
+ name: Publish
+ run: make publish
+ - name: Commit
+ uses: stefanzweifel/git-auto-commit-action@v5
+ with:
+ commit_message: README/rss:update
+name: Go
+&quot;on&quot;:
+ push:
+ branches:
+ - main
+</code></pre>
+<p>Yes, the keys are not in the same order as we defined, since Nix, like most
+programming languages (with the exception of
+<a href="https://mail.python.org/pipermail/python-dev/2017-December/151283.html">Python</a>),
+do not guarantee the insertion order in maps/dicts/attrsets/whatever. But I
+really hope whatever is consuming your YAML is not relying in the order the
+keys are defined (this would be more cursed than YAML already is).</p>
+<p>So that is basically it. For the bonus points that I talked at the start of the
+post, we can modify <code>pkgs.runCommand</code> to run some kind of validator. I use
+<a href="https://github.com/mpalmer/action-validator"><code>action-validator</code></a>, one that I
+particularly packaged in
+<a href="https://github.com/NixOS/nixpkgs/pull/260217">nixpkgs</a> to use in those cases.
+But you could use e.g.: a validator of Kubernetes YAML. Or a generic YAML lint
+like this <a href="https://github.com/adrienverge/yamllint">one</a>. The possibilities are
+endless.</p>
+<p>Let's modify our <code>flake.nix</code> to add the validation:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"> <span class="n">outputs</span> <span class="o">=</span> <span class="p">{</span> <span class="n">nixpkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">packages</span><span class="o">.</span><span class="n">x86_64-linux</span> <span class="o">=</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="k">inherit</span> <span class="p">(</span><span class="n">nixpkgs</span><span class="p">)</span> <span class="n">lib</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="n">nixpkgs</span> <span class="p">{</span> <span class="n">system</span> <span class="o">=</span> <span class="s2">&#34;x86_64-linux&#34;</span><span class="p">;</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">toYAML</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">runCommand</span> <span class="s2">&#34;toYAML&#34;</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">buildInputs</span> <span class="o">=</span> <span class="k">with</span> <span class="n">pkgs</span><span class="p">;</span> <span class="p">[</span> <span class="n">action-validator</span> <span class="n">yj</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="n">json</span> <span class="o">=</span> <span class="nb">builtins</span><span class="o">.</span><span class="n">toJSON</span> <span class="p">(</span><span class="kn">import</span> <span class="sr">./go.nix</span><span class="p">);</span>
+</span></span><span class="line"><span class="cl"> <span class="n">passAsFile</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;json&#34;</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> mkdir -p $out
+</span></span></span><span class="line"><span class="cl"><span class="s1"> yj -jy &lt; &#34;$jsonPath&#34; &gt; $out/go.yaml
+</span></span></span><span class="line"><span class="cl"><span class="s1"> action-validator -v $out/go.yaml
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>And let's add an error in our <code>go.nix</code> file:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gh">diff --git a/go.nix b/go.nix
+</span></span></span><span class="line"><span class="cl"><span class="gh">index 25e0596..8c00033 100644
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span><span class="gd">--- a/go.nix
+</span></span></span><span class="line"><span class="cl"><span class="gd"></span><span class="gi">+++ b/go.nix
+</span></span></span><span class="line"><span class="cl"><span class="gi"></span><span class="gu">@@ -5,7 +5,7 @@
+</span></span></span><span class="line"><span class="cl"><span class="gu"></span> jobs = {
+</span></span><span class="line"><span class="cl"> build = {
+</span></span><span class="line"><span class="cl"> runs-on = &#34;ubuntu-latest&#34;;
+</span></span><span class="line"><span class="cl"><span class="gd">- permissions.contents = &#34;write&#34;;
+</span></span></span><span class="line"><span class="cl"><span class="gd"></span><span class="gi">+ permissions.contents = [ &#34;write&#34; ];
+</span></span></span><span class="line"><span class="cl"><span class="gi"></span> steps = [
+</span></span><span class="line"><span class="cl"> { uses = &#34;actions/checkout@v4&#34;; }
+</span></span><span class="line"><span class="cl"> {
+</span></span></code></pre><p>Finally, let's try to build our YAML file again:</p>
+<pre><code>$ nix build .#packages.x86_64-linux.toYAML
+error: builder for '/nix/store/j8wr6j1pvyf986sf74hqw8k31lvlzac5-toYAML.drv' failed with exit code 1;
+ last 25 log lines:
+ &gt; &quot;Additional property 'runs-on' is not allowed&quot;,
+ &gt; ),
+ &gt; path: &quot;/jobs/build&quot;,
+ &gt; title: &quot;Property conditions are not met&quot;,
+ &gt; },
+ &gt; Properties {
+ &gt; code: &quot;properties&quot;,
+ &gt; detail: Some(
+ &gt; &quot;Additional property 'steps' is not allowed&quot;,
+ &gt; ),
+ &gt; path: &quot;/jobs/build&quot;,
+ &gt; title: &quot;Property conditions are not met&quot;,
+ &gt; },
+ &gt; Required {
+ &gt; code: &quot;required&quot;,
+ &gt; detail: None,
+ &gt; path: &quot;/jobs/build/uses&quot;,
+ &gt; title: &quot;This property is required&quot;,
+ &gt; },
+ &gt; ],
+ &gt; },
+ &gt; ],
+ &gt; },
+ &gt; ],
+ &gt; }
+ For full logs, run 'nix log /nix/store/j8wr6j1pvyf986sf74hqw8k31lvlzac5-toYAML.drv'.
+</code></pre>
+<p>Yes, the output of <code>action-validator</code> is awfully verbose, but it is still
+better than making <a href="https://x.com/eric_sink/status/1430954572848287744">&quot;8 commits/push in one
+hour&quot;</a>.</p>
+<p>If you are interested in how a more advantage usage of this technique is,
+including usage of functions and constants to share common steps between
+different actions, please take a look at the
+<a href="https://github.com/thiagokokada/nix-configs/tree/master/actions">actions</a>
+(<a href="https://github.com/thiagokokada/nix-configs/tree/fbbc8f935cc7f774f691196e1612bbf7dd2054b5/actions">permalink</a>)
+in my <code>nix-config</code> repository.</p></summary></entry><entry><title>First impressions: FPGBC</title><link href="https://kokada.dev/blog/first-impressions-fpgbc/" rel="alternate"/><published>2024-07-30T00:00:00+00:00</published><id>https://kokada.dev/blog/first-impressions-fpgbc/</id><summary type="html"><p>Here is something for nostalgia: I just put together a <a href="https://en.wikipedia.org/wiki/Game_Boy_Color">Game Boy
+Color</a> made of completely new
+parts for a friend: here is the
+<a href="https://funnyplaying.com/products/fpgbc-kit">FPGBC</a>.</p>
+<p>The <em>FP</em> part of the name comes from
+<a href="https://en.wikipedia.org/wiki/Field-programmable_gate_array">FPGA</a>, because
+instead of software emulation this device use FPGA to reproduce the device.
+While I am not convinced that FPGA is necessary more accurate than a good
+software emulator, one advantage of FPGA is the (possible) lower input latency
+thanks to the avoidance of complexity to handle the user input (e.g.: the
+Operational System). A quick playthrough against <a href="https://en.wikipedia.org/wiki/Motocross_Maniacs">Motocross
+Maniacs</a> seems to be fine, but
+I can't see much difference from my <a href="https://retrogamecorps.com/2022/05/15/miyoo-mini-v2-guide/">Miyoo
+Mini+</a> (I will do
+more comparisons between the two devices later), that is a software emulation
+device.</p>
+<p>But I think focusing in accuracy is wrong, the main reason of getting a device
+like this one is for nostalgia, and this definitely hit the mark. The quality
+of the case is as good as I remember the original, and most of the details are
+replicate perfectly, including reproduction stickers in the back of the device.
+The only differences that I can find is the usage of USB-C port for charging in
+place of the barrel jack power adapter (thanks!), and the fact that the screen
+bezels are smaller compared to the original (because the screen is bigger) and
+doesn't include the Game Boy Color logo (that is fine in my opinion, since it
+would look weird in the fine bezels). It even has a supposedly working <a href="https://en.wikipedia.org/wiki/Game_Link_Cable">Link
+Cable</a> (I don't have another
+Game Boy to test). Sadly it is missing the infrared sensor, but the usage of
+that was pretty limited anyway.</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_175245569.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_175245569.jpg" alt="FPGBC running Tetris."></a></p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_175131157.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_175131157.jpg" alt="Back of FPGBC. It includes even reproduction stickers of the original."></a></p>
+<p>So how well does it work? I can't say for sure. I don't have any original games
+with me, so I am relying in backups and a
+<a href="https://en.wikipedia.org/wiki/Flashcard">flashcard</a> for now. Many games that I
+tested works fine, a few of them have graphical issues that can be fixed in the
+menu (more about it later), and some of them doesn't boot. But I don't know if
+the issue with the games not booting are because of the roms, the flashcard or
+the device itself.</p>
+<p>By the way, the flashcard I am using is a cheap knockoff of an <a href="https://gbatemp.net/review/everdrive-gb.141/">Everdrive
+GB</a>. This FPGBC came with
+firmware v1.09, while there is an update available for v1.10 in the
+<a href="https://funnyplaying.com/products/fpgbc-kit">website</a>. I had an weird issue in
+the new firmware where no games would boot with this knockoff Everdrive so I
+had to go back to v1.09, but again, I am not sure if the issue was fact that I
+am using a knockoff device or this would happen with an original Everdrive GB.
+If you are going to buy a proper Everdrive, you probably wouldn't get a
+Everdrive GB anyway since it is discontinued, and it seems the <a href="https://www.reddit.com/r/Gameboy/comments/1atwjh3/fpgbc_everdrive_compatibility/">newer
+versions</a>
+have better compatibility with FPGBC.</p>
+<p>Sadly that the update didn't work, since there is this
+<a href="https://github.com/makhowastaken/GWGBC_FW">repository</a> that patches the
+firmware to boot the original logo instead of the ugly FPGBC one. And yes, for
+some reason the v1.09 firmware from this repository still doesn't work with my
+knockoff Everdrive.</p>
+<p>By the way, it seems the device is not easy to brick: I borked the firmware
+update process once while trying to downgrade back to v1.09, resulting in a
+black screen when I turned on the console. But just connecting the device to
+the computer and powering on, I could flash the firmware again and the device
+came back to life.</p>
+<p>About the features of the device: if you press the volume button (yes, you can
+press it now), it opens the following menu:</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_210604830.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_210604830.jpg" alt="FPGBC menu."></a></p>
+<p>The first 2 options are the LCD backlight (<code>BKLT</code>) and volume (<code>VOL</code>). I didn't talk about
+those, but the LCD screen seems to be IPS, and the quality is really good, and
+also looks bright enough to play even under bad lightining conditions. And the
+speaker has good quality, the sound is better than I remember, but sadly the
+maximum volume is kind low. Still should be enough for playing in a quiet room.</p>
+<p><code>DISPMOD</code> is probably the most controversial option: it allow you to set which
+scale you want. Anything with <code>EMU</code> at the end means emulating the original
+colors, and as far I remember it gets really close. You can also chose betwen
+<code>X4</code>, <code>X4P</code> and <code>FUL</code>, the last one is the one shown in the photos where the
+image fills the whole screen at the cost of non-integer scaling. <code>X4</code> is
+integer scaling, however the image doesn't fill the whole screen. The <code>X4P</code>
+also includes a pixel effect that makes the image closer than the original
+screen. It actually looks good, but the fact that I chose a white border for
+this FPGBC makes the border really distracting. Maybe the black one is a better
+choice if you want integer scale.</p>
+<p><code>CORE</code> is simple: you can choose between <code>GB</code> (Game Boy) or <code>GBC</code> (Game Boy
+Color). For those who don't know, you can run Game Boy games in Game Boy Color
+and they will be automatically colorised. Some people don't like this and
+prefer the colors of <code>GB</code>, so you have this option. The <code>GB_PALETTE</code> allows you
+to chose the color in GB mode, for example, the green-ish colors from the
+original Game Boy or the blue-ish colors from <a href="https://nintendo.fandom.com/wiki/Game_Boy_Light">Game Boy
+Light</a>. And yes, you can
+choose the color palette for Game Boy games running in <code>GBC</code> mode by pressing a
+<a href="https://gbstudiocentral.com/tips/game-boy-color-modes/">button combination</a> at
+the boot screen, but it seems not working in my unit and again, not sure if the
+fault is my knockoff Everdrive.</p>
+<p><code>FRAME_MIX</code> basically is an option that makes some effects, like transparency
+in <a href="https://en.wikipedia.org/wiki/Wave_Race">Wave Race</a>, to work at the cost of
+introducing blurriness. The reason for this is that those effects depends in
+the fact that the Game Boy screen was slow refresh, so you could rely on it by
+rapidly changing pixels to create some interesting effects, but sadly those
+effects doesn't work well in modern displays.</p>
+<p><code>GB_CLRFIX</code> is the option I mentioned before, where some Game Boy games just
+get completely wrong colors for some reason, e.g.: <a href="https://en.wikipedia.org/wiki/The_Addams_Family_(video_game)">The Addams
+Family</a>. Turning
+on fixes those games, but I am not sure if this option breaks other games.</p>
+<p>Finally, <code>SPD</code> allows you to increase or decrease the CPU clock, slowing or
+speeding up the games (including the sound). The result can be hilarious, so I
+think this is a nice addition to the features. Sadly you can't know what the
+default speed is, so you need to rely on sound to adjust back to the default.</p>
+<p>So in the end, can I recommend a FPGBC? I am not sure. If you want a device to
+play games, I still think something like a Miyoo Mini+ is a better choice. Not
+only you will have access to more games from different platforms, you also
+don't need to rely on flashcards or cartridges. Also it has way more features
+than FPGBC, like wireless multiplayer,
+<a href="https://retroachievements.org/">RetroArchivements</a> and save states.</p>
+<p>But the actual reason to get a FPGBC is nostalgia, and for that I think the
+FPGBC is difficult to beat. The price of the <a href="https://funnyplaying.com/products/fpgbc-kit">kit to
+assemble</a> ($69.90) is cheaper than
+most Game Boy's in good condition you can find in eBay, and you get for that
+price a rechargable battery, an amazing quality screen, the PCB and the
+speaker. You need to buy separately the case and the buttons, but in total you
+will still end up paying less, and allows you to fully customise your build.
+And the result device is not only in mint condition, it is really convenient
+too: recharging batteries (via USB-C even) is much more convenient than buying
+AA batteries, and the screen not only is better but it even has backlight. You
+can also buy a fully built console for
+<a href="https://funnyplaying.com/products/fpgbc-console">$99.00</a>, but you have less
+options of customisation.</p>
+<p>This is the classic case of do what I say, don't do what I do. This FPGBC is a
+gift, and I will buy another one soon. Can't wait to play <a href="https://en.wikipedia.org/wiki/Pok%C3%A9mon_Gold_and_Silver">Pokémon
+Gold</a> in (almost)
+original hardware again.</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_123847458.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_123847458.jpg" alt="The kit before assemble."></a></p></summary></entry><entry><title>Quick bits: why you should automate everything</title><link href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything/" rel="alternate"/><published>2024-07-29T00:00:00+00:00</published><id>https://kokada.dev/blog/quick-bits-why-you-should-automate-everything/</id><summary type="html"><p>If everything works as expected this blog post should appear in <a href="https://kokada.capivaras.dev/">in my
+blog</a> without I ever touching the
+<a href="https://capivaras.dev">capivaras.dev</a> website. I rewrote my <a href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform">previous Python
+script</a> to Go
+(<a href="https://github.com/thiagokokada/blog/blob/3c39e0f7cd58b1af885f69871490b05bf6fc7d99/blog.go">permalink</a>)
+since my attempt to generate proper description to the RSS feed resulted in
+slow startup times (not because of Python, but because of my usage of
+<code>nix-shell</code> since I didn't want to deal with
+<a href="https://docs.python.org/3/library/venv.html">venv</a> or anything to manage my
+Python dependencies).</p>
+<p>My previous workflow of this blog already involved me writing the texts in
+<a href="https://neovim.io/">neovim</a>, copying and pasting the result in the
+<a href="https://capivaras.dev">capivaras.dev</a> website and publishing. This was not
+that bad, except that it seems I have a heavy tendency of editing my posts
+multiple times. Copying and pasting data between neovim and the website became
+tedious, so I decided to give up and automate the whole process.</p>
+<p><a href="https://mataroa.blog/">Mataroa</a> (the blog platform
+<a href="https://capivaras.dev">capivaras.dev</a> run) has a reasonable good
+<a href="https://mataroa.blog/api/docs/">API</a>, and it only took a few hours to get a
+version of publishing working (it would take less if
+<a href="https://www.djangoproject.com/">Django</a>, the framework Mataroa is written, did
+not have a weird behavior with URLs missing a trailing <code>/</code>). An additional few
+lines of
+<a href="https://github.com/thiagokokada/blog/blob/51b20612335c7f4312a51a0f436235b4b701ce8b/.github/workflows/go.yml">YAML</a>
+to make GitHub Actions trigger a pipeline and now I should never have to
+manually update my blog again.</p>
+<p>I could have not done this. I mean, I probably wasted more time writing an
+automation than I actually wasted publishing manually. But the manual process
+is easy to miss, and I already did multiple mistakes publishing in the manual
+method. For example, when writing the Markdown files, each post is written in a
+particular format, where the first header is considered the title, so I need to
+remove it from the contents during publication. But of course, this is easy to
+miss, and I had to fix this multiple times already.</p>
+<p>So yes, I think this is a good lesson on why you should automate everything. It
+is more than just about <a href="https://xkcd.com/1205/">time savings</a>, it is about
+reducing mistakes and even documenting (even if poorly) a process. I mean, the
+code I wrote is not that great, but I can definitely rely on it in the future
+to remember what I need to do. It will be much faster than trying to learn from
+scratch again.</p></summary></entry><entry><title>Go, a reasonable good language</title><link href="https://kokada.dev/blog/go-a-reasonable-good-language/" rel="alternate"/><published>2024-07-29T00:00:00+00:00</published><id>https://kokada.dev/blog/go-a-reasonable-good-language/</id><summary type="html"><p>Go was one of the languages that I always was interested to learn, but never
+got the hang of it. I first got interested in the language when I was in my
+first job, between 2016-2018. At the time the language was a completely
+different beast: no modules, no generics, no easy way to error wrap yet, etc.</p>
+<p>Go forward 2023 (no pun indented), I wrote my <a href="https://github.com/thiagokokada/twenty-twenty-twenty/">first project in
+Go</a>, wrote some scripts
+at <code>$CURRENT_JOB</code> in the language, and now wrote <a href="https://github.com/thiagokokada/hyprland-go/">my first
+library</a> (with an <a href="https://kokada.dev/blog/writing-nixos-tests-for-fun-and-profit">interesting
+way to run
+CI</a>). I am also
+writing more
+<a href="https://github.com/thiagokokada/nix-configs/blob/8c559527ed12e1d4f57a3fc5c72630b956f4c290/home-manager/desktop/wayland/hyprland/hyprtabs/hyprtabs.go">scripts</a>
+in the language, where I would prefer to use Bash or Python before. Heck, even
+this blog is automatically published with a <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">Go
+script</a>,
+that used to be a <a href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform">Python
+one</a> before. I can
+say that nowadays it is another language in my toolbox, and while it is still a
+love and hate relationship, recently it is more about love and less about hate.</p>
+<p>The points that I love about Go is probably obvious for some, but still
+interesting to talk about anyway. The fact that the language generates static
+binaries by default and have fast compilation times is something that I
+apreciate since I first heard about the language, and now that I am using the
+language frequently, are points thatI appreciate even more. Something about
+getting almost instant feedback after changing a line of code and running <code>go run</code> (even with its quirks) are great for the developer experience. This is the
+main reason why I am using the language more frequently for scripts.</p>
+<p>Then we have the fast startup times. I am kind of sensitive to latency,
+especially of command line utilities that need to answer fast when I expect
+them to be fast (e.g.: <code>foo --help</code>). This is one part where I could have
+issues in Python, especially for more complex programs, but in Go it is rarely
+an issue.</p>
+<p>Modules are also fantastic. It is not without its weirdness (like everything in
+Go ecossystem), but the fact that it is so easy to add and manage dependencies
+in a project using only the <code>go</code> CLI is great. I also like that it generates a
+hash of every dependency, making it reproducible (well, probably not at Nix
+level, but still reproducible).</p>
+<p>Since I started to talk about <code>go</code> CLI, what a great tool! The fact that you
+can manage dependencies, generate documentation, format code, lint, run
+tests/<a href="https://blog.logrocket.com/benchmarking-golang-improve-function-performance/">benchmarks</a>/<a href="https://go.dev/doc/security/fuzz/">fuzzing</a>,
+check code for <a href="https://go.dev/doc/articles/race_detector">races</a> etc., all
+with just the &quot;compiler&quot; for the language is excelent. Still probably one of
+the best developer experiences I know in any programming language.</p>
+<p>I will not even talk about the things that everyone talks about Go, like
+<a href="https://go.dev/doc/effective_go#goroutines">goroutines</a>, because I just don't
+think I can add anything interesting to the topic.</p>
+<p>Now for the parts that I like less, the test part still quirks me that it is
+not based in assertions, but thankfully it is easy to write assertions with
+generics nowadays:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">Equal</span><span class="p">[</span><span class="nx">T</span> <span class="nx">comparable</span><span class="p">](</span><span class="nx">t</span> <span class="o">*</span><span class="nx">testing</span><span class="p">.</span><span class="nx">T</span><span class="p">,</span> <span class="nx">got</span><span class="p">,</span> <span class="nx">want</span> <span class="nx">T</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">t</span><span class="p">.</span><span class="nf">Helper</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">got</span> <span class="o">!=</span> <span class="nx">want</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">t</span><span class="p">.</span><span class="nf">Errorf</span><span class="p">(</span><span class="s">&#34;got: %#v, want: %#v&#34;</span><span class="p">,</span> <span class="nx">got</span><span class="p">,</span> <span class="nx">want</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">GreaterOrEqual</span><span class="p">[</span><span class="nx">T</span> <span class="nx">cmp</span><span class="p">.</span><span class="nx">Ordered</span><span class="p">](</span><span class="nx">t</span> <span class="o">*</span><span class="nx">testing</span><span class="p">.</span><span class="nx">T</span><span class="p">,</span> <span class="nx">actual</span><span class="p">,</span> <span class="nx">expected</span> <span class="nx">T</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">t</span><span class="p">.</span><span class="nf">Helper</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">actual</span> <span class="p">&lt;</span> <span class="nx">expected</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">t</span><span class="p">.</span><span class="nf">Errorf</span><span class="p">(</span><span class="s">&#34;got: %v; want: &gt;=%v&#34;</span><span class="p">,</span> <span class="nx">actual</span><span class="p">,</span> <span class="nx">expected</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// etc...
+</span></span></span></code></pre><p>Just one of those things that I end up re-writing in every project. Yes, I know
+about <a href="https://github.com/stretchr/testify">testify</a> and other assertion
+libraries, but quoting <a href="https://www.youtube.com/watch?v=PAAkCSZUG1c&amp;t=568s">Rob
+Pike</a> here, &quot;a little
+copying is better than a little dependency&quot;. As long the code you write is
+trivial, it is better to duplicate the code than try to import a dependency.</p>
+<p>About another piece of code that generics allows me to write and I always end
+up re-writing in every project is the <code>must*</code> family of functions:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">must</span><span class="p">(</span><span class="nx">err</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">must1</span><span class="p">[</span><span class="nx">T</span> <span class="nx">any</span><span class="p">](</span><span class="nx">v</span> <span class="nx">T</span><span class="p">,</span> <span class="nx">err</span> <span class="kt">error</span><span class="p">)</span> <span class="nx">T</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nf">must</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">v</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">must2</span><span class="p">[</span><span class="nx">T1</span> <span class="nx">any</span><span class="p">,</span> <span class="nx">T2</span> <span class="nx">any</span><span class="p">](</span><span class="nx">v1</span> <span class="nx">T1</span><span class="p">,</span> <span class="nx">v2</span> <span class="nx">T2</span><span class="p">,</span> <span class="nx">err</span> <span class="kt">error</span><span class="p">)</span> <span class="nx">T</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nf">must</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">v1</span><span class="p">,</span> <span class="nx">v2</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// must3, must4, etc...
+</span></span></span></code></pre><p>Those functions are so useful, especially for scripts where I generally don't
+want to handle each error: if I have an error, I want the program to halt and
+print a stack trace (exactly as I would have with a language with exceptions).
+It basically allow me to convert code from:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="nx">contents</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nf">ReadFile</span><span class="p">(</span><span class="s">&#34;file&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>To:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="nx">contents</span> <span class="o">:=</span> <span class="nf">must1</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nf">ReadFile</span><span class="p">(</span><span class="s">&#34;file&#34;</span><span class="p">))</span>
+</span></span></code></pre><p>This brings Go closer to Python to me, and I think for scripts this is
+something great.</p>
+<p>Finally, for the things that I hate, well the biggest one currently is the lack
+of nullability (or in Go terms,
+<a href="https://github.com/golang/go/issues/49202">nillability</a>). After using
+languages that has it, like Kotlin, or even something like
+<a href="https://www.mypy-lang.org/">mypy</a>, this is one of those things that completely
+changes the developer experience. I also still don't like the error handling
+(but <code>must*</code> goes far by improving the situation, when it is possible to use
+it), especially because it is easy to lose context on it:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1">// bad
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="nf">readFileContents</span><span class="p">(</span><span class="nx">file</span><span class="p">)</span> <span class="p">([]</span><span class="kt">byte</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">contents</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nf">ReadFile</span><span class="p">(</span><span class="nx">file</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="kc">nil</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">contents</span><span class="p">,</span> <span class="kc">nil</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// good
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="nf">readFileContents</span><span class="p">(</span><span class="nx">file</span><span class="p">)</span> <span class="p">([]</span><span class="kt">byte</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">contents</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nf">ReadFile</span><span class="p">(</span><span class="nx">file</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="kc">nil</span><span class="p">,</span> <span class="nx">fmt</span><span class="p">.</span><span class="nf">Errorf</span><span class="p">(</span><span class="s">&#34;readFileContents: error while reading a file: %w&#34;</span><span class="p">,</span> <span class="nx">err</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">contents</span><span class="p">,</span> <span class="kc">nil</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>I also have some grips about the mutate everything approach of the language. I
+prefer immutability by default, but I find that in general as long as you split
+your functions at a reasonable size it is generally fine.</p>
+<p>And for a language that is supposed to be straightforward, it is strange on how
+much magic the language relies on, in the form of things like <a href="https://go.dev/doc/modules/layout"><code>internal</code> and
+<code>main</code></a> packages, name capitalisation to
+indicate visibility (<code>private</code> vs <code>Public</code>), conditional compiling by filenames
+(e.g.: <code>foo_amd64.go</code>, <code>bar_linux.go</code>), magic comments (e.g.: <code>//go:build</code>),
+etc.</p>
+<p>I expect to write more Go code going forward. Not because it is the perfect
+language or whatever, but just because it a is language that has some really
+good qualities that makes the language attractive even with the issues that I
+have. That makes it a reasonable good language, and at least for me this is
+good enough.</p></summary></entry><entry><title>Quick bits: nix-shell is cursed</title><link href="https://kokada.dev/blog/quick-bits-nix-shell-is-cursed/" rel="alternate"/><published>2024-07-27T00:00:00+00:00</published><id>https://kokada.dev/blog/quick-bits-nix-shell-is-cursed/</id><summary type="html"><p>The other day I had to run a PHP project in my machine. I have no idea how PHP
+ecosystem work, I just wanted to get it to run.</p>
+<p>The easiest way to get a script to run if you use Nix is to use <code>nix-shell</code>. As
+many of you probably know, you can add <code>nix-shell</code> as a shebang in your scripts
+to run them as <code>./script</code>. This was a PHP script so I wanted to do the same.
+Easy right?</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1">#!/use/bin/env nix-shell
+</span></span></span><span class="line"><span class="cl"><span class="c1">#!nix-shell -i php -p php83
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="o">&lt;?</span><span class="nx">php</span>
+</span></span><span class="line"><span class="cl"><span class="k">declare</span><span class="p">(</span><span class="nx">strict_types</span><span class="o">=</span><span class="mi">1</span><span class="p">);</span>
+</span></span></code></pre><p>And:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ./index.php
+</span></span><span class="line"><span class="cl"><span class="go">Fatal error: strict_types declaration must be the very first statement in the script in index.php on line 4
+</span></span></span></code></pre><p>So it seems that <code>declare(strict_types=1)</code> needs to be the first line in a PHP
+script if used. I removed <code>declare(strict_types=1)</code> and while the script works,
+I don't have enough expertise in PHP to know if this would be safe or not.</p>
+<p>I decided to try something that initially looked really dumb:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1">#!/use/bin/env nix-shell
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="o">&lt;?</span><span class="nx">php</span>
+</span></span><span class="line"><span class="cl"><span class="k">declare</span><span class="p">(</span><span class="nx">strict_types</span><span class="o">=</span><span class="mi">1</span><span class="p">);</span>
+</span></span><span class="line"><span class="cl"><span class="c1">#!nix-shell -i php -p php83
+</span></span></span></code></pre><p>And:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ./index.php
+</span></span><span class="line"><span class="cl"><span class="go">Works
+</span></span></span></code></pre><p>Wat? I mean, it is not dumb if it works, but this at least looks cursed.</p>
+<p>Eventually I found this
+<a href="https://github.com/NixOS/nix/issues/2570#issuecomment-446220517">comment</a> in a
+Nix issue talking about cases where <code>nix-shell</code> shebang doesn't work. It looks
+like the classic case of a <a href="https://github.com/NixOS/nix/issues/2570#issuecomment-446222206">bug that becomes a
+feature</a>.</p>
+<p><em>Update:</em> after posting this in
+<a href="https://lobste.rs/s/gkcgza/quick_bits_nix_shell_is_cursed">Lobte.rs</a>, it seems
+someone decided to open a <a href="https://github.com/NixOS/nix/pull/11202">Pull
+Request</a> to document this behavior.
+Also the equivalent for the new <a href="https://nix.dev/manual/nix/2.23/command-ref/new-cli/nix#shebang-interpreter">nix
+CLI</a>
+explicitly documents this behavior:</p>
+<blockquote>
+<p>Note that the <code>#! nix</code> lines don't need to follow after the first line, to
+accomodate other interpreters.</p>
+</blockquote></summary></entry><entry><title>Using GitHub as a (bad) blog platform</title><link href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform/" rel="alternate"/><published>2024-07-26T00:00:00+00:00</published><id>https://kokada.dev/blog/using-github-as-a-bad-blog-platform/</id><summary type="html"><p>I finally started a new blog, thanks to the offer of
+<a href="https://gluer.org/">@ratsclub</a> to give me free access to
+<a href="https://capivaras.dev/">capivaras.dev</a>. But considering how small this blog
+platform is supposed to be, I want to have at least somewhere to have a backup
+of my posts. I know <a href="https://mataroa.blog/">Mataroa</a>, the blog platform that
+<a href="https://capivaras.dev/">capivaras.dev</a> runs, has automatic e-mail backups, but
+I want something more reliable.</p>
+<p>I am writing all my posts in Markdown (the format that <a href="https://1.mataroa.blog/guides/markdown/">Mataroa
+supports</a>) files inside
+<a href="https://neovim.io/">neovim</a> anyway, so why not store all my Markdown files in
+Git? So this is what I did, I now have an unofficial mirror in
+<a href="https://github.com/thiagokokada/blog">GitHub</a>.</p>
+<p>While I am here, why not overcomplicate? Can I make an usable blog platform
+from GitHub? And by that I don't mean GitHub pages, the repository itself. I
+mean, it already renders Markdown files by default, so no need to do anything
+in that space. To reach feature parity with
+<a href="https://capivaras.dev/">capivaras.dev</a>, I only need to have an index and RSS
+(since comments are not supported anyway). No need for newsletter since GitHub
+has a <a href="https://docs.github.com/en/account-and-profile/managing-subscriptions-and-notifications-on-github/managing-subscriptions-for-activity-on-github/viewing-your-subscriptions">watch
+feature</a>
+already.</p>
+<p>After a couple of hours hacking a Python script, you can see the result of this
+monstrosity <a href="https://github.com/thiagokokada/blog">here</a>. The script, called
+<code>gen_blog.py</code>, is available at the same repository (here is a
+<a href="https://github.com/thiagokokada/blog/blob/c8986d1ab1b94c0986fd814629bb8eb4034fb6e7/gen_blog.py">permalink</a>).
+It automatically generates an index at
+<a href="https://github.com/thiagokokada/blog/blob/main/README.md"><code>README.md</code></a> with
+each blog post and a
+<a href="https://raw.githubusercontent.com/thiagokokada/blog/main/rss.xml"><code>rss.xml</code></a>
+file at the root of the repository.</p>
+<p>Instead of trying to explain the code, I am going to explain the general idea,
+because I think that if you want to replicate this idea it is better to rewrite
+it in a way that you understand. It shouldn't take more than 2 hours in any
+decent programming language. But if you really want, the script itself is
+licensed in <a href="https://en.wikipedia.org/wiki/WTFPL">WTFPL</a> license. The code only
+uses Python 3's standard library and should work in any relatively recent
+version (anything newer than 3.9 should work).</p>
+<p>So the idea is basically to organise the repository and the Markdown files in a
+easy way that makes it trivial to parse in a deterministic way. For example, my
+repository is organised in the following way:</p>
+<pre><code>.
+├── 2024-07-26
+│ ├── 01-writing-nixos-tests-for-fun-and-profit.md
+│ └── 02-using-github-as-a-bad-blog-platform.md &lt;- this file
+├── gen_blog.py
+├── README.md
+└── rss.xml
+</code></pre>
+<p>Each day that you write a new blog post will be on its own directory. This is
+nice because Markdown files may include extra files than the posts themselves,
+e.g.: images, and this organisation make it trivial to organise everything.</p>
+<p>Each post has its own Markdown file. I put a two digit number before each post,
+to ensure that when publishing multiple posts at the same day I keep them in
+the same order of publishing. But if you don't care about it, you can just name
+the files whatever you want.</p>
+<p>Also, I am assuming that each Markdown file has a header starting with <code># </code>,
+and that is the title of the blog post.</p>
+<p>Using the above organisation, I have this function that scrapes the repository
+and collect the necessary information to generate the index and RSS files:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">grab_posts</span><span class="p">(</span><span class="n">pwd</span><span class="p">:</span> <span class="n">Path</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="n">posts</span> <span class="o">=</span> <span class="n">defaultdict</span><span class="p">(</span><span class="nb">list</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nb">dir</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">pwd</span><span class="o">.</span><span class="n">iterdir</span><span class="p">(),</span> <span class="n">reverse</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Ignore non-directories or hidden files</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="ow">not</span> <span class="nb">dir</span><span class="o">.</span><span class="n">is_dir</span><span class="p">()</span> <span class="ow">or</span> <span class="nb">dir</span><span class="o">.</span><span class="n">name</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="s2">&#34;.&#34;</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">continue</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Try to parse date from directory name</span>
+</span></span><span class="line"><span class="cl"> <span class="k">try</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="n">date</span> <span class="o">=</span> <span class="n">datetime</span><span class="o">.</span><span class="n">strptime</span><span class="p">(</span><span class="nb">dir</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="s2">&#34;%Y-%m-</span><span class="si">%d</span><span class="s2">&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;WARN: ignoring non-date directory: </span><span class="si">{</span><span class="nb">dir</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">sys</span><span class="o">.</span><span class="n">stderr</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">continue</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Iterate between the files in the date directory</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="n">post</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="nb">dir</span><span class="o">.</span><span class="n">iterdir</span><span class="p">(),</span> <span class="n">reverse</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Ignore non-markdown files or hidden files (draft)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="ow">not</span> <span class="n">post</span><span class="o">.</span><span class="n">suffix</span> <span class="o">==</span> <span class="s2">&#34;.md&#34;</span> <span class="ow">or</span> <span class="n">post</span><span class="o">.</span><span class="n">name</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="s2">&#34;.&#34;</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">continue</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Grab the first H1 section to parse as title</span>
+</span></span><span class="line"><span class="cl"> <span class="n">text</span> <span class="o">=</span> <span class="n">post</span><span class="o">.</span><span class="n">read_text</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="n">mTitle</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="sa">r</span><span class="s2">&#34;# (?P&lt;title&gt;.*)\r?\n&#34;</span><span class="p">,</span> <span class="n">text</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="n">mTitle</span> <span class="ow">and</span> <span class="p">(</span><span class="n">title</span> <span class="o">:=</span> <span class="n">mTitle</span><span class="o">.</span><span class="n">groupdict</span><span class="p">()</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;title&#34;</span><span class="p">)):</span>
+</span></span><span class="line"><span class="cl"> <span class="n">posts</span><span class="p">[</span><span class="n">date</span><span class="p">]</span><span class="o">.</span><span class="n">append</span><span class="p">({</span><span class="s2">&#34;title&#34;</span><span class="p">:</span> <span class="n">title</span><span class="p">,</span> <span class="s2">&#34;file&#34;</span><span class="p">:</span> <span class="nb">str</span><span class="p">(</span><span class="n">post</span><span class="p">)})</span>
+</span></span><span class="line"><span class="cl"> <span class="k">else</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;WARN: did not find title for file: </span><span class="si">{</span><span class="n">post</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">sys</span><span class="o">.</span><span class="n">stderr</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">posts</span>
+</span></span></code></pre><p>Some interesting tidbits: if a Markdown file has a <code>.</code> at the start I assume it
+is a draft post, and ignore it from my scraper. I added a bunch of <code>WARN</code>
+prints to make sure that the me in the future doesn't do anything dumb. Also,
+sorting in reverse since reverse chronological order is the one most people
+expect in blogs (i.e.: more recent blog posts at top).</p>
+<p>After running the function above, I have a resulting dictionary that I can use
+to generate either a <code>README.md</code> file or Markdown:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">gen_readme</span><span class="p">(</span><span class="n">posts</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="n">titles</span> <span class="o">=</span> <span class="p">[]</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="n">date</span><span class="p">,</span> <span class="n">dayPosts</span> <span class="ow">in</span> <span class="n">posts</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="n">post</span> <span class="ow">in</span> <span class="n">dayPosts</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># This creates a relative link to the Markdown file, .e.g.:</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># ./02-using-github-as-a-bad-blog-platform.md</span>
+</span></span><span class="line"><span class="cl"> <span class="n">link</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="s2">&#34;.&#34;</span><span class="p">,</span> <span class="n">post</span><span class="p">[</span><span class="s2">&#34;file&#34;</span><span class="p">])</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># This formats the title, e.g.:</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># - [Using GitHub as a (bad) blog platform](./2024-07-26/02-using-github-as-a-bad-blog-platform.md) - 2024-07-26</span>
+</span></span><span class="line"><span class="cl"> <span class="n">title</span> <span class="o">=</span> <span class="n">date</span><span class="o">.</span><span class="n">strftime</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;- [</span><span class="si">{</span><span class="n">post</span><span class="p">[</span><span class="s1">&#39;title&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">](</span><span class="si">{</span><span class="n">link</span><span class="si">}</span><span class="s2">) - %Y-%m-%d&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># This appends to the list to generate the content later</span>
+</span></span><span class="line"><span class="cl"> <span class="n">titles</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">title</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># README_TEMPLATE is a string with the static part of the README</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">print</span><span class="p">(</span><span class="n">README_TEMPLATE</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">posts</span><span class="o">=</span><span class="s2">&#34;</span><span class="se">\n</span><span class="s2">&#34;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">titles</span><span class="p">)))</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">gen_rss</span><span class="p">(</span><span class="n">posts</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Got most of the specification from here:</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># https://www.w3schools.com/XML/xml_rss.asp</span>
+</span></span><span class="line"><span class="cl"> <span class="n">rss</span> <span class="o">=</span> <span class="n">ET</span><span class="o">.</span><span class="n">Element</span><span class="p">(</span><span class="s2">&#34;rss&#34;</span><span class="p">,</span> <span class="n">version</span><span class="o">=</span><span class="s2">&#34;2.0&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Here are the RSS metadata for the blog itself</span>
+</span></span><span class="line"><span class="cl"> <span class="n">channel</span> <span class="o">=</span> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">rss</span><span class="p">,</span> <span class="s2">&#34;channel&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">channel</span><span class="p">,</span> <span class="s2">&#34;title&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="s2">&#34;kokada&#39;s blog&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">channel</span><span class="p">,</span> <span class="s2">&#34;link&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="s2">&#34;https://github.com/thiagokokada/blog&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">channel</span><span class="p">,</span> <span class="s2">&#34;description&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="s2">&#34;dd if=/dev/urandom of=/dev/brain0&#34;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># You create one item for each blog post</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="n">date</span><span class="p">,</span> <span class="n">dayPost</span> <span class="ow">in</span> <span class="n">posts</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="n">post</span> <span class="ow">in</span> <span class="n">dayPost</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="n">item</span> <span class="o">=</span> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">channel</span><span class="p">,</span> <span class="s2">&#34;item&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="n">link</span> <span class="o">=</span> <span class="n">urljoin</span><span class="p">(</span><span class="n">RSS_POST_LINK_PREFIX</span><span class="p">,</span> <span class="n">post</span><span class="p">[</span><span class="s2">&#34;file&#34;</span><span class="p">])</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="s2">&#34;title&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="n">post</span><span class="p">[</span><span class="s2">&#34;title&#34;</span><span class="p">]</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="s2">&#34;guid&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="n">link</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="s2">&#34;link&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="n">link</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="s2">&#34;pubDate&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="n">date</span><span class="o">.</span><span class="n">strftime</span><span class="p">(</span><span class="s1">&#39;</span><span class="si">%a</span><span class="s1">, </span><span class="si">%d</span><span class="s1"> %b %Y %H:%M:%S GMT&#39;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Generate the XML and indent</span>
+</span></span><span class="line"><span class="cl"> <span class="n">tree</span> <span class="o">=</span> <span class="n">ET</span><span class="o">.</span><span class="n">ElementTree</span><span class="p">(</span><span class="n">rss</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">indent</span><span class="p">(</span><span class="n">tree</span><span class="p">,</span> <span class="n">space</span><span class="o">=</span><span class="s2">&#34;</span><span class="se">\t</span><span class="s2">&#34;</span><span class="p">,</span> <span class="n">level</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="n">tree</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s2">&#34;rss.xml&#34;</span><span class="p">,</span> <span class="n">xml_declaration</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;UTF-8&#34;</span><span class="p">)</span>
+</span></span></code></pre><p>To publish a new Post, a basically write a Markdown file, run `./gen_readme.py</p>
+<blockquote>
+<p>README.md` at the root of the repository, and see the magic happen.</p>
+</blockquote>
+<p>It works much better than I initially anticipated. The <code>README.md</code> is properly
+populated with the titles and links. The RSS is kind of empty since it has no
+description, but it seems to work fine (at least in
+<a href="https://www.inoreader.com/">Inoreader</a>, my RSS reader of choice). I can
+probably fill the post description with more information if I really want, but
+it is enough for now (update: it is working now, you just need to render the
+Markdown as HTML and escape the tags;
+<a href="https://github.com/thiagokokada/blog/blob/9506051cc3d49f203304174b335ff62de9d17a05/gen_blog.py">permalink</a>
+for the updated script). Not sure who is that interested in my writing that
+will want to use this RSS feed instead the one available in
+<a href="https://kokada.capivaras.dev/rss/">capivaras.dev</a> anyway.</p>
+<p>Also, while I am using GitHub here, the same idea would work in GitLab, Gitea,
+sr.ht or whatever. As long as your source hub supports Markdown files it should
+work.</p>
+<p>So that is it. I am not saying this is a good idea for your primary blog
+platform or whatever, and I still prefer to publish to a platform that doesn't
+track users or have tons of JavaScript or whatever. But if you want a backup of
+your posts and you are already writing Markdown anyway, well, there are worse
+ways to do it I think.</p>
+<p><em>Update:</em> I rewrote the script again using Go
+(<a href="https://github.com/thiagokokada/blog/blob/3ece3853e7dd32977e7ec5238d2955e530ca4beb/blog.go">permalink</a>).
+The reason for it is because when I started rendering Markdown (for
+descriptions) the Python version got quite slow (not the fault of Python
+itself, mostly because of the usage of <code>nix-shell</code> to manage dependencies;
+something that Go doesn't need). Took about half an hour, showing how easy it
+is to do the same.</p></summary></entry><entry><title>Writing NixOS tests for fun and profit</title><link href="https://kokada.dev/blog/writing-nixos-tests-for-fun-and-profit/" rel="alternate"/><published>2024-07-26T00:00:00+00:00</published><id>https://kokada.dev/blog/writing-nixos-tests-for-fun-and-profit/</id><summary type="html"><p>I recently started a <a href="https://github.com/thiagokokada/hyprland-go">new side
+project</a> writing an IPC library in
+Go for <a href="https://hyprland.org/">Hyprland</a>, a Window Manager for Wayland.</p>
+<p>Once I got past the Work-in-Progress phase, I realise I had an issue: I wrote
+some tests, but I was running then inside my system running Hyprland. And the
+tests themselves were annoying: since they send commands to the current running
+Hyprland instance, I was having programs being opened and settings being
+changed, because this was the only way to have a reasonable good confidence
+that what I was doing was correct. So I need to do like any good developer and
+implement a CI, but how?</p>
+<p>One approach would be to create something like a mock client and test against
+my mock. Since this mock wouldn't need a running Hyprland instance the tests
+could run everywhere (even in non-Linux systems!), but they wouldn't be much
+useful. Mocks are great for testing business logic, but not really for making
+sure everything is working correctly.</p>
+<p>I need something more akin to an integration test, but this is tricky. It is
+not like I am doing integration with e.g.: PostgreSQL that has thousands of
+libraries available to make integration tests easier, I am doing integration
+with a Window Manager that is a moving target with multiple breaking changes in
+each release. And this is where NixOS tests enter, a way to run tests inside
+Virtual Machines configured in Nix.</p>
+<p>I am a long time NixOS user and commiter, but I never wrote a NixOS test
+outside of <a href="https://github.com/NixOS/nixpkgs">nixpkgs</a> itself. However I knew
+it was possible, and after doing a quick reading of the <a href="https://wiki.nixos.org/wiki/NixOS_VM_tests">Wiki
+entry</a> about it, I was ready to
+start.</p>
+<p>The first part is to call <code>pkgs.testers.runNixOSTest</code> and configure the machine
+as any other NixOS system, e.g.:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span> <span class="n">pkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"><span class="n">pkgs</span><span class="o">.</span><span class="n">testers</span><span class="o">.</span><span class="n">runNixOSTest</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;hyprland-go&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">nodes</span><span class="o">.</span><span class="n">machine</span> <span class="o">=</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span> <span class="n">config</span><span class="o">,</span> <span class="n">pkgs</span><span class="o">,</span> <span class="n">lib</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># bootloader related configuration</span>
+</span></span><span class="line"><span class="cl"> <span class="n">boot</span><span class="o">.</span><span class="n">loader</span><span class="o">.</span><span class="n">systemd-boot</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">boot</span><span class="o">.</span><span class="n">loader</span><span class="o">.</span><span class="n">efi</span><span class="o">.</span><span class="n">canTouchEfiVariables</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># enable hyprland</span>
+</span></span><span class="line"><span class="cl"> <span class="n">programs</span><span class="o">.</span><span class="n">hyprland</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># create a user called alice</span>
+</span></span><span class="line"><span class="cl"> <span class="n">users</span><span class="o">.</span><span class="n">users</span><span class="o">.</span><span class="n">alice</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">isNormalUser</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># add some extra packages that we need during tests</span>
+</span></span><span class="line"><span class="cl"> <span class="n">environment</span><span class="o">.</span><span class="n">systemPackages</span> <span class="o">=</span> <span class="k">with</span> <span class="n">pkgs</span><span class="p">;</span> <span class="p">[</span> <span class="n">go</span> <span class="n">kitty</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># auto login as alice</span>
+</span></span><span class="line"><span class="cl"> <span class="n">services</span><span class="o">.</span><span class="n">getty</span><span class="o">.</span><span class="n">autologinUser</span> <span class="o">=</span> <span class="s2">&#34;alice&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># configure VM, increase memory and CPU and enable OpenGL via LLVMPipe</span>
+</span></span><span class="line"><span class="cl"> <span class="n">virtualisation</span><span class="o">.</span><span class="n">qemu</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">options</span> <span class="o">=</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;-smp 2&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;-m 4G&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;-vga none&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;-device virtio-gpu-pci&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Start hyprland at login</span>
+</span></span><span class="line"><span class="cl"> <span class="n">programs</span><span class="o">.</span><span class="n">bash</span><span class="o">.</span><span class="n">loginShellInit</span> <span class="o">=</span> <span class="s2">&#34;Hyprland&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">testScript</span> <span class="o">=</span> <span class="s2">&#34;start_all()&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>A few details that I want to bring to attention. The first one is how easy it
+is to setup things like a normal user account, add some extra packages we need
+for testing, add Hyprland itself and configure auto-login. I have no idea how
+painful it would be to automatise all those steps in e.g.: Ansible, but here we
+are in a few lines of Nix code. This is, of course, thanks to all the
+contributors to nixpkgs that implement something that help their own use case,
+but once combined make it greater than the sum of the parts.</p>
+<p>Second is something that I took a while to figure out: how to enable GPU
+acceleration inside the VM. You see, Hyprland, different from other Window
+Managers, requires OpenGL support. This is basically why the flag <code>-device virtio-gpu-pci</code> is in <code>virtualisation.qemu.options</code>, this enables OpenGL
+rendering via LLVMPipe, that while being slow since it is rendered in CPU, is
+sufficient for this case.</p>
+<p>Putting the above code inside a
+<a href="https://wiki.nixos.org/wiki/Flakes"><code>flake.nix</code></a> for reproducibility, I had
+something similar to:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">description</span> <span class="o">=</span> <span class="s2">&#34;Hyprland&#39;s IPC bindings for Go&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">inputs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">url</span> <span class="o">=</span> <span class="s2">&#34;github:NixOS/nixpkgs/nixos-unstable&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">outputs</span> <span class="o">=</span> <span class="p">{</span> <span class="n">nixpkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">checks</span><span class="o">.</span><span class="n">x86_64-linux</span> <span class="o">=</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="n">nixpkgs</span> <span class="p">{</span> <span class="n">system</span> <span class="o">=</span> <span class="s2">&#34;x86_64-linux&#34;</span><span class="p">;</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">testVm</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">testers</span><span class="o">.</span><span class="n">runNixOSTest</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># the code above</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>I can now run <code>nix build .#checks.x86_64-linux.testVm -L</code> to build and run the
+VM. However it is not really useful right now, since we didn't add any useful
+code in <code>testScript</code>, the core of the NixOS test framework. We can also run
+<code>nix build .#checks.x86_64-linux.testVm.driverInteractive</code> and
+<code>./result/bin/nixos-test-driver</code>: this will start a Python console where we can
+manually play with the VM (try typing <code>start_all()</code> for example).</p>
+<p>The <code>testScript</code> is a sequence of Python statements that perform various
+actions, such as starting VMs, executing commands in the VMs, and so on. More
+about it in the official
+<a href="https://nixos.org/manual/nixos/stable/index.html#sec-nixos-tests">documentation</a>.
+For our case we can start with something like this:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">testScript</span> <span class="o">=</span> <span class="cm">/* python */</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> start_all()
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> machine.wait_for_unit(&#34;multi-user.target&#34;)
+</span></span></span><span class="line"><span class="cl"><span class="s1"> machine.wait_for_file(&#34;/home/alice/test-finished&#34;)
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>The first statement, <code>start_all()</code>, starts all VMs, in this case we have only
+one, called <code>machine</code>. We send two further commands to <code>machine</code>:
+<code>wait_for_unit(&quot;multi-user.target&quot;)</code> and
+<code>wait_for_file(&quot;/home/alice/test-finished&quot;)</code>.</p>
+<p>The first command waits until systemd's <code>multi-user.target</code> is ready, a good
+way to ensure that the system is ready for further commands. The second one we
+wait for a file called <code>test-finished</code> to appear in Alice's <code>$HOME</code> (basically,
+a canary), but how can we generate this file?</p>
+<p>Remember that we added <code>programs.bash.loginShellInit = &quot;Hyprland&quot;</code>, that
+automatically starts Hyprland when Alice logs in. We need to modify that
+command to run the Go tests from our library. The good thing is that Hyprland
+configuration file supports a
+<a href="https://wiki.hyprland.org/Configuring/Keywords/#executing"><code>exec-once</code></a>
+command that runs a command during Hyprland launch. We can abuse this to launch
+a terminal emulator and run our tests:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">programs</span><span class="o">.</span><span class="n">bash</span><span class="o">.</span><span class="n">loginShellInit</span> <span class="o">=</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">testScript</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">writeShellScript</span> <span class="s2">&#34;hyprland-go-test&#34;</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> set -euo pipefail
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> trap &#39;echo $? &gt; $HOME/test-finished&#39; EXIT # creates the canary when the script finishes
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> cd </span><span class="si">${</span><span class="sr">./.</span><span class="si">}</span><span class="s1"> # go to the library directory
+</span></span></span><span class="line"><span class="cl"><span class="s1"> go test -v ./... &gt; $HOME/test.log 2&gt;&amp;1 # run Go tests
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">hyprlandConf</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">writeText</span> <span class="s2">&#34;hyprland.conf&#34;</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> exec-once = kitty sh -c </span><span class="si">${</span><span class="n">testScript</span><span class="si">}</span><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> Hyprland --config </span><span class="si">${</span><span class="n">hyprlandConf</span><span class="si">}</span><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>So we are basically creating a custom Hyprland config that starts a
+<a href="https://sw.kovidgoyal.net/kitty/">Kitty</a> terminal emulator, that then launches
+a shell script that runs the test. Since we have no way to get the results of
+the test, we pipe the output to a file that we can collect later (e.g.:
+<code>machine.succeded(&quot;cat /home/alice/test.log&quot;)</code>). And once the script exit, we
+create the canary file <code>$HOME/test-finished</code>, that allows the <code>testScript</code>
+knows that the test finished and it can destroy the VM safely.</p>
+<p>If you want to take a look at the final result, it is
+<a href="https://github.com/thiagokokada/hyprland-go/blob/v0.0.1/flake.nix">here</a>. This
+tests run in any Linux machine that supports KVM, and also works in <a href="https://github.com/thiagokokada/hyprland-go/actions/workflows/nix.yaml">GitHub
+Actions</a>
+thanks to the the
+<a href="https://github.com/DeterminateSystems/nix-installer-action">nix-installer-action</a>.</p>
+<p>And now I have a proper CI pipeline in a way that I never imagined would be
+possible, especially considering how simple it was.</p></summary></entry></feed>
+\ No newline at end of file
(DIR) diff --git a/input/sfeed/realworld/kokada.dev.rss.xml b/input/sfeed/realworld/kokada.dev.rss.xml
@@ -0,0 +1,3706 @@
+<?xml version="1.0" encoding="utf-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>kokada</title><link>https://kokada.dev</link><description>
+# dd if=/dev/urandom of=/dev/brain0
+dd: error writing &#39;/dev/brain0&#39;: No space left on device
+
+</description><atom:link href="https://kokada.dev/rss/" rel="self"/><language>en-us</language><lastBuildDate>Wed, 04 Dec 2024 00:00:00 +0000</lastBuildDate><item><title>Praise to scdoc to generate man pages</title><link>https://kokada.dev/blog/praise-to-scdoc-to-generate-man-pages/</link><description><p>Hey, its been a long time since my <a href="posts/2024-10-07/01-enabling-le-audio-lc3-in-wf-1000xm5.md">last blog
+post</a>. It is mostly
+because I ran out of things to write, but I expected this. This is probably
+more likely how I am actually going to post from now. At least, it shows that
+my plan to have a <a href="https://kokada.dev/blog/making-a-blog-for-the-next-10-years">blog for a long
+time</a>, that is
+easy to go back when I wanted is working fine, but I digress.</p>
+<p>Going back to the theme of the today blog post, I needed to write a <a href="https://en.wikipedia.org/wiki/Man_page">man
+page</a> for the first time in years. I
+hate <a href="https://en.wikipedia.org/wiki/Troff">troff</a>, the typesetting system used
+for man pages (similar to <a href="https://en.wikipedia.org/wiki/LaTeX">LaTeX</a> for
+documents). It is one of the weirdest languages that I ever saw, and even the
+example in Wikipedia shows that:</p>
+<pre><code class="language-troff">.ND &quot;January 10, 1993&quot;
+.AU &quot;Ms. Jane Smith&quot;
+.AT &quot;Upcoming appointment&quot;
+.MT 5
+.DS
+Reference #A12345
+.sp 4
+Mr. Samuel Jones
+Field director, Bureau of Inspections
+1010 Government Plaza
+Capitoltown, ST
+.sp 3
+Dear Mr. Jones,
+.sp 2
+.P
+Making reference to the noted obligation to submit for state inspection our newly created production process, we request that you consider the possible inappropriateness of subjecting the innovative technologies of tomorrow to the largely antiquated requirements of yesterday. If our great state is to prosper in the twenty-first century, we must take steps
+.B now ,
+in
+.I this
+year of
+.I this
+decade, to prepare our industrial base for the interstate and international competition that is sure to appear. Our new process does precisely that. Please do not let it be undone by a regulatory environment that is no longer apt.
+.P
+Thank you for your consideration of our position.
+.FC Sincerely
+.SG
+</code></pre>
+<p>Keep in mind that the break lines are necessary every time you introduce a
+macro, like <code>.I this</code> (that I <em>think</em> it is for italics). Yes, this format is
+as illegible as hell, and it is worse that the format lacks good tooling (or at
+least I didn't find any good ones).</p>
+<p>Most people when they need to write a man page nowadays ends up using some
+other format that generates a man page. For example, in the past I used
+<a href="https://pandoc.org/">Pandoc</a> to convert Markdown to a man page, but even if
+Pandoc is a great project the result is sub-optimal at best: Markdowns are, at
+the end, designed for generating HTML (and a subset of it), and not man pages,
+so you basically ends up fighting the format for it to do what you want.
+Also, Pandoc is a big project, with a ~200MB binary (at least it is the default
+Pandoc binary in Nix).</p>
+<p>For this specific project I needed something small. I am trying to replace one
+of the most essential pieces inside NixOS, <code>nixos-rebuild</code>, written in Bash,
+with a <a href="https://discourse.nixos.org/t/nixos-rebuild-ng-a-nixos-rebuild-rewrite/55606/">full rewritten in
+Python</a>
+(sorry Rust zealots!), called <code>nixos-rebuild-ng</code>.</p>
+<p>Since this project will eventually (if successful) be in the critical path for
+NixOS, I want to reduce the number of dependencies as much as possible, so
+something as big as Pandoc is out. I could use
+<a href="https://asciidoc.org/">AsciiDoc</a>, but it is a big complicated Python project
+(this may seem ironic, but <code>nixos-rebuild-ng</code> has only one runtime dependency,
+that is optional). And I also hated the last time I tried to use it to generate
+man pages: it more flexible than Markdown, but still far from optimal.</p>
+<p>Thanks to Drew DeVault (creator of <a href="https://swaywm.org/">SwayWM</a>) that seems it
+had the same issues in the past and created
+<a href="https://drewdevault.com/2018/05/13/scdoc.html"><code>scdoc</code></a>, a very simple man
+page generator using a DSL inspired in Markdown, but specific to generate man
+pages. The binary is written in C (and advantage in this case since it means it
+is easier to bootstrap), is small (~1 Kloc) and has no dependencies, so it
+fits the requirement.</p>
+<p>While the language suffers from being a niche project for a niche segment, the
+<a href="https://man.archlinux.org/man/scdoc.5.en">man page</a> for it is actually really
+nice. It is terse though and lacks examples, and this is what this blog post
+will try to accomplish.</p>
+<p>To start, let's have a quick summary of the syntax, written in <code>scdoc</code> as
+comments:</p>
+<pre><code class="language-scdoc">; quick summary:
+; # new section
+; comments starts with ;
+; - this is a list
+; - sub-list
+; - *bold*: _underline_, force a line break++
+; - [tables], \[ can be used to force an actual [
+; . numbered list
+; please configure your editor to use hard tabs
+; see `man 5 scdoc` for more information about syntax
+; or https://man.archlinux.org/man/scdoc.5.en
+</code></pre>
+<p>I actually added this summary in the <code>.scd</code> (the <code>scdoc</code> extension) files that
+I wrote, so it is easy for someone that never saw the format to start
+collaborating.</p>
+<p>And here an example of a (summarised) man page in <code>.scd</code> format:</p>
+<pre class="chroma"><code><span class="line"><span class="cl">nixos-rebuild-ng(8)
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># NAME
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl">nixos-rebuild - reconfigure a NixOS machine
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># SYNOPSIS
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl"><span class="ge">_nixos-rebuild_</span> \[--upgrade] [--upgrade-all]++
+</span></span><span class="line"><span class="cl"> \[{switch,boot}]
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># DESCRIPTION
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl">This command has one required argument, which specifies the desired operation.
+</span></span><span class="line"><span class="cl">It must be one of the following:
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="ge">*switch*</span>
+</span></span><span class="line"><span class="cl"> Build and activate the new configuration, and make it the boot default.
+</span></span><span class="line"><span class="cl"> That is, the configuration is added to the GRUB boot menu as the
+</span></span><span class="line"><span class="cl"> default menu entry, so that subsequent reboots will boot the system
+</span></span><span class="line"><span class="cl"> into the new configuration. Previous configurations activated with
+</span></span><span class="line"><span class="cl"> nixos-rebuild switch or nixos-rebuild boot remain available in the GRUB
+</span></span><span class="line"><span class="cl"> menu.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="ge">*boot*</span>
+</span></span><span class="line"><span class="cl"> Build the new configuration and make it the boot default (as with
+</span></span><span class="line"><span class="cl"> <span class="ge">*nixos-rebuild switch*</span>), but do not activate it. That is, the system
+</span></span><span class="line"><span class="cl"> continues to run the previous configuration until the next reboot.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># OPTIONS
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl"><span class="ge">*--upgrade, --upgrade-all*</span>
+</span></span><span class="line"><span class="cl"> Update the root user&#39;s channel named &#39;nixos&#39; before rebuilding the
+</span></span><span class="line"><span class="cl"> system.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> In addition to the &#39;nixos&#39; channel, the root user&#39;s channels which have
+</span></span><span class="line"><span class="cl"> a file named &#39;.update-on-nixos-rebuild&#39; in their base directory will
+</span></span><span class="line"><span class="cl"> also be updated.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> Passing <span class="ge">*--upgrade-all*</span> updates all of the root user&#39;s channels.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl">See the Nix manual, <span class="ge">*nix flake lock --help*</span> or <span class="ge">*nix-build --help*</span> for details.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># ENVIRONMENT
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl">NIXOS_CONFIG
+</span></span><span class="line"><span class="cl"> Path to the main NixOS configuration module. Defaults to
+</span></span><span class="line"><span class="cl"> <span class="ge">_/etc/nixos/configuration.nix_</span>.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># FILES
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl">/etc/nixos/flake.nix
+</span></span><span class="line"><span class="cl"> If this file exists, then <span class="ge">*nixos-rebuild*</span> will use it as if the
+</span></span><span class="line"><span class="cl"> <span class="ge">*--flake*</span> option was given. This file may be a symlink to a
+</span></span><span class="line"><span class="cl"> flake.nix in an actual flake; thus <span class="ge">_/etc/nixos_</span> need not be a
+</span></span><span class="line"><span class="cl"> flake.
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="gh"># AUTHORS
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span>
+</span></span><span class="line"><span class="cl">Nixpkgs/NixOS contributors
+</span></span></code></pre><p>And here is a screenshot of the result:</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-12-04/2024-12-04-230955_hyprshot.png"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-12-04/2024-12-04-230955_hyprshot.png" alt="Man page rendered from scd
+file"></a></p>
+<p>One of nice things that I found is how looking at the plain text looks kind
+like the man page result already. And if you know Markdown, you can basically
+understand most things that is happening. There are a few differences, like
+<code>*bold*</code> instead of <code>**bold**</code>, and while they're unfortunate they're not the
+end of the world.</p>
+<p>Now, the format has its quirks. The first line being the name of the program
+and section in parenthesis is required, but this makes sense, since you need
+this information for the corners. But for one, it requires the usage of hard
+tabs to create indentation, and the error messages are awful, in a situation
+that kind remembers me of <code>Makefile</code>. Also the choice of <code>[</code> to start a table
+means that the traditional <code>app [command]</code> needs in many cases to be escaped as
+<code>app \[command]</code>. I found this a strange choice since this is supposed to be a
+format that is only used for man pages, and using <code>[command]</code> to indicate an
+optional is common, but at least it is easy to escape.</p>
+<p>In the end, I think all that matters is the result. And for the first time for
+all those years trying to write a man page, I am satisfied with the result. The
+man page looks exactly as I wanted once rendered, and the <code>.scd</code> file looks
+reasonable good that it can work as a documentation for someone that for one
+reason or another can't use the man page (can't say the same for the troff
+version). Also, it is really easy for someone to just go there and update the
+man page, even without experience in the format (except for maybe the
+requirement of tabs). So all in all, I really liked the format, and will use it
+again if I need to write another man page in the future.</p></description><pubDate>Wed, 04 Dec 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/praise-to-scdoc-to-generate-man-pages/</guid></item><item><title>Enabling LE Audio/LC3 in WF-1000XM5</title><link>https://kokada.dev/blog/enabling-le-audio-lc3-in-wf-1000xm5/</link><description><p>One of things that I hate the most about the fact that we are all using
+wireless earbuds instead of wired earphones is the latency: it is bad, getting
+up to seconds(!) depending on your particular combination of OS/earbuds/device.</p>
+<p>There is a solution though: Bluetooth LE Audio, that is supposed to fix
+multiple issues with the original design for Bluetooth Classic Audio, including
+a much lower latency, improved efficiency (e.g.: less battery power) and even
+multiple streams of audio. LE Audio also includes a new default codec for
+improved audio quality, <a href="https://en.wikipedia.org/wiki/LC3_(codec)">LC3</a>, that
+replaces the venerable <a href="https://en.wikipedia.org/wiki/SBC_(codec)">SBC</a> codec
+for audio.</p>
+<p>However, the standard is a mess right now: a few wireless headphones already
+support it, but they're generally disabled by default and it is pretty messy to
+enable. And even after enabling it, getting it to work can be a pain.</p>
+<p>I have pretty much the best setup to use LE Audio right now: a recently
+released Pixel 9 Pro with Sony's
+<a href="https://www.sony.ie/headphones/products/wf-1000xm5">WF-1000XM5</a> earbuds, and
+after lots of tries I got it to work. You can see below the versions of
+everything I am using:</p>
+<ul>
+<li>Android: 14</li>
+<li><a href="https://play.google.com/store/apps/details?id=com.sony.songpal.mdr">Sound
+Connect</a>:
+11.0.1</li>
+<li>WM-1000XM5: 4.0.2</li>
+</ul>
+<p>The first thing you need to do is enable in &quot;Sound Connect&quot; app &quot;LE Audio
+Priority&quot; in &quot;Device Settings -&gt; System&quot;:</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-10-07/photo_4909454744305642922_y.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-10-07/photo_4909454744305642922_y.jpg" alt="LE Audio option inside Sound
+Connect"></a></p>
+<p>After this, you will need to pair your headset with the device again. You can
+do this as same as always: press and hold the button in case for a few seconds
+until a blue light starts to blink. However, this is where things starts to get
+janky: I couldn't get the headset to pair with Android again.</p>
+<p>A few of the things that I needed to do (in no specific order):</p>
+<ul>
+<li>Remove the previous paired headset</li>
+<li>Restart the Android</li>
+<li>Clean-up &quot;Sound Connect&quot; storage (Long press the app icon -&gt; &quot;App info&quot; -&gt;
+&quot;Storage and Cache&quot; -&gt; &quot;Clear storage&quot;)</li>
+</ul>
+<p>If you can get the headset to connect, go to the &quot;Bluetooth&quot; settings in
+Android, click in the gear icon for the headset and enable &quot;LE Audio&quot; option:</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-10-07/photo_4909454744305642937_y.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-10-07/photo_4909454744305642937_y.jpg" alt="LE Audio option Bluetooth
+Settings"></a></p>
+<p>If you can't, you may want to <a href="https://helpguide.sony.net/mdr/2963/v1/en/contents/TP1000783925.html">restore the headset to factory
+settings</a>
+and try again from the start (that means pairing your device with &quot;Sound
+Connect&quot; again, and you may want to try to clear the storage before doing so).</p>
+<p>Yes, the process is extremely janky, but I think this is why both &quot;Sound
+Connect&quot; and Android marks this feature as beta/experimental. And I still need
+to test the latency, but from my initial testing there are some glitches when
+the audio is only used for a short period of time (e.g.: Duolingo only enables
+the audio when the character is speaking). So I only recommend this if you want
+to test how LE Audio will behave, since it is clear that this needs more
+polish.</p></description><pubDate>Mon, 07 Oct 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/enabling-le-audio-lc3-in-wf-1000xm5/</guid></item><item><title>Quick bits: where does Nix store Flake's trusted settings?</title><link>https://kokada.dev/blog/quick-bits-where-does-nix-store-flakes-trusted-settings/</link><description><p>Have you ever run a <code>nix build</code> command and had this prompt?</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix run .#darwinActivations/Sekai-MacBook-Pro
+</span></span><span class="line"><span class="cl"><span class="go">do you want to allow configuration setting &#39;extra-substituters&#39; to be set to &#39;https://nix-community.cachix.org https://thiagokokada-nix-configs.cachix.org&#39; (y/N)? y
+</span></span></span><span class="line"><span class="cl"><span class="go">do you want to permanently mark this value as trusted (y/N)? y
+</span></span></span></code></pre><p>And realise that you did/didn't want to mark this value as trusted? But where
+is this stored? Well, I had to look at the Nix source code to find the answer,
+since I can't find this anywhere in the web or in ChatGPT (but I am sure that
+now that I posted this it will eventually be searchable), and the answer can be
+found
+<a href="https://github.com/NixOS/nix/blob/c116030605bf7fecd232d0ff3b6fe066f23e4620/src/libflake/flake/config.cc#L13-L16">here</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="n">Path</span> <span class="nf">trustedListPath</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">getDataDir</span><span class="p">()</span> <span class="o">+</span> <span class="s">&#34;/trusted-settings.json&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Where is <code>getDataDir()</code> though? I found the answer
+<a href="https://github.com/NixOS/nix/blob/c116030605bf7fecd232d0ff3b6fe066f23e4620/src/libutil/users.cc#L52-L65">here</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="n">Path</span> <span class="nf">getDataDir</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">auto</span> <span class="n">dir</span> <span class="o">=</span> <span class="n">getEnv</span><span class="p">(</span><span class="s">&#34;NIX_DATA_HOME&#34;</span><span class="p">);</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">(</span><span class="n">dir</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="o">*</span><span class="n">dir</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">auto</span> <span class="n">xdgDir</span> <span class="o">=</span> <span class="n">getEnv</span><span class="p">(</span><span class="s">&#34;XDG_DATA_HOME&#34;</span><span class="p">);</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">(</span><span class="n">xdgDir</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="o">*</span><span class="n">xdgDir</span> <span class="o">+</span> <span class="s">&#34;/nix&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">getHome</span><span class="p">()</span> <span class="o">+</span> <span class="s">&#34;/.local/share/nix&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>So we solved the mystery:</p>
+<ul>
+<li>If <code>NIX_DATA_HOME</code> is set, the file will be in
+<code>$NIX_DATA_HOME/trusted-settings.json</code></li>
+<li>If <code>XDG_DATA_HOME</code> is set, the file will be in
+<code>$XDG_DATA_HOME/nix/trusted-settings.json</code></li>
+<li>Otherwise Nix will fallback to <code>$HOME/.local/share/nix/trusted-settings.json</code></li>
+</ul>
+<p>By the way, if you don't know why you got this prompt, if <code>flake.nix</code> has a
+<code>nixConfig</code> attribute inside <code>outputs</code> <strong>and</strong> this <code>nixConfig</code> is an unsafe
+attribute (like <code>extra-substituters</code>) you will get this prompt, unless you set
+<a href="https://nix.dev/manual/nix/2.23/command-ref/conf-file#conf-accept-flake-config"><code>accept-flake-config = true</code></a>
+in your Nix configuration (please <strong>do not do this</strong>, it is dangerous because
+it may allow running possible unsafe options without asking you first).</p>
+<p>You can inspect the JSON file or delete it and Nix will prompt you again the
+next time you run a <code>nix</code> command. And yes, saving this preference is
+controversial considering this is Nix, but having the power to set <code>nixConfig</code>
+attributes is really powerful, and with great powers comes great
+responsibilities.</p></description><pubDate>Mon, 30 Sep 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/quick-bits-where-does-nix-store-flakes-trusted-settings/</guid></item><item><title>My coding experience with LLM</title><link>https://kokada.dev/blog/my-coding-experience-with-llm/</link><description><p>I don't want to talk about AI. AI fatigue is real, with (garbage) AI content
+everywhere you go. However, I like to talk about tools, and AIs, or more
+specifically, <a href="https://en.wikipedia.org/wiki/Large_language_model">Large Language
+Models</a> (LLM), can be
+really useful tools. Maybe someday we will have our AI overlords dominating
+everything (including my job), but right now I don't feel particularly
+threatened given my experience with AIs.</p>
+<p>Given that <a href="https://mashable.com/article/google-search-low-quality-research">Google Search is getting
+worse</a>, I am
+slowly relying in LLMs more and more. This is the focus of this post, basically
+<a href="https://www.rottentomatoes.com/m/the_good_the_bad_and_the_ugly">the good, the bad and the
+ugly</a> (by the
+way, never saw this film) of LLMs, especially focused for solving coding
+problems. I will take a look at the my chat history in
+<a href="https://chatgpt.com/">ChatGPT</a> and see where it was a good tool, where it
+shined, and where it just completely wasted my time.</p>
+<p>A disclaimer, I never bothered to buy a ChatGPT subscription because I don't
+feel that the tool is useful enough (at least yet), so most of the examples
+here are either with <a href="https://openai.com/index/chatgpt/">GPT-3.5</a> or <a href="https://openai.com/index/gpt-4o-mini-advancing-cost-efficient-intelligence/">GPT-4o
+mini</a>,
+since those where the models offered by free in ChatGPT.</p>
+<p>An addendum, I have some experience with <a href="https://github.com/features/copilot">GitHub
+Copilot</a> (another LLM, but this one runs
+inside your IDE or favorite text editor) in <code>$PREVIOUS_JOB</code>. But my experience
+with it is even more underwhelming than what I am going to describe in this
+post: it was basically really good for generating fixture for tests and between
+ok-ish to plain bad for everything else. Yes, that's would fit in a tweet (or
+xeet?).</p>
+<h2>The good</h2>
+<p><a href="https://chatgpt.com/share/c58a1432-2761-4954-acac-cade29942c34">Chat history</a>.</p>
+<blockquote>
+<p>Is there any way that I can pass a context for a net.conn to cancel its
+Read()?</p>
+</blockquote>
+<p>This is one of the good cases where ChatGPT felt to me that I was talking with
+an expert in Go. To start, I didn't even mention in my initial prompt that I
+was talking about Go, but it correctly inferred so. Also, the solution overview
+was great:</p>
+<blockquote>
+<ol>
+<li><strong>Use a separate goroutine</strong> to handle the context cancellation.</li>
+<li><strong>Set a deadline</strong> on the connection using <code>SetReadDeadline()</code> to unblock
+the <code>Read()</code> when the context is canceled.</li>
+</ol>
+</blockquote>
+<p>Before asking ChatGPT about this issue I had already coded my own naive
+solution that was something similar to this:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">foo</span><span class="p">(</span><span class="nx">ctx</span> <span class="nx">context</span><span class="p">.</span><span class="nx">Context</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// ...
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kd">struct</span><span class="p">{})</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">n</span> <span class="kt">int</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">err</span> <span class="kt">error</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">Read</span><span class="p">(</span><span class="nx">buf</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">done</span> <span class="o">&lt;-</span><span class="kd">struct</span><span class="p">{}{}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}()</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">select</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">ctx</span><span class="p">.</span><span class="nf">Done</span><span class="p">():</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">conn</span><span class="p">.</span><span class="nf">Close</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">ctx</span><span class="p">.</span><span class="nf">Err</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">done</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// ...
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
+</span></span></code></pre><p>Compared this solution with the one from ChatGPT:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">readWithContext</span><span class="p">(</span><span class="nx">ctx</span> <span class="nx">context</span><span class="p">.</span><span class="nx">Context</span><span class="p">,</span> <span class="nx">conn</span> <span class="nx">net</span><span class="p">.</span><span class="nx">Conn</span><span class="p">,</span> <span class="nx">buf</span> <span class="p">[]</span><span class="kt">byte</span><span class="p">)</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kd">struct</span><span class="p">{})</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">n</span> <span class="kt">int</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">err</span> <span class="kt">error</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1">// Start a goroutine to perform the read
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">Read</span><span class="p">(</span><span class="nx">buf</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">close</span><span class="p">(</span><span class="nx">done</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}()</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">select</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">ctx</span><span class="p">.</span><span class="nf">Done</span><span class="p">():</span> <span class="c1">// Context was canceled or timed out
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="c1">// Set a short deadline to unblock the Read()
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"> <span class="o">&lt;-</span><span class="nx">done</span> <span class="c1">// Wait for the read to finish
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">ctx</span><span class="p">.</span><span class="nf">Err</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">done</span><span class="p">:</span> <span class="c1">// Read finished successfully
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>The ChatGPT version is much better because:</p>
+<ol>
+<li>It doesn't close the connection socket allowing it to be reused</li>
+<li>It waits until the goroutine is finished to avoid leaks</li>
+<li>It closes the channel after it finishes</li>
+</ol>
+<p>Now, I don't claim to be a Go expert (far from it), but this was one of those
+cases where I felt that I was being guided by someone that is coding in Go for
+years.</p>
+<p>But it didn't end there, I asked:</p>
+<blockquote>
+<p>If I want to reuse the connection, do I need to reset the SetReadDeadline?</p>
+</blockquote>
+<p>Since in this particular case I wanted the underlying connection to be reused,
+and ChatGPT correctly amended the code:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">readWithContext</span><span class="p">(</span><span class="nx">ctx</span> <span class="nx">context</span><span class="p">.</span><span class="nx">Context</span><span class="p">,</span> <span class="nx">conn</span> <span class="nx">net</span><span class="p">.</span><span class="nx">Conn</span><span class="p">,</span> <span class="nx">buf</span> <span class="p">[]</span><span class="kt">byte</span><span class="p">)</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Same as before
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">select</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">ctx</span><span class="p">.</span><span class="nf">Done</span><span class="p">():</span> <span class="c1">// Context was canceled or timed out
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="c1">// Set a short deadline to unblock the Read()
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"> <span class="o">&lt;-</span><span class="nx">done</span> <span class="c1">// Wait for the read to finish
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Reset the deadline so the connection can be reused
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Time</span><span class="p">{})</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">ctx</span><span class="p">.</span><span class="nf">Err</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">done</span><span class="p">:</span> <span class="c1">// Read finished successfully
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Also the explanation on why this happens was good:</p>
+<blockquote>
+<p>When you set a read deadline with <code>conn.SetReadDeadline(time.Now())</code> to unblock
+the <code>Read()</code> call, this deadline remains in effect for future <code>Read()</code>
+operations. This means that if you attempt another read operation after this,
+it could immediately fail with a timeout error if the deadline is still in
+effect.
+To reuse the connection, you'll need to remove the deadline or set a new one.
+You can do this by calling <code>conn.SetReadDeadline(time.Time{})</code>, which clears
+any existing deadline.</p>
+</blockquote>
+<p>I had one last question that I kind already knew the answer:</p>
+<blockquote>
+<p>Do we need to defer the clearing?</p>
+</blockquote>
+<p>And ChatGPT correctly returned:</p>
+<blockquote>
+<p>Whether you need to defer the clearing of the read deadline depends on how
+your code is structured. If you want to ensure that the read deadline is
+always cleared after a context cancellation, even if the code panics or exits
+early, then deferring the <code>conn.SetReadDeadline(time.Time{})</code> call is a good
+idea.</p>
+</blockquote>
+<p>This whole interaction was one of the best ones I ever had in ChatGPT, one that
+it gave me an actual functional code with good explanation on what was
+happening. But still, it didn't talked at all about the gotcha of setting the
+read deadline and reusing the underlying connection, needing another prompt to
+give me this information.</p>
+<p>Also, there is one issue in ChatGPT solution though: we are discarding the
+values of the buffer once the context is done by returning <code>n = 0</code> instead of
+the number of bytes read. In this particular case this is what I wanted, but
+this is a possible issue that ChatGPT didn't talk.</p>
+<p>For comparison,
+<a href="https://stackoverflow.com/questions/61637359/how-to-use-context-context-with-tcp-connection-read">this</a>
+is the best that I got searching in both DuckDuckGo and Google, that is where I
+kind based my first solution on. I still not sure where ChatGPT could give me
+such a good answer for this question, because I just couldn't find anything
+remotely similar during my searches.</p>
+<h2>The amazing</h2>
+<p><a href="https://chatgpt.com/share/0c9a148f-4cfd-4b4e-aa84-7486e185125b">Chat history</a>.</p>
+<blockquote>
+<p>I want to write an extension to <a href="https://github.com/yuin/goldmark/">https://github.com/yuin/goldmark/</a> that allows
+me to rewrite <code>[link](../2024-07-30/post.md)</code> to
+<code>[link](https://kokada.capivaras.dev/slug)</code></p>
+</blockquote>
+<p>Here is the generated code:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">linkrewriter</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kn">import</span> <span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;fmt&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;path&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;strings&#34;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark/ast&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark/parser&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark/renderer&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark/util&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// LinkRewriter is the main struct for your extension
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">type</span> <span class="nx">LinkRewriter</span> <span class="kd">struct</span><span class="p">{}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// NewLinkRewriter returns a new instance of LinkRewriter
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="nf">NewLinkRewriter</span><span class="p">()</span> <span class="o">*</span><span class="nx">LinkRewriter</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="o">&amp;</span><span class="nx">LinkRewriter</span><span class="p">{}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// Extend will be called by Goldmark to add your extension
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="p">(</span><span class="nx">e</span> <span class="o">*</span><span class="nx">LinkRewriter</span><span class="p">)</span> <span class="nf">Extend</span><span class="p">(</span><span class="nx">m</span> <span class="nx">goldmark</span><span class="p">.</span><span class="nx">Markdown</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span><span class="p">.</span><span class="nf">Parser</span><span class="p">().</span><span class="nf">AddOptions</span><span class="p">(</span><span class="nx">parser</span><span class="p">.</span><span class="nf">WithASTTransformers</span><span class="p">(</span><span class="nx">util</span><span class="p">.</span><span class="nf">Prioritized</span><span class="p">(</span><span class="nx">e</span><span class="p">,</span> <span class="mi">0</span><span class="p">)))</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// Transform is the method that modifies the AST
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="p">(</span><span class="nx">e</span> <span class="o">*</span><span class="nx">LinkRewriter</span><span class="p">)</span> <span class="nf">Transform</span><span class="p">(</span><span class="nx">node</span> <span class="o">*</span><span class="nx">ast</span><span class="p">.</span><span class="nx">Document</span><span class="p">,</span> <span class="nx">reader</span> <span class="nx">text</span><span class="p">.</span><span class="nx">Reader</span><span class="p">,</span> <span class="nx">pc</span> <span class="nx">parser</span><span class="p">.</span><span class="nx">Context</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">ast</span><span class="p">.</span><span class="nf">Walk</span><span class="p">(</span><span class="nx">node</span><span class="p">,</span> <span class="kd">func</span><span class="p">(</span><span class="nx">n</span> <span class="nx">ast</span><span class="p">.</span><span class="nx">Node</span><span class="p">,</span> <span class="nx">entering</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">(</span><span class="nx">ast</span><span class="p">.</span><span class="nx">WalkStatus</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">!</span><span class="nx">entering</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">ast</span><span class="p">.</span><span class="nx">WalkContinue</span><span class="p">,</span> <span class="kc">nil</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">link</span><span class="p">,</span> <span class="nx">ok</span> <span class="o">:=</span> <span class="nx">n</span><span class="p">.(</span><span class="o">*</span><span class="nx">ast</span><span class="p">.</span><span class="nx">Link</span><span class="p">);</span> <span class="nx">ok</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nf">rewriteLink</span><span class="p">(</span><span class="nx">link</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">ast</span><span class="p">.</span><span class="nx">WalkContinue</span><span class="p">,</span> <span class="kc">nil</span>
+</span></span><span class="line"><span class="cl"> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// rewriteLink modifies the link URL
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="nf">rewriteLink</span><span class="p">(</span><span class="nx">link</span> <span class="o">*</span><span class="nx">ast</span><span class="p">.</span><span class="nx">Link</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">url</span> <span class="o">:=</span> <span class="nb">string</span><span class="p">(</span><span class="nx">link</span><span class="p">.</span><span class="nx">Destination</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">strings</span><span class="p">.</span><span class="nf">HasPrefix</span><span class="p">(</span><span class="nx">url</span><span class="p">,</span> <span class="s">&#34;../&#34;</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Modify this part according to your slug generation logic
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">slug</span> <span class="o">:=</span> <span class="nf">generateSlug</span><span class="p">(</span><span class="nx">url</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">link</span><span class="p">.</span><span class="nx">Destination</span> <span class="p">=</span> <span class="p">[]</span><span class="nb">byte</span><span class="p">(</span><span class="nx">fmt</span><span class="p">.</span><span class="nf">Sprintf</span><span class="p">(</span><span class="s">&#34;https://kokada.capivaras.dev/%s&#34;</span><span class="p">,</span> <span class="nx">slug</span><span class="p">))</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// generateSlug generates a slug from the given URL
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="nf">generateSlug</span><span class="p">(</span><span class="nx">url</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">string</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Assuming the slug is the last part of the URL without the extension
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nx">strings</span><span class="p">.</span><span class="nf">TrimSuffix</span><span class="p">(</span><span class="nx">path</span><span class="p">.</span><span class="nf">Base</span><span class="p">(</span><span class="nx">url</span><span class="p">),</span> <span class="nx">path</span><span class="p">.</span><span class="nf">Ext</span><span class="p">(</span><span class="nx">url</span><span class="p">))</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kn">import</span> <span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s">&#34;github.com/yuin/goldmark/renderer/html&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">linkrewriter</span> <span class="s">&#34;path/to/your/linkrewriter&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">md</span> <span class="o">:=</span> <span class="nx">goldmark</span><span class="p">.</span><span class="nf">New</span><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">goldmark</span><span class="p">.</span><span class="nf">WithExtensions</span><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">linkrewriter</span><span class="p">.</span><span class="nf">NewLinkRewriter</span><span class="p">(),</span>
+</span></span><span class="line"><span class="cl"> <span class="p">),</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">goldmark</span><span class="p">.</span><span class="nf">WithRendererOptions</span><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">html</span><span class="p">.</span><span class="nf">WithHardWraps</span><span class="p">(),</span>
+</span></span><span class="line"><span class="cl"> <span class="p">),</span>
+</span></span><span class="line"><span class="cl"> <span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1">// Use `md.Convert` to convert your markdown to HTML as usual
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
+</span></span></code></pre><p>This one will need some context. <a href="https://github.com/yuin/goldmark/">Goldmark</a>,
+the Markdown renderer that <a href="https://kokada.dev/blog/making-a-blog-for-the-next-10-years">powers this
+blog</a>, does not
+have good examples or documentation (at least I didn't found neither).</p>
+<p>So I was not really hopeful I would get any answers in ChatGPT, but not only it
+put me in the correct path, the code was almost correct. It did had some unused
+and missing imports, and there were some compilation errors that were easily
+fixed. And when it registered the extension, it also added a
+<code>html.WithHardWraps()</code> renderer for no reason at all.</p>
+<p>But this is one of the experiences in LLM that most impressed me. I had no idea
+at all on how to solve this problem, and ChatGPT basically gave me the
+solution. A <a href="https://github.com/thiagokokada/blog/blob/3a2ea58a0638d1005617d25eabeae0626933db46/link_rewriter.go">modified version of the
+code</a>
+from this chat is still used to power this blog to this day, that also
+demonstrates that the code is not garbage (since now I understand what it does
+and I can even extend it).</p>
+<p>I am still not sure how the license situation of this code is though. Does
+licenses even make sense in AI generated code?</p>
+<h2>The bad</h2>
+<p><a href="https://chatgpt.com/share/95fcd777-b03c-4cfe-8d1d-12e53f5a4dfe">Chat history</a>.</p>
+<blockquote>
+<p>I want to configure VM options inside IntelliJ by project</p>
+</blockquote>
+<blockquote>
+<p>My project uses sbt, and I want to set this in a way that I can share with my
+colleagues</p>
+</blockquote>
+<blockquote>
+<p>I am using a build.sbt file, but IntelliJ is not loading it's JVM options and
+I need to set this up manually. I want to automate this</p>
+</blockquote>
+<p>This is an example of my most common interaction with ChatGPT: it generally
+gives some options that could work, but not in my specific case. So I start to
+ask for more information until it eventually starts to
+<a href="https://en.wikipedia.org/wiki/Hallucination_(artificial_intelligence)">hallucinate</a>.</p>
+<p>In this particular case, the hallucination was in:</p>
+<blockquote>
+<p>The sbt-idea-plugin can generate IntelliJ IDEA project files based on your
+SBT configuration, including JVM options. This allows you to ensure that
+IntelliJ loads the correct settings from the SBT configuration.</p>
+<p>Steps:</p>
+<ol>
+<li>Add the <code>sbt-idea-plugin</code> to your <code>project/plugins.sbt</code> file:</li>
+</ol>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="n">addSbtPlugin</span><span class="o">(</span><span class="s">&#34;com.github.mwz&#34;</span> <span class="o">%</span> <span class="s">&#34;sbt-idea&#34;</span> <span class="o">%</span> <span class="s">&#34;2.4.0&#34;</span><span class="o">)</span>
+</span></span></code></pre><ol start="2">
+<li>Run the following command in your terminal to regenerate IntelliJ IDEA
+project files:</li>
+</ol>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="go">sbt gen-idea
+</span></span></span></code></pre></blockquote>
+<p>Yes, there is a
+<a href="https://github.com/JetBrains/sbt-idea-plugin"><code>sbt-idea-plugin</code></a>, but no, it
+doesn't generate project files based in my SBT configuration. It is not even
+from the repository that it is supposed to be pointing too.</p>
+<p>I will just not say that this interaction was a waste of time because some of
+the other ideas can be applied, but this was the kind of case where I ended up
+just being disappointed because the thing that seemed to be a possible solution
+for my problem ended up not existing at all.</p>
+<h2>The ugly</h2>
+<p>There are lots of examples where ChatGPT just plain disappointed me. Here is a
+few:</p>
+<blockquote>
+<p>What is the language that is a fork of Go that has extra features like map?</p>
+</blockquote>
+<p><a href="https://chatgpt.com/share/2b854bbd-d376-4049-97fe-b47321c1ef07">Chat history</a>.</p>
+<p>This is one of those cases where I saw something once and was trying to
+remember. ChatGPT just gave me lots of answers that were not a fork of Go
+(<a href="https://vlang.io/">V</a>, <a href="https://github.com/gluon-lang/gluon">Gluon</a>,
+<a href="https://www.ponylang.io">Pony</a>), hallucinated a programming language (Gomini),
+and said that <a href="https://ziglang.org/">Zig</a> is focused in STEM.</p>
+<p>By the way, I eventually remember what the language was:
+<a href="https://goplus.org/">Go+</a>. To be fair with ChatGPT, I misremembered that the
+Go+ had map (as the <a href="https://en.wikipedia.org/wiki/Map_(higher-order_function)">high-order
+function</a>, not a
+hashmap that both Go and Go+ have). But still, Go+ explicit announces that it
+is a language for STEM everywhere in their website, and even them ChatGPT
+couldn't answer.</p>
+<blockquote>
+<p>In IntelliJ, I need to pass some VM options to the run configuration for my
+application to run tests, e.g.:</p>
+<pre><code>--add-exports=java.base/sun.security.x509=ALL-UNNAMED
+--add-opens=java.base/sun.security.ssl=ALL-UNNAMED
+-Dconfig.resource=api.test.conf
+</code></pre>
+<p>However, the <code>api.test.conf</code> may be <code>jobs.api.conf</code> or something else
+depending on the subproject I am running inside Idea. Can I parametrize this
+in some way?</p>
+</blockquote>
+<p><a href="https://chatgpt.com/share/aa9bd051-65de-49d9-8d56-0e28de94722c">Chat history</a></p>
+<p>So quick answer: you can't. IntelliJ macros are not powerful enough for this.
+ChatGPT itself said so when I asked about the IntelliJ macros
+<a href="https://chatgpt.com/share/7a057bf5-bcec-458b-9432-98e3f551ad28">directly</a>.</p>
+<p>But in this particular case, ChatGPT happily said &quot;yes, you can parameterize VM
+options in IntelliJ IDEA to make them more flexible depending on the subproject
+or other context&quot;. Thanks for wasting my time, I guess.</p>
+<h2>Conclusion</h2>
+<p>I do think that LLMs, in particular ChatGPT since this is the one I have more
+experience with, are improving. But still, if there is anything that I
+concluded after putting all those experiences in a post is that you still need
+someone that knows at least as much about whatever you're asking ChatGPT to
+actually validate the answer.</p>
+<p>Not only because LLMs hallucinates a lot, but also because even in the &quot;good&quot;
+example the LLM needed extra input to figure out about the possible drawback of
+the solution. The only case where I felt that ChatGPT outsmarted me was the
+&quot;amazing&quot; case, but this was literally the only example that I could find in
+all my chat history with ChatGPT that was like this.</p>
+<p>So yes, at least for now I still don't think AI will be our overlords. Maybe
+someday.</p></description><pubDate>Mon, 02 Sep 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/my-coding-experience-with-llm/</guid></item><item><title>Making a blog for the next 10 years</title><link>https://kokada.dev/blog/making-a-blog-for-the-next-10-years/</link><description><p>So one thing that I realise after starting writing this blog is that I care
+more about it than some of my other projects. For some reason or another I want
+to make sure that this blog will continue with me for a long time. This is one
+of the reasons why I use <a href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform">GitHub as mirror
+blog</a> and why I
+created a <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">bunch of
+automation</a>
+to make sure I never forget how to maintain this blog.</p>
+<p>Still, there are a bunch of dependencies that I need to make sure they're
+working so I can publish blog posts:</p>
+<ul>
+<li>Markdown</li>
+<li>A text editor</li>
+<li>Hosting and blog platform</li>
+<li>Shell script and
+<a href="https://kokada.dev/blog/abusing-makefiles-for-fun-and-profit">Makefile</a></li>
+<li>Go toolchain and modules</li>
+</ul>
+<p>Let's start with the most important one: the texts themselves, they're all
+written in <a href="https://www.markdownguide.org/">Markdown</a>. The nice thing about
+Markdown is that it is just plain text files with some special notation that
+allow you to format text, but the text itself is still legible even if you have
+no support to render Markdowns. So it means as long as I can read a plain text
+file, I can still read the posts, no issue there. Closely related issue here is
+the text editor, but the nice thing about Markdown is that if tomorrow I decide
+to change from <code>neovim</code> to, say, <a href="https://zed.dev/">Zed</a>, I can still write it
+Markdown files without issue. I also use a standardised Markdown implementation
+called <a href="https://commonmark.org/">CommonMark</a>, that fixes a bunch of ambiguities
+of the original Markdown spec.</p>
+<p>The next point is the host (<a href="capivaras.dev">capivaras.dev</a>) and the blog
+platform (<a href="https://github.com/mataroa-blog/mataroa">Mataroa</a>). One of the nice
+things about Mataroa is that it avoids platform lock-in by having multiple ways
+to <a href="https://mataroa.blog/export/">export your posts</a>. I could export everything
+to <a href="https://gohugo.io/">Hugo</a>, for example, and serve the blog from <a href="https://pages.github.com/">GitHub
+Pages</a>.</p>
+<p>This is especially nice consider how small <a href="capivaras.dev">capivaras.dev</a> is,
+so it is good to know that if I eventually have issues I could move to
+somewhere else. I also have an e-mail backup every month with all posts made
+(another <a href="https://hey.mataroa.blog/blog/monthly-auto-exports-via-email/">Mataroa
+feature</a>), and
+of course I have a <a href="https://github.com/thiagokokada/blog">Git repo</a> that also
+acts as a <a href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform">mirror of this
+blog</a>. So I would
+say the chance of losing access to the content is slim.</p>
+<p>One other issue is the URL of the posts that are indexed in many different
+places, like <a href="https://news.ycombinator.com/">Hacker News</a>,
+<a href="https://lobste.rs/">Lobte.rs</a>, etc. This is why I finally decide to bite the
+bullet and purchase a proper domain, and this website should now be available
+in <a href="kokada.dev">kokada.dev</a>. This means that in my eventual exit from
+<a href="capivaras.dev">capivaras.dev</a>, I can just point my new blog location to my own
+domain if needed (it is not as easy since I also need to preserve the post
+URLs, but shouldn't be difficult to fix this if I ever need to do so).</p>
+<p>Now for the tools that I use to publish from the original Markdown files to
+everything else. Let's start with shell script(s) and Makefile: I decided that
+they're less of an issue if they eventually stop working: they're only used to
+make my life easier, but I can still publish files manually if needed. Still, I
+tried to rewrite both the
+<a href="https://github.com/thiagokokada/blog/commit/a0d421ca90f3da059998295c5e3c6c7a6a3f0688">shell</a>
+and
+<a href="https://github.com/thiagokokada/blog/commit/074580065b21fbdaf930aa51968e69f015d49505">Makefile</a>
+to avoid GNUisms, so in the eventual case that I decide to e.g.: stop using a
+GNU/Linux system like NixOS and use a *BSD system instead, I am covered.</p>
+<p>In other projects I would probably add a <code>shell.nix</code> file and add the GNU
+versions of the tools that I am using, but I am trying to avoid Nix while
+building this blog as much as I can, mainly because it is not available
+everywhere (e.g.: *BSD systems).</p>
+<p>Go is the more important part: the tooling used to <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">publish this blog is
+written in
+Go</a>. Go
+is a good language when you want to ensure that things will work for a long
+time because of its <a href="https://go.dev/blog/compat">backwards compatibility
+guarantee</a>. Also I don't expect Google dropping Go
+development soon, but even if this happen (<a href="https://killedbygoogle.com/">&quot;killed by
+Google&quot;</a> is a thing after all), it is very likely
+some other group or company would adopt its development quickly, considering
+<a href="https://www.tiobe.com/tiobe-index/go/">how popular the language</a> is.</p>
+<p>However, the <a href="https://github.com/thiagokokada/blog/blob/main/go.mod">Go
+modules</a> that I depend
+are another story:</p>
+<ul>
+<li><a href="https://github.com/elliotchance/orderedmap/">elliotchance/orderedmap</a>: an
+ordered map implementation that I use until Go adds it in the <a href="https://kokada.dev/blog/an-unordered-list-of-things-i-miss-in-go">standard
+library</a></li>
+<li><a href="https://github.com/gorilla/feeds">gorilla/feeds</a>: a RSS generator library</li>
+<li><a href="https://github.com/gosimple/slug">gosimple/slug</a>: a
+<a href="https://developer.mozilla.org/en-US/docs/Glossary/Slug">slug</a> generator
+library</li>
+<li><a href="https://github.com/yuin/goldmark">yuin/goldmark</a>: a CommonMark parser and
+renderer</li>
+<li><a href="https://github.com/teekennedy/goldmark-markdown">teekennedy/goldmark-markdown</a>:
+a renderer for Goldmark to render back to Markdown (since Goldmark itself
+doesn't have this capacity)</li>
+</ul>
+<p>In common for all those modules are that they're clearly small projects
+maintained mostly by one developer. They're all very good, don't get me wrong,
+but they're still an reliability issue in the future. There is no guarantee
+those repositories will not be deleted tomorrow, for example.</p>
+<p>Yes, <a href="https://proxy.golang.org/">Go Proxy</a> exist, but from what I understood
+reading its page is that while it caches modules contents, this is not
+guarantee:</p>
+<blockquote>
+<p>proxy.golang.org does not save all modules forever. There are a number of
+reasons for this, but one reason is if proxy.golang.org is not able to detect
+a suitable license. In this case, only a temporarily cached copy of the
+module will be made available, and may become unavailable if it is removed
+from the original source and becomes outdated. The checksums will still
+remain in the checksum database regardless of whether or not they have become
+unavailable in the mirror.</p>
+</blockquote>
+<p>This is why this is the first project that made sense to me to use <a href="https://go.dev/ref/mod#go-mod-vendor"><code>go mod vendor</code></a>. Now I have a copy of the source
+code of all modules inside the
+<a href="https://github.com/thiagokokada/blog/tree/0b97630d6b30551ffe05b5d8124305b1065f729d/vendor">vendor</a>
+directory in the repository, avoiding the risks I commented above. This allows
+me to ensure that this blog will still be publishable in the future, as long as
+I have a working Go toolchain (and Go toolchain makes this
+<a href="https://kokada.dev/blog/quick-bits-go-automatically-downloads-a-newer-toolchain-if-needed">easy</a>).</p>
+<p>There are a few other things that can bitrot this blog, for example links going
+nowhere. I always try to use
+<a href="https://en.wikipedia.org/wiki/Permalink">permalinks</a> when it makes sense, but
+the only actual way to ensure those links would work in the future would be to
+point them to <a href="https://archive.org/">archive.org</a> (but even archive.org may not
+exist forever). Maybe something to fix in the future, hope not in the far
+future, before things start to break.</p></description><pubDate>Sat, 24 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/making-a-blog-for-the-next-10-years/</guid></item><item><title>An unordered list of hidden gems inside NixOS</title><link>https://kokada.dev/blog/an-unordered-list-of-hidden-gems-inside-nixos/</link><description><p>After using <a href="https://nixos.org/">NixOS</a> for the last 5+ years as my main OS, I
+end up with a <a href="https://github.com/thiagokokada/nix-configs/">configuration</a>
+with many things that are interesting for one reason or another, but it is not
+listed anywhere (well, except if you are the kind of person that reads <code>man 5 configuration.nix</code> or the release notes in every release).</p>
+<p>So kind in the same spirit as my <a href="https://kokada.dev/blog/an-unordered-list-of-things-i-miss-in-go">list of things that I miss in
+Go</a>, here is
+a list of modules that I find neat in NixOS and are not default already. Again,
+the list is unordered since this makes it easier to update in the future if I
+find something else, but also I don't want to think too hard about an order
+here.</p>
+<p>With all above, let's start.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/6afb255d976f85f3359e4929abd6f5149c323a02/nixos/modules/services/networking/nftables.nix"><code>networking.nftables</code></a></h2>
+<p><a href="https://www.nftables.org/">nftables</a> is, accordingly to Wikipedia:</p>
+<blockquote>
+<p>nftables is a subsystem of the Linux kernel providing filtering and
+classification of network packets/datagrams/frames.</p>
+</blockquote>
+<p>It is basically a replacement of the venerable
+<a href="https://en.wikipedia.org/wiki/Iptables">iptables</a>, that still exist and is the
+default program to configure the famous <code>networking.firewall</code>, the declarative
+<a href="https://wiki.nixos.org/wiki/Firewall">Firewall</a> that NixOS enable by default.</p>
+<p>To enable, it is simple, just add to your configuration:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">networking</span><span class="o">.</span><span class="n">nftables</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>And thanks to the fact that NixOS's Firewall is declarative, everything should
+still work as expect: any service that you set <code>openFirewall = true</code> will still
+have its ports open, if you set <code>networking.firewall.allowPing = false</code> it will
+still disable pings like before, etc.</p>
+<p>If you look at the documentation of the above option, you will find the
+following warning:</p>
+<blockquote>
+<p>Note that if you have Docker enabled you will not be able to use nftables
+without intervention. Docker uses iptables internally to setup NAT for
+containers. This module disables the ip_tables kernel module, however Docker
+automatically loads the module. Please see
+<a href="https://github.com/NixOS/nixpkgs/issues/24318#issuecomment-289216273">https://github.com/NixOS/nixpkgs/issues/24318#issuecomment-289216273</a> for
+more information.</p>
+</blockquote>
+<p>I don't use Docker (switched to Podman instead for quite a long time), so I
+don't know how bad the situation is. Also keep in mind that <code>nftables</code> does
+offer <code>iptables-compat</code> for compatibility with old iptables scripts, so it is
+most likely Docker doing something weird here.</p>
+<p>Now, the actual advantage from the user here is not clear: the main advantage
+from my point of view (and the reason I used to use in other distros like Arch)
+is the improved syntax, however if you are using the declarative NixOS's
+Firewall you are not interacting with either <code>iptables</code> or <code>nftables</code> directly
+anyway. <code>nftables</code> is supposed to be more efficient, but not sure most users
+will care about this.</p>
+<p>However if you are the kind of person that needs custom rules, switching to
+<code>nftables</code> does bring a few benefits, including
+<code>networking.nftables.checkRuleset</code> (enabled by default), that checks if your
+ruleset has syntax errors during build time. Really valuable to avoid issues
+only after switch.</p>
+<p>Anyway, this is one of those options that I think it should be the default for
+a long time, since most of the new development in NixOS firewall seems to be
+focusing <code>nftables</code> for a while.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/877d19523edcac81b167e8fd716ad2658da2adca/nixos/modules/system/activation/switchable-system.nix#L30-L38"><code>system.switch.enableNg</code></a></h2>
+<p><a href="https://github.com/NixOS/nixpkgs/pull/308801">This one</a> I just discovered
+today, but it has been available for a while (~2 months if you're using
+<code>nixos-unstable</code>). Finally someone is rewriting
+<a href="https://github.com/NixOS/nixpkgs/blob/b1eff03c35aa7c90ab3a4d9f6ef297dae5fba37b/nixos/modules/system/activation/switch-to-configuration.pl"><code>switch-to-configuration.pl</code></a>,
+the Perl script that is called everytime you run <code>nixos-rebuild switch</code>.</p>
+<p>Now, I am not one of those &quot;rewrite in Rust&quot; zealots, but in this case this is
+definitely worth it: <code>switch-to-configuration.pl</code> is one of those pieces of
+code in NixOS that most people avoid touching at the fear of breaking
+something. There is a reason why
+<a href="https://github.com/NixOS/nixpkgs/commit/eeb2588a59c938042b74183ce1da7052a6ef7e59"><code>nixos-rebuild</code></a>
+is as convoluted as it is, because even if it is a messy shell script, most
+people preferred to workaround issues from the <code>switch-to-configuration.pl</code>
+inside it than trying to understand the mess that <code>switch-to-configuration.pl</code>
+is.</p>
+<p>Trying this one is easy:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">system</span><span class="o">.</span><span class="n">switch</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">enable</span> <span class="o">=</span> <span class="no">false</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">enableNg</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Yes, you need to explicit set <code>system.switch.enable = false</code>, since the default
+is <code>true</code>.</p>
+<p>By the way, what is the reason you would want to set <code>system.switch.enable = false</code> before the <code>enableNg</code> appeared you ask? For systems that are immutable
+and updated by e.g.: image upgrades instead of modifying root.</p>
+<p>Enabling <code>switch-to-configuration-ng</code> right now is mostly for testing purposes,
+but one of the advantages that I saw is that system switches are (slightly)
+faster:</p>
+<pre><code>$ hyperfine &quot;sudo nixos-rebuild switch&quot; # switch-to-configuration.pl
+Benchmark 1: sudo nixos-rebuild switch
+ Time (mean ± σ): 3.576 s ± 0.035 s [User: 0.004 s, System: 0.014 s]
+ Range (min … max): 3.522 s … 3.645 s 10 runs
+</code><p><code>$ hyperfine &quot;sudo nixos-rebuild switch&quot; # switch-to-configuration-ng
+Benchmark 1: sudo nixos-rebuild switch
+Time (mean ± σ): 3.394 s ± 0.080 s [User: 0.004 s, System: 0.013 s]
+Range (min … max): 3.325 s … 3.608 s 10 runs
+</code></p></pre><p></p>
+<p>But yes, the difference is not enough to make a significant impact, and it is
+not the objective anyway. The real reason for the rewrite is to make it easier
+to collaborate. I hope one day we also have someone brave enough to rewrite the
+<code>nixos-rebuild</code> script in something saner.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/cce9aef6fd8f010d288d685b9d2a38f3b6ac47e9/nixos/modules/system/boot/systemd/initrd.nix"><code>boot.initrd.systemd</code></a></h2>
+<p>A quick recap on how a modern Linux distro generally boots: the first thing
+that the bootloader (say <a href="https://www.gnu.org/software/grub/">GRUB</a> or
+<a href="https://systemd.io/BOOT/">systemd-boot</a>) loads is <code>initrd</code> (<em>initial
+ramdisk</em>), a small image that runs from RAM and includes the Linux kernel and
+some utilities that are responsible for setting up the main system. For
+example, one of the responsibilities of the <code>initrd</code> is to mount the disks and
+start init system (<code>systemd</code>).</p>
+<p>It may surprising that this <code>initrd</code> image does <strong>not</strong> generally include
+<code>systemd</code>. Traditionally <code>initrd</code> is composed by a bunch of shell scripts and a
+minimal runtime (e.g.: <a href="https://www.busybox.net/">busybox</a>), however <code>systemd</code>
+can also do this job since a long time ago. It is just the role of the distros
+to integrate <code>systemd</code> inside the <code>initrd</code>.</p>
+<p>This is what <code>boot.initrd.systemd</code> does: enable <code>systemd</code> inside the <code>initrd</code>.
+It make a few subtle changes:</p>
+<ul>
+<li>If you are using <a href="https://wiki.nixos.org/wiki/Full_Disk_Encryption">Full Disk Encryption via
+LUKS</a>, you will get a
+different password prompt at login</li>
+<li>You will get <code>initrd</code> time information if using <code>systemd-analyze</code> to measure
+boot time
+<ul>
+<li>You can get even more information (bootloader) if you also use
+<code>systemd-boot</code></li>
+</ul>
+</li>
+<li>You will also get <code>systemd</code> style status about services during <code>initrd</code> (not
+only afterwards)</li>
+</ul>
+<p>But I think the main reason is that since <code>systemd</code> is event-driven, it should
+make boot more reliable, especially in challenging situations (like booting
+from network). I can't say that I have any system like this to test if it is
+actually more reliable or not, but I don't remember having any issues since I
+set <code>boot.initrd.systemd.enable = true</code>, so there is that.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/b4a09f1f9d1599478afadffa782a02690550447c/pkgs/development/libraries/pipewire/default.nix"><code>services.pipewire</code></a></h2>
+<p>If there is something in that list that has a good chance that you're using
+already, it is this one, especially if you're using
+<a href="https://wayland.freedesktop.org/">Wayland</a>. Still, I think it is interesting
+to include in this list since <a href="https://www.pipewire.org/">PipeWire</a> is great.</p>
+<p>The experience with PipeWire until now for me was seamless: I never had any
+issues with it, all my applications still work exactly as it always worked. I
+also didn't had any issues with
+<a href="https://www.freedesktop.org/wiki/Software/PulseAudio/">PulseAudio</a> for a
+while, but I still remember when I first tried PulseAudio during the 0.x in
+Fedora and having tons of issues. So bonus points for PipeWire developers for
+polishing the experience of enough that most people will feel no difference.</p>
+<p>To enable PipeWire, I would recommend:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">services</span><span class="o">.</span><span class="n">pipewire</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">alsa</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pulse</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># jack.enable = true;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="n">security</span><span class="o">.</span><span class="n">rtkit</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This enables both ALSA and PulseAudio emulation support in PipeWire for maximum
+compatibility with desktop applications (you can also enable
+<a href="https://jackaudio.org/"><code>jack</code></a> if you use professional audio applications).
+It also enables <a href="https://github.com/heftig/rtkit"><code>rtkit</code></a>, allowing PipeWire
+to get (soft) realtime, helping avoiding cracks during high CPU load.</p>
+<p>I also recommend taking a look at the <a href="https://wiki.nixos.org/wiki/PipeWire">Wiki
+article</a>, that has multiple interesting
+configurations that can be added for low-latency setups or improved codecs for
+Bluetooth devices.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/c9ec8289781a3c4ac4dd5c42c8d50dd65360e79c/nixos/modules/services/networking/networkmanager.nix#L264-L271"><code>networking.networkmanager.wifi.backend = &quot;iwd&quot;</code></a></h2>
+<p>There is a good change that you're using
+<a href="https://www.networkmanager.dev/"><code>NetworkManager</code></a> to manage network,
+especially for Wi-Fi. And if that is the case, I can't recommend enough
+changing the backend from the default <code>wpa_supplicant</code> to
+<a href="https://iwd.wiki.kernel.org/"><code>iwd</code></a>.</p>
+<p>If you think that your Wi-Fi takes a long time to connect/re-connect, it may be
+because <code>wpa_supplicant</code>. <code>iwd</code> seems much more optimised in this regard, and
+since switching to it I never felt that my Wi-Fi was worse than other OSes (and
+generally slightly better than Windows, but keep in mind that this is a
+non-scientific comparison).</p>
+<p>Not saying that I never had Wi-Fi issues since switching to <code>iwd</code>, however
+switching back to <code>wpa_supplicant</code> in those cases never fixed the issue (it was
+the same or worse), so I assume either bad hardware or drivers in those cases.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/d5badef1e0416160298aad6dd8604eaf8b6e7e52/nixos/modules/system/boot/tmp.nix#L25-L32"><code>boot.tmp.useTmpfs</code></a></h2>
+<p><em>Added in 2024-08-22</em></p>
+<p>Most Linux distro nowadays mount <code>/tmp</code> inside
+<a href="https://en.wikipedia.org/wiki/Tmpfs">tmpfs</a>, storing the files inside RAM (and
+making them actually temporary, e.g.: does not persist between reboots). There
+is a <a href="https://lwn.net/Articles/499410/">long discussion</a> whether this makes
+sense or not, but it is a fact that using <code>/tmp</code> as an storage for small files
+generally makes sense.</p>
+<p>However, NixOS still stores <code>/tmp</code> inside <code>/</code> by default. The main reason for
+this is because Nix, by default, still builds everything in <code>TMPDIR</code> (that
+defaults to <code>/tmp</code> if not set). To fix the situation you can do:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">boot</span><span class="o">.</span><span class="n">tmp</span><span class="o">.</span><span class="n">useTmpfs</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">systemd</span><span class="o">.</span><span class="n">services</span><span class="o">.</span><span class="n">nix-daemon</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">environment</span><span class="o">.</span><span class="n">TMPDIR</span> <span class="o">=</span> <span class="s2">&#34;/var/tmp&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This ensures that Nix will build in <code>/var/tmp</code>, that is the temporary directory
+for large files.</p>
+<p>If you don't want to use <code>/tmp</code> inside tmpfs for some reason, I recommend at
+least setting <code>boot.tmp.cleanOnBoot = true</code>. This is to avoid issues with e.g.:
+mistakenly writing a program that depends in <code>/tmp</code> being persistent, because
+this is the behavior that most other distros expects.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/68142254d20256e617f596a5d50f9950f98fa36a/nixos/modules/config/zram.nix"><code>zramSwap</code></a></h2>
+<p><em>Added in 2024-08-22</em></p>
+<p>Have a system with small amounts of RAM? <del>You can download more RAM for free,
+just click this <a href="https://downloadmoreram.com/">link</a>.</del> Well, just kidding, but
+you can actually improve RAM usage by compressing it. This is what
+<a href="https://en.wikipedia.org/wiki/Zram"><code>zram</code></a> does: it will create a block
+device using part of your RAM that will be compressed.</p>
+<p>While this means that whatever is in the compressed part can't be used as-is
+(it needs to be decompressed first), it means you can store a lot more
+information. And since RAM is much faster than disk, this generally is a good
+trade-off. It is still recommended that you have some swap space though, e.g.:
+to swap pages that are unused.</p>
+<p>To enable it, you can do:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">zramSwap</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">algorithm</span> <span class="o">=</span> <span class="s2">&#34;zstd&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>You can play a little with the <code>zramSwap.algorithm</code> parameter, but I recommend
+either <code>lz4</code> or <code>zstd</code>. It is important for the compression algorithm to be
+fast, since you probably want to minimise CPU usage. Well, unless you have a
+very good CPU and small amounts of RAM, them it may make sense to use an
+algorithm that compress better but uses more CPU.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/5356420466c4d7901b63acc5e337c5bf30573f8a/nixos/modules/services/misc/fstrim.nix"><code>services.fstrim</code></a></h2>
+<p><em>Added in 2024-08-22</em></p>
+<p>Do you have a SSD? If so, you probably want to
+<a href="https://en.wikipedia.org/wiki/Trim_(computing)">trim</a> it regularly to keep a
+good performance. This should be as easy as:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">services</span><span class="o">.</span><span class="n">fstrim</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>One caveat though: if you are using Full Disk Encryption with LUKS, you also
+need to enable <code>boot.initrd.luks.devices.&lt;name&gt;.allowDiscards</code>, otherwise
+<code>fstrim</code> will not work. The reason that this is not enabled by default is
+because there are some <a href="https://asalor.blogspot.com/2011/08/trim-dm-crypt-problems.html">security
+implications</a>.
+It shouldn't be an issue for most people, but if you are paranoid please assess
+your risks first.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/e83fc891118e5e5660ccca000040e33b0a0a3080/nixos/modules/system/boot/binfmt.nix"><code>boot.binfmt.emulatedSystems</code></a></h2>
+<p><em>Added in 2024-08-22</em></p>
+<p>This is one of my favorites. Do you want to have the power to run binaries from
+other architectures like
+<a href="https://en.wikipedia.org/wiki/ARM_architecture_family">ARM</a> or
+<a href="https://en.wikipedia.org/wiki/RISC-V">RISC-V</a>? In NixOS it is easy:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">boot</span><span class="o">.</span><span class="n">binfmt</span><span class="o">.</span><span class="n">emulatedSystems</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;aarch64-linux&#34;</span> <span class="s2">&#34;riscv64-linux&#34;</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This will install a QEMU emulator for the target architectures, and configure
+<a href="https://en.wikipedia.org/wiki/Binfmt_misc"><code>binfmt</code></a> so that the kernel will
+automatically detect when a binary from another architecture is run,
+running it with the QEMU emulator instead.</p>
+<p>Now, keep in mind that you still need e.g.: libraries for the target
+architecture. However this is where the Nix magic comes in, you can easily
+compile something to another architecture as:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> uname -a
+</span></span><span class="line"><span class="cl"><span class="go">Linux sankyuu-nixos 6.10.3 #1-NixOS SMP PREEMPT_DYNAMIC Sat Aug 3 07:01:09 UTC 2024 x86_64 GNU/Linux
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="gp">$</span> <span class="nb">cd</span> nixpkgs
+</span></span><span class="line"><span class="cl"><span class="gp">$</span> nix build .#hello --system aarch64-linux
+</span></span><span class="line"><span class="cl"><span class="gp">$</span> file ./result/bin/hello
+</span></span><span class="line"><span class="cl"><span class="go">./result/bin/hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically linked, interpreter /nix/store/kz7xglxzhad64v667wwpn8vrxhjwcbna-glibc-2.39-52/lib/ld-linux-aarch64.so.1, for GNU/Linux 3.10.0, not stripped
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="gp">$</span> ./result/bin/hello
+</span></span><span class="line"><span class="cl"><span class="go">Hello, world!
+</span></span></span></code></pre><p>And since the binary will be linked with the libraries from the target
+architecture, everything works as expect.</p>
+<p>You also need to temper your expectations: QEMU emulation is slow. It is
+sufficient fast to build small programs, but if you need to build something
+bigger, I would recommend you to do it via <a href="https://kokada.dev/blog/building-static-binaries-in-nix">cross-compilation
+instead</a>.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/d9cf6ea6f809b862b73766705bdadb1236eeeff8/nixos/modules/services/system/dbus.nix#L40-L50"><code>services.dbus.implementation = &quot;broker&quot;</code></a></h2>
+<p><em>Added in 2024-08-22</em></p>
+<p>Someone in
+<a href="https://lobste.rs/s/ymmale/unordered_list_hidden_gems_inside_nixos#c_dz1hck">Lobste.rs</a>
+remembered me of this gem: <a href="https://github.com/bus1/dbus-broker">dbus-broker</a>,
+a high performance implementation of
+<a href="https://en.wikipedia.org/wiki/D-Bus">D-Bus</a>.</p>
+<p>For those who doesn't know, D-Bus is the <a href="https://en.wikipedia.org/wiki/Inter-process_communication">Inter-Process
+Communication</a>
+protocol used mostly in Linux desktop. And distros like
+<a href="https://archlinux.org/news/making-dbus-broker-our-default-d-bus-daemon/">Arch</a>
+and
+<a href="https://fedoraproject.org/wiki/Changes/DbusBrokerAsTheDefaultDbusImplementation">Fedora</a>
+already use it to default, so there aren't lots of reason to not use it.</p>
+<h2><a href="https://github.com/NixOS/nixpkgs/blob/6afb255d976f85f3359e4929abd6f5149c323a02/nixos/modules/services/hardware/irqbalance.nix"><code>services.irqbalance</code></a></h2>
+<p><em>Added in 2024-08-23</em></p>
+<p>Here is one that I have no experience but got curious after this comment in
+<a href="https://lobste.rs/s/ymmale/unordered_list_hidden_gems_inside_nixos#c_aghpwy">Lobte.rs</a>:</p>
+<blockquote>
+<p>One more option to add is maybe <code>services.irqbalance.enable</code>. For my old
+laptop it’s a life savior: no more freezes of the DE or video playback during
+heavy operations like e.g. compilation.</p>
+</blockquote>
+<p>Never tried it before but will give a try!</p></description><pubDate>Wed, 21 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/an-unordered-list-of-hidden-gems-inside-nixos/</guid></item><item><title>Quick bits: using forks with Go modules</title><link>https://kokada.dev/blog/quick-bits-using-forks-with-go-modules/</link><description><p>There are 2 types of blog posts: the ones you write for others, and the ones
+that you write for yourself. This blog post is the latter kind. What I am going
+to talk here is probably something most people know, but I didn't, and the
+documentation is all scattered in the internet. So I am writing mostly to
+remember myself, in future, if I have the same kind of issue what I need to do.</p>
+<p>The context: <a href="https://mataroa.blog/">Mataroa</a>, the blog platform
+<a href="https://capivaras.dev">capivaras.dev</a> is hosted on, relies in
+<a href="https://python-markdown.github.io/">python-markdown</a>, predates
+<a href="https://commonmark.org/">CommonMark</a> specification and as such, has some
+incompatibilities. One of those incompatibilities with CommonMark is the way
+sub lists are handled. From the documentation:</p>
+<blockquote>
+<p>The syntax rules clearly state that when a list item consists of multiple
+paragraphs, “each subsequent paragraph in a list item must be indented by
+either 4 spaces or one tab” (emphasis added). However, many implementations
+do not enforce this rule and allow less than 4 spaces of indentation. The
+implementers of Python-Markdown consider it a bug to not enforce this rule.</p>
+</blockquote>
+<p>CommonMark <a href="https://spec.commonmark.org/0.31.2/#lists">relax those
+restrictions</a>, allowing a sublist to
+be defined with just 2 spaces of indentation.</p>
+<p>So I have automated all posts from this blog <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">using
+Go</a> and
+a CommonMark renderer called <a href="https://github.com/yuin/goldmark/">Goldmark</a>. I
+them re-render the Markdown to Mataroa using a <a href="https://github.com/teekennedy/goldmark-markdown">Markdown
+renderer</a> before publising to
+<a href="https://capivaras.dev">capivaras.dev</a>, because this allow me to do some
+transformations in the original Markdown. It mostly works fine except for sub
+lists, thanks to the fact that the Markdown renderer I am using renders sub
+lists with 2 spaces.</p>
+<p>The only reason sub lists are working right now is because
+<a href="https://gluer.org/">@ratsclub</a> fixed this issue in the fork that
+<a href="https://capivaras.dev">capivaras.dev</a> runs. But I want to be compatible with
+the official instance if I ever need to migrate.</p>
+<p>The solution? Let's fix this in a
+<a href="https://github.com/teekennedy/goldmark-markdown/pull/21">PR</a>. However now that
+I have code to fix the issue, how can I use it without waiting upstream to
+merge my code?</p>
+<p>If you are using Go modules it is easy, you just need to use the <a href="https://go.dev/ref/mod#go-mod-file-replace"><code>replace</code>
+directive</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="nx">module</span> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">thiagokokada</span><span class="o">/</span><span class="nx">blog</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="k">go</span> <span class="mf">1.23</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">require</span> <span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">elliotchance</span><span class="o">/</span><span class="nx">orderedmap</span><span class="o">/</span><span class="nx">v2</span> <span class="nx">v2</span><span class="mf">.4.0</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">gorilla</span><span class="o">/</span><span class="nx">feeds</span> <span class="nx">v1</span><span class="mf">.2.0</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">gosimple</span><span class="o">/</span><span class="nx">slug</span> <span class="nx">v1</span><span class="mf">.14.0</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">teekennedy</span><span class="o">/</span><span class="nx">goldmark</span><span class="o">-</span><span class="nx">markdown</span> <span class="nx">v0</span><span class="mf">.3.0</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">yuin</span><span class="o">/</span><span class="nx">goldmark</span> <span class="nx">v1</span><span class="mf">.7.4</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">yuin</span><span class="o">/</span><span class="nx">goldmark</span><span class="o">-</span><span class="nx">highlighting</span> <span class="nx">v0</span><span class="mf">.0.0</span><span class="o">-</span><span class="mi">20220208100518</span><span class="o">-</span><span class="mi">594</span><span class="nx">be1970594</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">require</span> <span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">alecthomas</span><span class="o">/</span><span class="nx">chroma</span> <span class="nx">v0</span><span class="mf">.10.0</span> <span class="c1">// indirect
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">dlclark</span><span class="o">/</span><span class="nx">regexp2</span> <span class="nx">v1</span><span class="mf">.11.4</span> <span class="c1">// indirect
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">gosimple</span><span class="o">/</span><span class="nx">unidecode</span> <span class="nx">v1</span><span class="mf">.0.1</span> <span class="c1">// indirect
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nx">replace</span> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">teekennedy</span><span class="o">/</span><span class="nx">goldmark</span><span class="o">-</span><span class="nx">markdown</span> <span class="p">=&gt;</span> <span class="nx">github</span><span class="p">.</span><span class="nx">com</span><span class="o">/</span><span class="nx">thiagokokada</span><span class="o">/</span><span class="nx">goldmark</span><span class="o">-</span><span class="nx">markdown</span> <span class="nx">v0</span><span class="mf">.0.0</span><span class="o">-</span><span class="mi">20240820111219</span><span class="o">-</span><span class="nx">f30775d8ed15</span>
+</span></span></code></pre><p>This will replace all usages of <code>github.com/teekennedy/goldmark-markdown</code> to my
+fork in <code>github.com/thiagokokada/goldmark-markdown</code>. You even get all the
+reproducibility of modules since Go automatically pins the commit.</p>
+<p>Since the Go format for versions is quite unique, you can just set to the
+desired branch (e.g.: instead of <code>v0.0.0-20240820111219-f30775d8ed15</code>, you can
+use <code>add-sublist-length-opt</code> that is the branch name) and run <code>go mod tidy</code> to
+fix the format.</p></description><pubDate>Tue, 20 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/quick-bits-using-forks-with-go-modules/</guid></item><item><title>Quick bits: Go automatically downloads a newer toolchain if needed</title><link>https://kokada.dev/blog/quick-bits-go-automatically-downloads-a-newer-toolchain-if-needed/</link><description><p>I am using
+<a href="https://github.com/elliotchance/orderedmap/">elliotchance/orderedmap</a> as my
+choice of ordered maps (since Go <a href="https://kokada.dev/blog/an-unordered-list-of-things-i-miss-in-go">doesn't have
+one</a> in
+standard library yet). I recently did a
+<a href="https://github.com/elliotchance/orderedmap/pull/41">PR</a> to implement Go 1.23
+iterators, because I find them neat, however I was avoiding to use it in the
+code that generates this <a href="https://github.com/thiagokokada/blog">blog</a> since Go
+1.23 was just released and is still not the default Go in
+<a href="https://github.com/NixOS/nixpkgs">nixpkgs</a>.</p>
+<p>I decided that I would create a
+<a href="https://github.com/thiagokokada/blog/pull/2">branch</a> and leave there for a few
+months, until I decided to try to run the code locally and got this:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> go build
+</span></span><span class="line"><span class="cl"><span class="go">go: downloading go1.23.0 (darwin/arm64)
+</span></span></span></code></pre><p>Nice. And before you ask, yes, the compiled binary works perfectly:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make
+</span></span><span class="line"><span class="cl"><span class="go">./blog &gt; README.md
+</span></span></span><span class="line"><span class="cl"><span class="go">./blog -rss &gt; rss.xml
+</span></span></span></code></pre><p>So how does this work? Take a look at the documentation in the official <a href="https://tip.golang.org/doc/toolchain">Golang
+page</a>:</p>
+<blockquote>
+<p>Starting in Go 1.21, the Go distribution consists of a go command and a
+bundled Go toolchain, which is the standard library as well as the compiler,
+assembler, and other tools. The go command can use its bundled Go toolchain
+as well as other versions that it finds in the local PATH or downloads as
+needed.</p>
+</blockquote>
+<p>There are a bunch of rules here that I am not going to enter in detail (I
+recommend you to read the official documentation), but a quick summary:</p>
+<ul>
+<li>
+<p>Go will download a toolchain when either <code>go</code> or <code>toolchain</code> lines <code>go.mod</code>
+is set to a Go version higher than your current <code>go</code> binary</p>
+<ul>
+<li>But only if your <code>go</code> binary is at least version 1.21, since this is the
+version that introduces this behavior</li>
+</ul>
+</li>
+<li>
+<p>You can force a specific toolchain with <code>GOTOOLCHAIN</code> environment setting,
+e.g.: <code>GOTOOLCHAIN=1.23</code></p>
+<ul>
+<li>The default value for <code>GOTOOLCHAIN</code> is <code>auto</code>, that basically has the
+behavior described in this post</li>
+<li>You can also set to <code>local</code> to always use the current <code>go</code> binary, or the
+previous behaviour pre-1.21 Go</li>
+<li>There is also <code>&lt;name&gt;+auto</code> and <code>path</code> options, that can be seen in the
+docs</li>
+</ul>
+</li>
+<li>
+<p>The downloaded toolchains go to whatever your <code>GOPATH</code> is, inside
+<code>golang.org/toolchain</code> module, and version <code>v0.0.1-goVERSION.GOOS-GOARCH</code>, for
+example:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ls -lah <span class="nv">$GOPATH</span>/pkg/mod/golang.org/toolchain@v0.0.1-go1.23.0.darwin-arm64
+</span></span><span class="line"><span class="cl"><span class="go">total 64
+</span></span></span><span class="line"><span class="cl"><span class="go">dr-xr-xr-x 14 user staff 448B 19 Aug 12:01 .
+</span></span></span><span class="line"><span class="cl"><span class="go">drwxr-xr-x 4 user staff 128B 19 Aug 12:01 ..
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 1.3K 19 Aug 12:01 CONTRIBUTING.md
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 1.4K 19 Aug 12:01 LICENSE
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 1.3K 19 Aug 12:01 PATENTS
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 1.4K 19 Aug 12:01 README.md
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 426B 19 Aug 12:01 SECURITY.md
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 35B 19 Aug 12:01 VERSION
+</span></span></span><span class="line"><span class="cl"><span class="go">dr-xr-xr-x 4 user staff 128B 19 Aug 12:01 bin
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 52B 19 Aug 12:01 codereview.cfg
+</span></span></span><span class="line"><span class="cl"><span class="go">-r--r--r-- 1 user staff 505B 19 Aug 12:01 go.env
+</span></span></span><span class="line"><span class="cl"><span class="go">dr-xr-xr-x 3 user staff 96B 19 Aug 12:01 lib
+</span></span></span><span class="line"><span class="cl"><span class="go">dr-xr-xr-x 4 user staff 128B 19 Aug 12:01 pkg
+</span></span></span><span class="line"><span class="cl"><span class="go">dr-xr-xr-x 77 user staff 2.4K 19 Aug 12:02 src
+</span></span></span></code></pre></li>
+</ul>
+<p>By the way, this only works well because Go toolchain binaries are static.</p>
+<p>While I don't like a program downloading random binaries from the internet, I
+like what Go is doing here. It makes the whole bootstrapping process for a Go
+project much easier: as long as you have a reasonable up-to-date <code>go</code> binary in
+your <code>PATH</code>, you should be ready to go (pun intended). And Go modules are
+already reasonable secure, ensuring that each module have a proper checksum. As
+long as nobody else can publish modules in <code>golang.org/toolchain</code> namespace I
+can't see much of a security issue here, but I am not a security expert.</p>
+<p>But if you don't like this behavior, you can always disable it by setting
+<code>GOTOOLCHAIN=local</code>. And just do not forget to set this in your
+<a href="https://brandur.org/fragments/go-version-matrix">CI</a>, unless you don't care
+about Go versions.</p></description><pubDate>Mon, 19 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/quick-bits-go-automatically-downloads-a-newer-toolchain-if-needed/</guid></item><item><title>An unordered list of things I miss in Go</title><link>https://kokada.dev/blog/an-unordered-list-of-things-i-miss-in-go/</link><description><p>I like Go. I think it is a <a href="https://kokada.dev/blog/go-a-reasonable-good-language">reasonable good
+language</a>, and has some
+good qualities that makes up for its flaws. However, this doesn't mean I think
+the language couldn't be better, far from it.</p>
+<p>This blog post is a list of things that I miss from Go from other languages.
+Some of the things here could probably be implemented soon, some other would
+probably need a major revision of the language. The list is unordered, because
+this makes it easier for me to update in the future if I found something else,
+but also because I don't want to think too hard about giving each point here a
+rank.</p>
+<p>With all above, let's start.</p>
+<h2>Ordered maps in standard library</h2>
+<p>When I first learned about
+<a href="https://docs.python.org/3/library/stdtypes.html#typesmapping">dictionaries</a> in
+Python it quickly became one of my favorite data structures ever. They're
+extremely versatile, and most modern programming languages have something
+similar in its standard library. Go isn't different, it has
+<a href="https://go.dev/blog/maps"><code>map</code></a>, that is Go implementation of a <a href="https://en.wikipedia.org/wiki/Hash_table">hash
+table</a>. However <code>map</code> in Go are
+quirky, for example:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">main</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span> <span class="o">:=</span> <span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kt">bool</span><span class="p">{</span><span class="s">&#34;foo&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span> <span class="s">&#34;bar&#34;</span><span class="p">:</span> <span class="kc">false</span><span class="p">,</span> <span class="s">&#34;baz&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span> <span class="s">&#34;qux&#34;</span><span class="p">:</span> <span class="kc">false</span><span class="p">,</span> <span class="s">&#34;quux&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nx">k</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">m</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">println</span><span class="p">(</span><span class="nx">k</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> go run ./test.go
+</span></span><span class="line"><span class="cl"><span class="go">bar
+</span></span></span><span class="line"><span class="cl"><span class="go">baz
+</span></span></span><span class="line"><span class="cl"><span class="go">qux
+</span></span></span><span class="line"><span class="cl"><span class="go">quux
+</span></span></span><span class="line"><span class="cl"><span class="go">foo
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> go run ./test.go
+</span></span><span class="line"><span class="cl"><span class="go">foo
+</span></span></span><span class="line"><span class="cl"><span class="go">bar
+</span></span></span><span class="line"><span class="cl"><span class="go">baz
+</span></span></span><span class="line"><span class="cl"><span class="go">qux
+</span></span></span><span class="line"><span class="cl"><span class="go">quux
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> go run ./test.go
+</span></span><span class="line"><span class="cl"><span class="go">qux
+</span></span></span><span class="line"><span class="cl"><span class="go">quux
+</span></span></span><span class="line"><span class="cl"><span class="go">foo
+</span></span></span><span class="line"><span class="cl"><span class="go">bar
+</span></span></span><span class="line"><span class="cl"><span class="go">baz
+</span></span></span></code></pre><p>Now, I don't expect any hash table implementation to keep the order of the
+elements, but Go actually <a href="https://victoriametrics.com/blog/go-map/">randomise each map
+instance</a>:</p>
+<blockquote>
+<p>But here’s the deal, while the hash function used for maps in Go is
+consistent across all maps with <strong>the same key type</strong>, the <code>seed</code> used by
+that hash function is different for each map instance. So, when you create a
+new map, Go generates a random seed just for that map.</p>
+</blockquote>
+<p>While I understand the reason for this (i.e.: to avoid developers relying in a
+specific iteration order), I still find it weird, and I think this is something
+unique for Go. This decision means that even if you don't care about a specific
+order, you will still need to sort the map before doing something else if you
+want reproducibility, something that I care a lot.</p>
+<p>The fix for this? Go could offer an ordered map implementation inside the
+standard library. An ordered map ensure that the iteration order of the map is
+the same as the insertion order (that is, by the way, a powerful property that
+allow maps to be used in other contexts, not just my pet peeve above).</p>
+<p>Python actually does this for any dictionaries since <a href="https://stackoverflow.com/a/39980744">Python
+3.6</a>, but it offered an
+<a href="https://docs.python.org/3/library/collections.html#collections.OrderedDict">OrderedDict</a>
+before it (and <code>OrderedDict</code> still has some methods that normal <code>dict</code> doesn't,
+that maybe useful in specific cases).</p>
+<p>Before generics it would be impossible to have a type-safe API for such data
+structure without introducing a new data type in the language (like <code>slices</code>),
+but now Go has generics so it is not an issue anymore. The other issue is that
+you would be forced to iterate manually in this new data structure, but thanks
+to the new <a href="https://tip.golang.org/doc/go1.23#language"><code>range-over-func</code></a> in
+Go 1.23, it means we can iterate in an ordered map as a library almost exactly
+like we can do as a <code>map</code>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">import</span> <span class="s">&#34;orderedmap&#34;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span> <span class="o">:=</span> <span class="nx">orderedmap</span><span class="p">.</span><span class="nx">New</span><span class="p">[</span><span class="kt">string</span><span class="p">,</span> <span class="kt">bool</span><span class="p">]()</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span><span class="p">.</span><span class="nf">Set</span><span class="p">(</span><span class="s">&#34;foo&#34;</span><span class="p">,</span> <span class="kc">true</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span><span class="p">.</span><span class="nf">Set</span><span class="p">(</span><span class="s">&#34;bar&#34;</span><span class="p">,</span> <span class="kc">false</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">m</span><span class="p">.</span><span class="nf">Set</span><span class="p">(</span><span class="s">&#34;baz&#34;</span><span class="p">,</span> <span class="kc">true</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nx">k</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">m</span><span class="p">.</span><span class="nf">Iterator</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">println</span><span class="p">(</span><span class="nx">k</span><span class="p">)</span> <span class="c1">// Order always will be: foo, bar, baz
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Now, of course the lack of Ordered Map in the standard library can be filled
+with third party implementations, e.g.: I am using this
+<a href="https://github.com/elliotchance/orderedmap">one</a> in one of my projects. But
+being in standard library reduces the friction: if there was some
+implementation in standard library, I would generally prefer it unless I have
+some specific needs. However when the standard library doesn't offer what I
+need, I need to find it myself a suitable library, and this ends up taking time
+since generally there are lots of alternatives.</p>
+<h2>Keyword and default arguments for functions</h2>
+<p>Something that comes straight from Python that I miss sometimes in Go is that
+you can do things like this when declaring a function:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">hello</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s2">&#34;World&#34;</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;Hello, </span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="n">hello</span><span class="p">(</span><span class="s2">&#34;Foo&#34;</span><span class="p">)</span> <span class="c1"># &#34;normal&#34; function call</span>
+</span></span><span class="line"><span class="cl"><span class="n">hello</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s2">&#34;Bar&#34;</span><span class="p">)</span> <span class="c1"># calling with keyword arguments</span>
+</span></span><span class="line"><span class="cl"><span class="n">hello</span><span class="p">()</span> <span class="c1"># calling with default arguments</span>
+</span></span></code></pre><pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> python hello.py
+</span></span><span class="line"><span class="cl"><span class="go">Hello, Foo
+</span></span></span><span class="line"><span class="cl"><span class="go">Hello, Bar
+</span></span></span><span class="line"><span class="cl"><span class="go">Hello, World
+</span></span></span></code></pre><p>The lack of default arguments especially affects even some of the API decisions
+for Go standard library, for example, <code>string.Replace</code>:</p>
+<blockquote>
+<p><code>func Replace(s, old, new string, n int) string</code></p>
+<p>Replace returns a copy of the string s with the first n non-overlapping
+instances of old replaced by new. If old is empty, it matches at the
+beginning of the string and after each UTF-8 sequence, yielding up to k+1
+replacements for a k-rune string. If n &lt; 0, there is no limit on the number
+of replacements.</p>
+</blockquote>
+<p>If Go had default arguments, <code>Replace</code> could have e.g.: <code>func Replace(s, old, new string, n int = -1)</code> signature, that would mean we don't need
+<code>strings.ReplaceAll</code> (since this is basically what this function does, call
+<code>strings.Replace(s, old, new, -1)</code>).</p>
+<h2>Nullability (or nillability)</h2>
+<p>I talked I little about this in <a href="https://kokada.dev/blog/go-a-reasonable-good-language">my previous post about
+Go</a>, but I want to
+expand here.</p>
+<p>First, I don't think the language needs to support the generic solution for
+nullability, that would be either having proper Union or Sum types. Kotlin
+AFAIK doesn't support neither, but my 2 years experience with Kotlin showed
+that just having nullable types already helped a lot in ensuring type safety.</p>
+<p>Second, I do feel that Go has less issues with <code>nil</code> values, than say, Java,
+because its decision of using zero values instead of <code>nil</code> in many cases. So
+for example, a string can never be <code>nil</code>, however a string pointer can be. This
+means that this is fine:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span><span class="p">(</span><span class="nx">s</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// do something with s
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
+</span></span></code></pre><p>However:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span><span class="p">(</span><span class="nx">s</span> <span class="o">*</span><span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// s maybe nil here, better check first
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
+</span></span></code></pre><p>Still, I get more <code>panic</code> for <code>nil</code> pointer deference than I get in other
+languages that offer nullables (heck, even Python with
+<a href="https://www.mypy-lang.org/"><code>mypy</code></a> is safer).</p>
+<p>Sadly this is the change in this post that is more likely to need a completely
+new revision of the language.
+<a href="https://github.com/golang/go/issues/49202">nillability</a> was proposed before,
+but it is really unlikely it can be done without breaking backwards
+compatibility.</p>
+<p>It could be done the Java way by adding a <code>nullable</code> type to the standard
+library (<a href="https://jcp.org/en/jsr/detail?id=305">JSR305</a>), but the fact that
+<a href="https://stackoverflow.com/questions/2289694/what-is-the-status-of-jsr-305">JSR305 is considerd
+dead</a>
+by many shows how difficult it is to do something like this without a major
+change in the language. Dart is the only language that I know that <a href="https://dart.dev/null-safety/understanding-null-safety">did this
+successfully</a>, but
+definitely it was not without its pains. And the fact that most people that
+program in Dart probably does because of Flutter (that eventually required
+newer versions with null-safety) is not a good sign.</p>
+<h2>Lambdas</h2>
+<p><em>Added in 2024-08-18</em></p>
+<p>Go is a surprising good language for some functional code, thanks to having
+first class functions and closures. Sadly the syntax doesn't help, since the
+only way you can use anonymous functions in Go is using <code>func</code>. Especially if
+the types are complex, this can result in some convoluted code. Take the
+example from the <a href="https://go.dev/wiki/RangefuncExperiment"><code>range-over-func</code>
+experiment</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">slices</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">Backward</span><span class="p">[</span><span class="nx">E</span> <span class="nx">any</span><span class="p">](</span><span class="nx">s</span> <span class="p">[]</span><span class="nx">E</span><span class="p">)</span> <span class="kd">func</span><span class="p">(</span><span class="kd">func</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="nx">E</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="kd">func</span><span class="p">(</span><span class="nx">yield</span> <span class="kd">func</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="nx">E</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">--</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">!</span><span class="nf">yield</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">s</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>If Go had a syntax for lambdas, especially if we could elide the types, this
+could be simplified a lot:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">slices</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">Backward</span><span class="p">[</span><span class="nx">E</span> <span class="nx">any</span><span class="p">](</span><span class="nx">s</span> <span class="p">[]</span><span class="nx">E</span><span class="p">)</span> <span class="kd">func</span><span class="p">(</span><span class="kd">func</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="nx">E</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="p">(</span><span class="nx">yield</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">--</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">!</span><span class="nf">yield</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">s</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Or even something like this would already help, no special syntax but allowing
+the types to be elided in an unnamed function:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kn">package</span> <span class="nx">slices</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">Backward</span><span class="p">[</span><span class="nx">E</span> <span class="nx">any</span><span class="p">](</span><span class="nx">s</span> <span class="p">[]</span><span class="nx">E</span><span class="p">)</span> <span class="kd">func</span><span class="p">(</span><span class="kd">func</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="nx">E</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="kd">func</span><span class="p">(</span><span class="nx">yield</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">--</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="p">!</span><span class="nf">yield</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">s</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This feature I am still somewhat hopeful that may become a reality in some
+future version of the language, since they didn't close the
+<a href="https://github.com/golang/go/issues/21498">issue</a> yet, and the discussion
+about the possibility of this feature is still ongoing.</p>
+<h2>Error on unused return values</h2>
+<p><em>Added in 2024-09-12</em></p>
+<p>In a <a href="https://kokada.dev/blog/my-coding-experience-with-llm">recent post about
+LLMs</a>, I talked about
+this function that I asked ChatGPT to generate to create a socket that accepted
+a <a href="https://pkg.go.dev/context">context</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">readWithContext</span><span class="p">(</span><span class="nx">ctx</span> <span class="nx">context</span><span class="p">.</span><span class="nx">Context</span><span class="p">,</span> <span class="nx">conn</span> <span class="nx">net</span><span class="p">.</span><span class="nx">Conn</span><span class="p">,</span> <span class="nx">buf</span> <span class="p">[]</span><span class="kt">byte</span><span class="p">)</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kd">struct</span><span class="p">{})</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">n</span> <span class="kt">int</span>
+</span></span><span class="line"><span class="cl"> <span class="kd">var</span> <span class="nx">err</span> <span class="kt">error</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1">// Start a goroutine to perform the read
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">Read</span><span class="p">(</span><span class="nx">buf</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">close</span><span class="p">(</span><span class="nx">done</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}()</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">select</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">ctx</span><span class="p">.</span><span class="nf">Done</span><span class="p">():</span> <span class="c1">// Context was canceled or timed out
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="c1">// Set a short deadline to unblock the Read()
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"> <span class="o">&lt;-</span><span class="nx">done</span> <span class="c1">// Wait for the read to finish
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">ctx</span><span class="p">.</span><span class="nf">Err</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">done</span><span class="p">:</span> <span class="c1">// Read finished successfully
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">return</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>However while reading <a href="https://joeduffyblog.com/2016/02/07/the-error-model/">this blog
+post</a> about &quot;The Error
+Model&quot;, I realised that this function is lacking error check during
+<code>conn.SetReadDeadline()</code> calls:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">readWithContext</span><span class="p">(</span><span class="nx">ctx</span> <span class="nx">context</span><span class="p">.</span><span class="nx">Context</span><span class="p">,</span> <span class="nx">conn</span> <span class="nx">net</span><span class="p">.</span><span class="nx">Conn</span><span class="p">,</span> <span class="nx">buf</span> <span class="p">[]</span><span class="kt">byte</span><span class="p">)</span> <span class="p">(</span><span class="nx">n</span> <span class="kt">int</span><span class="p">,</span> <span class="nx">err</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kd">struct</span><span class="p">{})</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1">// Start a goroutine to perform the read
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">Read</span><span class="p">(</span><span class="nx">buf</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">close</span><span class="p">(</span><span class="nx">done</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}()</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">select</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">done</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">ctx</span><span class="p">.</span><span class="nf">Done</span><span class="p">():</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Set a short deadline to unblock the Read()
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Reset read deadline
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="k">defer</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Time</span><span class="p">{});</span> <span class="nx">e</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">err</span> <span class="p">=</span> <span class="nx">errors</span><span class="p">.</span><span class="nf">Join</span><span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">e</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}()</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// Make sure that the goroutine is done to avoid leaks
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="o">&lt;-</span><span class="nx">done</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">errors</span><span class="p">.</span><span class="nf">Join</span><span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">ctx</span><span class="p">.</span><span class="nf">Err</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>I could blame the LLM on this, but this is the type of mistake that I could see
+happening even in a Pull Request done by an actual human.</p>
+<p>Ignoring errors is bad, especially because once the error is ignored it is
+gone, forever. You may have strange issues in the code that are impossible to
+debug because you can't know about something that doesn't exist. This is one of
+the reasons I think exceptions are better, since this is the kind of error that
+would be impossible to ignore if the language had exceptions, and the exception
+would eventually propagate in your stack until it is captured or you get a
+crash (with a stack trace to debug the issue).</p>
+<p>Now, I don't think this is a fault of using error as values instead of
+exceptions. Go has the tools to encapsulate the errors and propagate them
+properly, like it is shown in the fixed code. But the fact that someone can do
+this mistake without any warning or error from the compiler is bad.</p>
+<p>If Go had a warning or error for unused return values, this would be different:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">foo</span><span class="p">(</span><span class="nx">conn</span> <span class="o">*</span><span class="nx">net</span><span class="p">.</span><span class="nx">Conn</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// ...
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">_</span> <span class="p">=</span> <span class="nx">conn</span><span class="p">.</span><span class="nf">SetReadDeadline</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nf">Now</span><span class="p">())</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Now in this case it is clear: I am ignoring the error explicitly, probably for
+a good reason. I can ask during a Pull Request why the committer is ignoring if
+it is lacking appropriate context, and maybe even ask for some comments to be
+added why this would be safe. What can't happen is this being ignored by
+mistake.</p>
+<p>I am not completely sure if I want this only for errors or for any unused value
+though. There are lots of cases where ignoring non-error values is ok, but I
+also don't see the issue of having something like:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">foo</span><span class="p">()</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">// ...
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span> <span class="nx">_</span><span class="p">,</span> <span class="nx">_</span> <span class="p">=</span> <span class="nf">FuncThatReturnIntAndError</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>If anything, it is clear for whoever is reading this code later that you're
+only calling this function only for its side-effects.</p>
+<p>By the way, yes, <a href="https://github.com/kisielk/errcheck">errcheck</a> linter exists,
+but if the language itself doesn't enforce this it means that there are lots of
+libraries that are probably mistakenly ignoring errors. And if the library is
+ignoring errors by mistake, you can't do much when you actually have them.</p></description><pubDate>Sat, 17 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/an-unordered-list-of-things-i-miss-in-go/</guid></item><item><title>Quick bits: NixOS's boot.kernelPackages is a attrset</title><link>https://kokada.dev/blog/quick-bits-nixoss-boot-kernelpackages-is-a-attrset/</link><description><p>I don't know if this is just something that got me by surprise or not, but
+<a href="https://github.com/NixOS/nixpkgs/blob/bb16119a4a7639ebbc91ad0f516b324b0f7c9b68/nixos/modules/system/boot/kernel.nix#L40-L71"><code>boot.kernelPackages</code></a>
+option does not receive a derivation like most other packages, but instead
+receives a function and returns an attribute set with all packages. Here is the
+documentation:</p>
+<blockquote>
+<p>This option allows you to override the Linux kernel used by NixOS. Since
+things like external kernel module packages are tied to the kernel you’re
+using, it also overrides those. This option is a function that takes Nixpkgs
+as an argument (as a convenience), and returns an attribute set containing at
+the very least an attribute kernel. Additional attributes may be needed
+depending on your configuration. For instance, if you use the NVIDIA X
+driver, then it also needs to contain an attribute <code>nvidia_x11</code>.</p>
+</blockquote>
+<p>The kernel package itself is referenced by the
+<a href="https://github.com/NixOS/nixpkgs/blob/bb16119a4a7639ebbc91ad0f516b324b0f7c9b68/nixos/modules/system/boot/kernel.nix#L331-L332"><code>kernel</code></a>
+derivation inside this attribute set:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="go">nix-repl&gt; nixosConfigurations.sankyuu-nixos.config.boot.kernelPackages.kernel
+</span></span></span><span class="line"><span class="cl"><span class="go">«derivation /nix/store/5zyjvf3qgfk52qmgxh36l4dkr9lf100x-linux-6.10.3.drv»
+</span></span></span></code></pre><p>The reason for this is because it ensure that things like modules are built
+with the same kernel version you are booting.</p>
+<p>However one less obvious consequence about this is that if you want packages
+that come from <code>linuxPackages</code>, say for example
+<a href="https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/os-specific/linux/cpupower/default.nix"><code>cpupower</code></a>
+or
+<a href="https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/os-specific/linux/cpupower/default.nix"><code>turbostat</code></a>,
+it is better to do:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span> <span class="n">config</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">environment</span><span class="o">.</span><span class="n">systemPackages</span> <span class="o">=</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="n">config</span><span class="o">.</span><span class="n">boot</span><span class="o">.</span><span class="n">kernelPackages</span><span class="o">.</span><span class="n">cpupower</span>
+</span></span><span class="line"><span class="cl"> <span class="n">config</span><span class="o">.</span><span class="n">boot</span><span class="o">.</span><span class="n">kernelPackages</span><span class="o">.</span><span class="n">turbostat</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Instead of:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span> <span class="n">pkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">environment</span><span class="o">.</span><span class="n">systemPackages</span> <span class="o">=</span> <span class="k">with</span> <span class="n">pkgs</span><span class="p">;</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="n">linuxPackages</span><span class="o">.</span><span class="n">cpupower</span>
+</span></span><span class="line"><span class="cl"> <span class="n">linuxPackages</span><span class="o">.</span><span class="n">turbostat</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Now, I used the later for a long time and never had issues. But technically
+those packages depends in a specific kernel version for a reason, so getting
+them from <code>config.boot.kernelPackages</code> reduces the chance of you having some
+compatibility issue in the future.</p></description><pubDate>Thu, 15 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/quick-bits-nixoss-boot-kernelpackages-is-a-attrset/</guid></item><item><title>Abusing Makefiles for fun and profit</title><link>https://kokada.dev/blog/abusing-makefiles-for-fun-and-profit/</link><description><p>If you are following this blog for a while, it should be no surprise that most
+of the workflow in this blog is <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">automated using
+Go</a>. I
+basically write Markdown files with some special rules inside the
+<a href="https://github.com/thiagokokada/blog">repository</a>, commit and push it. In
+seconds, the CI (currently <a href="https://github.com/thiagokokada/blog/blob/4e3f25485c6682f3e066b219df2290934bc0d256/.github/workflows/go.yml">GitHub
+Actions</a>)
+will take the latest commit, generate some files (since I use the <a href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform">repository
+itself</a> as a
+backup blog) and publish to the <a href="https://kokada.capivaras.dev/">capivaras.dev
+website</a>.</p>
+<p>Now, considering how much about <a href="https://nixos.org/">Nix</a> I talk in this blog,
+it should be a surprise that the workflow above has <strong>zero</strong> Nix code inside
+it. I am not saying this blog will never have it, but I am only going to add if
+this is necessary, for example if I start using a tool to build this blog that
+I generally don't expect it to be installed by the machine I am currently
+using. Go is an exception of this rule since it is relatively straightfoward to
+install (just download the <a href="https://go.dev/doc/install">binary</a>) and because
+its <a href="https://go.dev/doc/go1compat">stability guarantee</a> means (hopefully) no
+breakage. But most other things I consider moving targets, and I wouldn't be
+comfortable to use unless I have Nix to ensure reproducibility.</p>
+<p>This is why the other tool that this blog (ab)uses during its workflow is
+<a href="https://en.wikipedia.org/wiki/Make_(software)"><code>Make</code></a>, one of the oldest
+build automation tool that exist. It is basically available in any *nix (do not
+confuse with <a href="https://nixos.org/">Nix</a>) system, from most Linux distros to
+macOS, by default. So it is the tool I choose to automatise some tasks in this
+blog, even if I consider writing a <code>Makefile</code> (the domain-specific language
+that <code>Make</code> uses) kind of a lost, dark art.</p>
+<p>To be clear, the idea of this post is not to be a <code>Makefile</code> tutorial. I will
+explain some basic concepts, but if you want an actual tutorial a good one can
+be found <a href="https://makefiletutorial.com/">here</a>. Also, while I am using <code>Make</code>
+thanks to the reasons above, you can use many other tools for a similar
+objective, like <a href="https://github.com/casey/just">Justfiles</a>,
+<a href="https://taskfile.dev/">Taskfiles</a> (sadly it uses
+<a href="https://kokada.dev/blog/generating-yaml-files-with-nix">YAML</a>), or even a
+small script written in any language you want. The reason that I am writing
+this post is why you should do it, not how.</p>
+<p>A quick recap on how this blog works: inside the
+<a href="https://github.com/thiagokokada/blog">repository</a>, a post is basically a
+Markdown post following the directory structure below
+(<a href="https://github.com/thiagokokada/blog/tree/894a388c61ca3a38dfc9d4cbe88dc684fd964bb7">permalink</a>
+for the current version of this blog):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="go">.
+</span></span></span><span class="line"><span class="cl"><span class="go">&lt;...&gt;
+</span></span></span><span class="line"><span class="cl"><span class="go">├── 2024-08-07
+</span></span></span><span class="line"><span class="cl"><span class="go">│ ├── 01-quick-bits-is-crostini-a-microvm.md
+</span></span></span><span class="line"><span class="cl"><span class="go">│ └── 02-meta-are-quick-bits-really-quick.md
+</span></span></span><span class="line"><span class="cl"><span class="go">├── 2024-08-11
+</span></span></span><span class="line"><span class="cl"><span class="go">│ └── 01-building-static-binaries-in-nix.md
+</span></span></span><span class="line"><span class="cl"><span class="go">├── 2024-08-12
+</span></span></span><span class="line"><span class="cl"><span class="go">│ ├── 01-things-i-dont-like-in-my-chromebook-duet-3.md
+</span></span></span><span class="line"><span class="cl"><span class="go">│ └── Screenshot_2024-08-12_20.50.42.png
+</span></span></span><span class="line"><span class="cl"><span class="go">├── 2024-08-13
+</span></span></span><span class="line"><span class="cl"><span class="go">│ ├── 01-abusing-makefiles-for-fun-and-profit.md &lt;-- this file
+</span></span></span><span class="line"><span class="cl"><span class="go">├── .github
+</span></span></span><span class="line"><span class="cl"><span class="go">│ └── workflows
+</span></span></span><span class="line"><span class="cl"><span class="go">│ └── go.yml
+</span></span></span><span class="line"><span class="cl"><span class="go">├── .gitignore
+</span></span></span><span class="line"><span class="cl"><span class="go">├── go.mod
+</span></span></span><span class="line"><span class="cl"><span class="go">├── go.sum
+</span></span></span><span class="line"><span class="cl"><span class="go">├── LICENSE
+</span></span></span><span class="line"><span class="cl"><span class="go">├── link_rewriter.go
+</span></span></span><span class="line"><span class="cl"><span class="go">├── Makefile
+</span></span></span><span class="line"><span class="cl"><span class="go">├── mataroa.go
+</span></span></span><span class="line"><span class="cl"><span class="go">├── README.md
+</span></span></span><span class="line"><span class="cl"><span class="go">├── rss.xml
+</span></span></span><span class="line"><span class="cl"><span class="go">└── .scripts
+</span></span></span><span class="line"><span class="cl"><span class="go"> └── gen-post.sh
+</span></span></span></code></pre><p>So I just create a new Markdown file following the
+<code>YYYY-MM-DD/XX-title-slug.md</code> format. It <strong>must</strong> start with a <code>h1</code> header,
+that will be automatically extract to be used as the post title, but otherwise
+there is no other formatting rules. It is a highly optionated structure, but
+the nice thing about being optionated is that we can extract lots of
+information just from how the files are organised in the filesystem.</p>
+<p>Most of the magic that converts those Markdown files to actual blog posts are
+in the Go files that you can see above: <code>blog.go</code> is the main logic that walks
+in the repository and extracts the necessary information, <code>mataroa.go</code> is
+responsible for the <a href="https://capivaras.dev/">capivaras.dev</a> integration (that
+uses <a href="https://mataroa.blog/">Mataroa</a> platform), while <code>link_rewriter.go</code> is
+responsible to do some transformations in the Markdown files before posting.</p>
+<p>While I could manage everything by just using <code>go</code> CLI and a few other *nix
+commands, to make it easier to manager everything I have the following
+<a href="https://github.com/thiagokokada/blog/blob/527466a2a7c8baae532281bff5db3f0695f018cb/Makefile"><code>Makefile</code></a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="nv">MARKDOWN</span> <span class="o">:=</span> <span class="k">$(</span>wildcard ./**/*.md<span class="k">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">all</span>
+</span></span><span class="line"><span class="cl"><span class="nf">all</span><span class="o">:</span> <span class="n">README</span>.<span class="n">md</span> <span class="n">rss</span>.<span class="n">xml</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">blog</span><span class="o">:</span> *.<span class="n">go</span> <span class="n">go</span>.*
+</span></span><span class="line"><span class="cl"> go build
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">README.md</span><span class="o">:</span> <span class="n">blog</span> <span class="k">$(</span><span class="nv">MARKDOWN</span><span class="k">)</span>
+</span></span><span class="line"><span class="cl"> ./blog &gt; README.md
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">rss.xml</span><span class="o">:</span> <span class="n">blog</span> <span class="k">$(</span><span class="nv">MARKDOWN</span><span class="k">)</span>
+</span></span><span class="line"><span class="cl"> ./blog -rss &gt; rss.xml
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">publish</span>
+</span></span><span class="line"><span class="cl"><span class="nf">publish</span><span class="o">:</span> <span class="n">blog</span>
+</span></span><span class="line"><span class="cl"> ./blog -publish
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nv">DAY</span> <span class="o">:=</span> <span class="k">$(</span>shell date<span class="k">)</span>
+</span></span><span class="line"><span class="cl"><span class="nv">_PARSED_DAY</span> <span class="o">:=</span> <span class="k">$(</span>shell date <span class="s1">&#39;+%Y-%m-%d&#39;</span> -d <span class="s1">&#39;$(DAY)&#39;</span><span class="k">)</span>
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">day</span>
+</span></span><span class="line"><span class="cl"><span class="nf">day</span><span class="o">:</span>
+</span></span><span class="line"><span class="cl"> mkdir -p <span class="s1">&#39;$(_PARSED_DAY)&#39;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nv">TITLE</span> <span class="o">=</span> <span class="k">$(</span>error TITLE is not defined<span class="k">)</span>
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">post</span>
+</span></span><span class="line"><span class="cl"><span class="nf">post</span><span class="o">:</span> <span class="n">blog</span> <span class="n">day</span>
+</span></span><span class="line"><span class="cl"> ./.scripts/gen-post.sh <span class="s1">&#39;$(_PARSED_DAY)&#39;</span> <span class="s1">&#39;$(TITLE)&#39;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nv">FILE</span> <span class="o">=</span> <span class="k">$(</span>error FILE is not defined<span class="k">)</span>
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">draft</span>
+</span></span><span class="line"><span class="cl"><span class="nf">draft</span><span class="o">:</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">cd</span> <span class="s1">&#39;$(dir $(FILE))&#39;</span> <span class="o">&amp;&amp;</span> mv <span class="s1">&#39;$(notdir $(FILE))&#39;</span> <span class="s1">&#39;.$(notdir $(FILE))&#39;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">undraft</span>
+</span></span><span class="line"><span class="cl"><span class="nf">undraft</span><span class="o">:</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">cd</span> <span class="s1">&#39;$(dir $(FILE))&#39;</span> <span class="o">&amp;&amp;</span> mv <span class="s1">&#39;$(notdir $(FILE))&#39;</span> <span class="s1">&#39;$(patsubst .%,%,$(notdir $(FILE)))&#39;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="nf">.PHONY</span><span class="o">:</span> <span class="n">clean</span>
+</span></span><span class="line"><span class="cl"><span class="nf">clean</span><span class="o">:</span>
+</span></span><span class="line"><span class="cl"> rm -rf blog
+</span></span></code></pre><p>For those unfamiliar with <code>Makefile</code>, a quick explanation on how it works from
+<a href="https://en.wikipedia.org/wiki/Make_(software)#Makefile">Wikipedia</a>:</p>
+<blockquote>
+<p>Each rule begins with a <em>dependency line</em> which consists of the rule's target
+name followed by a colon (:) and optionally a list of targets on which the
+rule's target depends, its prerequisites.</p>
+</blockquote>
+<p>So if we look for example at the <code>blog</code> binary, the dependencies are all the
+<code>.go</code> files and Go module files like <code>go.mod</code> and <code>go.sum</code>. We can make the
+<code>blog</code> binary by running:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make blog
+</span></span><span class="line"><span class="cl"><span class="go">go build
+</span></span></span></code></pre><p>One nice thing about <code>Makefile</code> is that they track if any of the source files
+has a newer timestamp than the target file, and only trigger the build again if
+there are changes, for example:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make blog
+</span></span><span class="line"><span class="cl"><span class="go">make: &#39;blog&#39; is up to date.
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> touch blog.go
+</span></span><span class="line"><span class="cl"><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> make blog
+</span></span><span class="line"><span class="cl"><span class="go">go build
+</span></span></span></code></pre><p>But sometimes this property is undesirable. In those cases we can declare a
+target as <code>.PHONY</code>, that basically instructs <code>Makefile</code> to always make the
+target. One classic example is <code>clean</code> target, that removes build artifacts:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make clean
+</span></span><span class="line"><span class="cl"><span class="go">rm -rf blog
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> make clean
+</span></span><span class="line"><span class="cl"><span class="go">rm -rf blog
+</span></span></span></code></pre><p>By the way, it is better to declare a target as <code>.PHONY</code> than declaring
+dependencies incorrectly, especially in languages that has fast build times
+like e.g.: Go. The worst thing that can happen is something not being rebuild
+when it needs to. So my recomendation if you are writing your first <code>Makefile</code>
+is to just declare everything as <code>.PHONY</code>. You can always improve it later.</p>
+<p>One last basic concept that I want to explain about <code>Makefile</code> is the default
+target: it is the target that is run if you just run <code>make</code> without arguments
+inside the directory that contains a <code>Makefile</code>. The default target is
+generally the first target in the <code>Makefile</code>. It is common to have an <code>all</code>
+target (that is also marked as <code>.PHONY</code>) that has as dependencies all the
+targets that you want to build by default. In this particular case I declare
+the <code>README.md</code> and <code>rss.xml</code> files to be build by default, and they themselves
+depends in <code>blog</code> binary being build. So once I run <code>make</code> you get as result:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make
+</span></span><span class="line"><span class="cl"><span class="go">go build
+</span></span></span><span class="line"><span class="cl"><span class="go">./blog &gt; README.md
+</span></span></span><span class="line"><span class="cl"><span class="go">./blog -rss &gt; rss.xml
+</span></span></span></code></pre><p>And this result above highlights the first reason I think you should have a
+<code>Makefile</code> or something similar in your projects: you don't need to remember
+the exactly steps that you need to get things working. If I see one project of
+mine having a <code>Makefile</code>, I can be reasonably confident that I can get it
+working by just running <code>make</code>.</p>
+<p>But now let's focus in the other targets that I have in the <code>Makefile</code> that are
+not related to the build process but are there to help me manage my blog posts.
+Remember the rules I explained above? Maybe not, but it should be no problem,
+because:</p>
+<pre><code>$ make post TITLE=&quot;My new blog post&quot;
+mkdir -p &quot;2024-08-13&quot;
+./.scripts/gen-post.sh &quot;2024-08-13&quot; &quot;My new blog post&quot;
+Creating file: 2024-08-13/02-my-new-blog-post.md
+<p>$ cat 2024-08-13/02-my-new-blog-post.md</p>
+<h1>My new blog post</h1>
+</code><p><code></code></p></pre><p></p>
+<p>This command, <code>make post</code>, is responsible for:</p>
+<ol>
+<li>Create a new directory for today, if it doesn't exist</li>
+<li>Run the
+<a href="https://github.com/thiagokokada/blog/blob/6a3b06970729f7650e5bee5fb0e1f9f2541ffea8/.scripts/gen-post.sh"><code>gen-post.sh</code></a>
+script, that:
+<ol>
+<li>Enumerates all posts from the day, so we can number the new post correctly
+<ul>
+<li>We already had this post planned for 2024-08-13, so the new post is 02</li>
+</ul>
+</li>
+<li>Slugify the title, so we can create each Markdown file with the correct
+filename</li>
+<li>Creates a new Markdown file with the title as a <code>h1</code> header</li>
+</ol>
+</li>
+</ol>
+<p>The steps above may or may not seen trivial, and for a while I was doing them
+manually. But not having to think what is the current date or if I already
+posted that day or what is the slug is for the title make (pun intended) my
+like much easier.</p>
+<p>Yes, the code is ugly. The way variables works in <code>Make</code> is that you can
+declare then inside the <code>Makefile</code>, but they can be overwritten in the terminal
+if you pass them. I used this to allow <code>make post</code> to also work for future
+posts:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make post <span class="nv">TITLE</span><span class="o">=</span><span class="s2">&#34;Another new blog post&#34;</span> <span class="nv">DAY</span><span class="o">=</span>2024-12-12
+</span></span><span class="line"><span class="cl"><span class="go">mkdir -p &#34;2024-12-12&#34;
+</span></span></span><span class="line"><span class="cl"><span class="go">./.scripts/gen-post.sh &#34;2024-12-12&#34; &#34;Another new blog post&#34;
+</span></span></span><span class="line"><span class="cl"><span class="go">Creating file: 2024-12-12/01-another-new-blog-post.md
+</span></span></span></code></pre><p>So in the above case, <code>DAY</code> is filled with the value passed in the terminal
+instead of default (that would be the current day), and <code>_PARSED_DAY</code> is the
+day we use to actually create the directory. We can actually pass any date
+format recognised by
+<a href="https://www.gnu.org/software/coreutils/manual/html_node/Examples-of-date.html"><code>date</code></a>,
+not just <code>YYYY-MM-DD</code>.</p>
+<p>I have 2 other phony targets that I want to talk, <code>draft</code> and <code>undraft</code>. They
+expect a <code>FILE</code> to be passed, and I use them to either hide or unhide a file:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> make draft <span class="nv">FILE</span><span class="o">=</span>2024-12-12/01-another-new-blog-post.md
+</span></span><span class="line"><span class="cl"><span class="go">mv &#34;2024-12-12/01-another-new-blog-post.md&#34; &#34;2024-12-12/.01-another-new-blog-post.md&#34;
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> make undraft <span class="nv">FILE</span><span class="o">=</span>2024-12-12/.01-another-new-blog-post.md
+</span></span><span class="line"><span class="cl"><span class="go">mv &#34;2024-12-12/.01-another-new-blog-post.md&#34; &#34;2024-12-12/01-another-new-blog-post.md&#34;
+</span></span></span></code></pre><p>Why? Because hidden files are <a href="https://github.com/thiagokokada/blog/blob/894a388c61ca3a38dfc9d4cbe88dc684fd964bb7/blog.go#L101-L104">explicit
+ignored</a>
+during my directory parser to mean they're a draft post and not ready to be
+published. And the reason I created those targets is because I was tired of
+trying to hide or unhide a file manually.</p>
+<p>So that's it, for the same reason you <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">should probably automate
+everything</a>,
+you also need to have some way to automate your tasks. <code>Makefile</code> is one way to
+do it, maybe not the best way to do it, but it works and it is available
+anywhere.</p></description><pubDate>Tue, 13 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/abusing-makefiles-for-fun-and-profit/</guid></item><item><title>Things I don't like in my Chromebook Duet 3</title><link>https://kokada.dev/blog/things-i-dont-like-in-my-chromebook-duet-3/</link><description><p>So this is kind of a continuation from my <a href="https://kokada.dev/blog/my-favorite-device-is-a-chromebook">previous
+post</a> talking why
+my favorite device is a Chromebook. In this post I want to talk about what
+makes me this device unhappy, and comment about things that if changed would
+make it a much better device.</p>
+<p>But before talking about the negative aspects, let me talk about a positive
+aspect that I just briefly talked in the previous post: the screen. It is a
+HiDPI screen (2000x1200 resolution in 10.95''), that is unexpected bright (400
+nits according to the
+<a href="https://www.lenovo.com/us/en/p/laptops/lenovo/lenovo-edu-chromebooks/ideapad-duet-3-chromebook-11-inch,-qlc/len101i0034">specs</a>).
+It is difficult to find laptops at the same price with a screen that good. At
+10.95'' in its default resolution I find it too small (like 1250x750), but I
+find the font size acceptable at 115% scale (1087x652). Yes, it result in a
+small workspace, but this is not a big issue for what I do in this device. It
+is also only 60Hz, but I thought I would miss high refresh rate more than I
+actually miss in this device.</p>
+<p>Update: I forgot to say one thing about the screen: it scratches really easy. I
+got my screen scratched after the first day of usage, and considering the price
+I don't think the screen has a hardened glass. I bought a cheap glass screen
+protector and this did the trick though, even hiding the previous scratch, and
+I have zero issues with the screen now.</p>
+<p>Now the first aspect that I don't like: the speakers. They sound tiny and even
+at maximum volume it is not really loud. The speakers is the only reason why I
+still keep my <a href="https://www.gsmarena.com/xiaomi_pad_5-11042.php">Xiaomi Pad 5</a>,
+because I like to watch animes/videos before sleep and having good speakers is
+a must.</p>
+<p>The keyboard has that issue that I mentioned in the previous post: sometimes
+the key get stuck, and I get duplicated characters. But it also has some minor
+issues that I didn't talked about: the first one is the UK layout that has some
+extra keys that I have no use for, but this also makes the keys that I use
+smaller. Very much a &quot;me&quot; problem, since if I had got a US version I wouldn't
+have those issues, but an issue nonetheless that gets worse considering how
+small the keyboard is. I am actually suprised how fast I can type considering
+how many issues this keyboard has, so maybe this is a testament that this
+keyboard is not actually that bad.</p>
+<p>The other keyboard issue is a problem that affects all Chromebooks: its custom
+layout. Google replaced a few keys like Fn keys with shortcuts and replaced the
+Caps Lock with a
+<a href="https://chromeunboxed.com/chromebook-launcher-now-everything-button">&quot;Everything&quot;</a>
+key (that is similar to the Windows Key), while removing Windows Key from its
+place. I actually have less issue with this than I initially though: I don't
+care too much about Fn keys (except when using IntelliJ, but that is something
+that I only use at <code>$CURRENT_JOB</code>), and ChromeOS is surprisingly powerful in
+its customisation, allowing you to swap key functionality. I remap Everything
+key with Esc, and Esc for the Everything key, and I can get productive in my
+<code>neovim</code> setup.</p>
+<p>And finally, let me talk more about the performance: yes, it is bad, but
+bearable once you get used to. The issue is both the CPU and IO. While the CPU,
+a <a href="https://www.qualcomm.com/products/mobile/snapdragon/laptops-and-tablets/snapdragon-mobile-compute-platforms/snapdragon-7c-gen-2-compute-platform">Snapdragon 7c Gen
+2</a>
+is octa-core, it has only 2 high performance CPU cores vs 6 low performance
+ones (2xARM Cortex A76 vs 6xARM Cortex A55). If it was something like 4x4, it
+would be much better. The fact that the cores are old doesn't help either.</p>
+<p>But the worst part is the IO. Not only it uses a eMMC module, it is slow:</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-12/Screenshot_2024-08-12_20.50.42.png"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-12/Screenshot_2024-08-12_20.50.42.png" alt="CPDT Benchmark results from Chromebook Duet 3."></a></p>
+<p>I don't know how much more expensive it would be to put a
+<a href="https://en.wikipedia.org/wiki/Universal_Flash_Storage">UFS</a> instead of eMMC in
+this device, but this is probably the choice that would most increase
+performance in this device, especially considering how aggressive Chromebooks
+use (z)swap.</p>
+<p>Update 2: I forgot to talk about the fact that the exterior of the device is
+covered in cloth. I thought I would hate this at first, but nowadays I kind
+like it. And it is also nice that it will never get scratched, I don't care too
+much about the exterior of this device and it is the only device that I have at
+home that doesn't have additional protection (except the screen protector
+mentioned above).</p></description><pubDate>Mon, 12 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/things-i-dont-like-in-my-chromebook-duet-3/</guid></item><item><title>Building static binaries in Nix</title><link>https://kokada.dev/blog/building-static-binaries-in-nix/</link><description><p>I recently had laser eye surgery for my near-sightedness, and while evaluating
+if I could have the surgery I discovered that I was suffering from dry eyes.
+Thanks to this, my ophthalmologist recommended that every 20 minutes while
+using screens, I look somewhere 20 feet away for 20 seconds, a technique known
+as <a href="https://www.healthline.com/health/eye-health/20-20-20-rule">20-20-20 rule</a>.</p>
+<p>I had issues following this rule because I never remembered to do the pauses. I
+initially tried to setup an alarm, but this became annoying, so I decided to
+try to find a program. I found
+<a href="https://tonyh4156.github.io/20-20-20.github.io/">this</a> one for macOS that
+worked fine, but it bothered me that it was compiled for x86_64 while I was
+using a M1 MacBook Pro at the time, and also I needed something that worked in
+Linux.</p>
+<p>Since I never found a good multi-platform alternative, I decided to write my
+own. This became
+<a href="https://github.com/thiagokokada/twenty-twenty-twenty/">twenty-twenty-twenty</a>,
+the first <a href="https://kokada.dev/blog/go-a-reasonable-good-language">Go</a> program
+that I ever wrote. I wrote it in Go because I wanted to learn the language, but
+also because Go made it easy to build static binaries. And the first version I
+could build static binaries without issues because I was using
+<a href="https://github.com/gen2brain/beeep">beeep</a>, that uses pure Go code in all
+supported platforms. However, it also meant that the notifications in macOS
+looked ugly, since it used
+<a href="https://github.com/gen2brain/beeep/blob/master/beep_darwin.go#L20">osascript</a>.</p>
+<p>I wanted better integration with macOS, so this meant switching libraries.
+After searching for a while, the
+<a href="https://pkg.go.dev/gioui.org/x/notify">notify</a> library from
+<a href="https://gioui.org/">GioUI</a> is the one that seemed to work better. It
+implements notification in macOS using its native framework, so it works much
+better, but sadly it meant losing static binaries because it depends in CGO.</p>
+<p>Not a big loss initially, because I am only depending in Foundation inside
+macOS (that should always be available), and in Linux I could still statically
+compile. However I eventually added more features like sound
+(via <a href="https://github.com/gopxl/beep">beep</a>) and tray icon (via
+<a href="https://github.com/fyne-io/systray">systray</a>), that meant I needed CGO in both
+macOS and Linux.</p>
+<p>Losing static binaries in Linux is a much bigger deal, since Linux is a moving
+target. The general recommendation for building CGO binaries statically is
+using
+<a href="https://eli.thegreenplace.net/2024/building-static-binaries-with-go-on-linux/">musl</a>,
+but this also means building all dependencies that we need using musl (e.g.:
+<a href="https://github.com/ebitengine/oto?tab=readme-ov-file#linux"><code>ALSA</code></a> for
+[beep/oto]). This generally means pain, but Nix makes it easy.</p>
+<p>Let's start by creating a <a href="https://github.com/thiagokokada/twenty-twenty-twenty/blob/main/twenty-twenty-twenty.nix">Nix
+file</a>
+that builds our Go module (simplified below for brevity):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span> <span class="n">lib</span>
+</span></span><span class="line"><span class="cl"><span class="o">,</span> <span class="n">stdenv</span>
+</span></span><span class="line"><span class="cl"><span class="o">,</span> <span class="n">alsa-lib</span>
+</span></span><span class="line"><span class="cl"><span class="o">,</span> <span class="n">buildGoModule</span>
+</span></span><span class="line"><span class="cl"><span class="o">,</span> <span class="n">pkg-config</span>
+</span></span><span class="line"><span class="cl"><span class="o">,</span> <span class="n">withStatic</span> <span class="o">?</span> <span class="no">false</span>
+</span></span><span class="line"><span class="cl"><span class="p">}:</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="n">buildGoModule</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pname</span> <span class="o">=</span> <span class="s2">&#34;twenty-twenty-twenty&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">version</span> <span class="o">=</span> <span class="s2">&#34;1.0.0&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">src</span> <span class="o">=</span> <span class="n">lib</span><span class="o">.</span><span class="n">cleanSource</span> <span class="sr">./.</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">vendorHash</span> <span class="o">=</span> <span class="s2">&#34;sha256-NzDhpJRogIfL2IYoqAUHoPh/ZdNnvnhEQ+kn8A+ZyBw=&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">CGO_ENABLED</span> <span class="o">=</span> <span class="s2">&#34;1&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">nativeBuildInputs</span> <span class="o">=</span> <span class="n">lib</span><span class="o">.</span><span class="n">optionals</span> <span class="p">(</span><span class="n">stdenv</span><span class="o">.</span><span class="n">hostPlatform</span><span class="o">.</span><span class="n">isLinux</span><span class="p">)</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkg-config</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">buildInputs</span> <span class="o">=</span> <span class="n">lib</span><span class="o">.</span><span class="n">optionals</span> <span class="p">(</span><span class="n">stdenv</span><span class="o">.</span><span class="n">hostPlatform</span><span class="o">.</span><span class="n">isLinux</span><span class="p">)</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="n">alsa-lib</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">ldflags</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;-X=main.version=</span><span class="si">${</span><span class="n">version</span><span class="si">}</span><span class="s2">&#34;</span> <span class="s2">&#34;-s&#34;</span> <span class="s2">&#34;-w&#34;</span> <span class="p">]</span>
+</span></span><span class="line"><span class="cl"> <span class="o">++</span> <span class="n">lib</span><span class="o">.</span><span class="n">optionals</span> <span class="n">withStatic</span> <span class="p">[</span> <span class="s2">&#34;-linkmode external&#34;</span> <span class="s1">&#39;&#39;-extldflags &#34;-static&#34;&#39;&#39;</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">meta</span> <span class="o">=</span> <span class="k">with</span> <span class="n">lib</span><span class="p">;</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">description</span> <span class="o">=</span> <span class="s2">&#34;Alerts every 20 minutes to look something at 20 feet away for 20 seconds&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">homepage</span> <span class="o">=</span> <span class="s2">&#34;https://github.com/thiagokokada/twenty-twenty-twenty&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">license</span> <span class="o">=</span> <span class="n">licenses</span><span class="o">.</span><span class="n">mit</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">mainProgram</span> <span class="o">=</span> <span class="s2">&#34;twenty-twenty-twenty&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>And we can build it with the following <code>flake.nix</code>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">description</span> <span class="o">=</span> <span class="s2">&#34;twenty-twenty-twenty&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">inputs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">url</span> <span class="o">=</span> <span class="s2">&#34;nixpkgs/nixpkgs-unstable&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">flake-compat</span><span class="o">.</span><span class="n">url</span> <span class="o">=</span> <span class="s2">&#34;github:edolstra/flake-compat&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">outputs</span> <span class="o">=</span> <span class="p">{</span> <span class="n">self</span><span class="o">,</span> <span class="n">nixpkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">supportedSystems</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;x86_64-linux&#34;</span> <span class="s2">&#34;aarch64-linux&#34;</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Helper function to generate an attrset &#39;{ x86_64-linux = f &#34;x86_64-linux&#34;; ... }&#39;.</span>
+</span></span><span class="line"><span class="cl"> <span class="n">forAllSystems</span> <span class="o">=</span> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">lib</span><span class="o">.</span><span class="n">genAttrs</span> <span class="n">supportedSystems</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Nixpkgs instantiated for supported system types.</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgsFor</span> <span class="o">=</span> <span class="n">forAllSystems</span> <span class="p">(</span><span class="n">system</span><span class="p">:</span> <span class="kn">import</span> <span class="n">nixpkgs</span> <span class="p">{</span> <span class="k">inherit</span> <span class="n">system</span><span class="p">;</span> <span class="p">});</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">packages</span> <span class="o">=</span> <span class="n">forAllSystems</span> <span class="p">(</span><span class="n">system</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span> <span class="n">pkgs</span> <span class="o">=</span> <span class="n">nixpkgsFor</span><span class="o">.</span><span class="si">${</span><span class="n">system</span><span class="si">}</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">default</span> <span class="o">=</span> <span class="n">self</span><span class="o">.</span><span class="n">packages</span><span class="o">.</span><span class="si">${</span><span class="n">system</span><span class="si">}</span><span class="o">.</span><span class="n">twenty-twenty-twenty</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">twenty-twenty-twenty</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">callPackage</span> <span class="sr">./twenty-twenty-twenty.nix</span> <span class="p">{</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="n">twenty-twenty-twenty-static</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">pkgsStatic</span><span class="o">.</span><span class="n">callPackage</span> <span class="sr">./twenty-twenty-twenty.nix</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">withStatic</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">});</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>I think this shows how powerful Nix is: the only difference between the normal
+build and a static build the usage of <code>pkgs.pkgsStatic</code> instead of <code>pkgs</code>. This
+automatically builds all packages statically with <code>musl</code>. Also we need pass
+some <a href="https://honnef.co/articles/statically-compiled-go-programs-always-even-with-cgo-using-musl/">extra
+flags</a>
+to the Go compiler (i.e.: <code>-linkmode external -extldflags &quot;-static&quot;</code>), but this
+is a requirement from Go.</p>
+<p>So, does it work? Let's test:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix build .#twenty-twenty-twenty-static
+</span></span><span class="line"><span class="cl"><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> file result/bin/twenty-twenty-twenty
+</span></span><span class="line"><span class="cl"><span class="go">result/bin/twenty-twenty-twenty: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, stripped
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> ./result/bin/twenty-twenty-twenty
+</span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/dhn51w2km4fyf9ivi00rz03qs8q4mpng-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/ly9d7llymzjyf6gi1455qzayqipk2kab-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/dhn51w2km4fyf9ivi00rz03qs8q4mpng-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/ly9d7llymzjyf6gi1455qzayqipk2kab-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/dhn51w2km4fyf9ivi00rz03qs8q4mpng-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">ALSA lib pcm.c:2712:(snd_pcm_open_conf) Either /nix/store/ly9d7llymzjyf6gi1455qzayqipk2kab-pipewire-1.2.1/lib/alsa-lib/libasound_module_pcm_pipewire.so cannot be opened or _snd_pcm_pipewire_open was not defined inside
+</span></span></span><span class="line"><span class="cl"><span class="go">2024-08-11T19:26:33+01:00 INFO Running twenty-twenty-twenty every 20.0 minute(s), with 20 second(s) duration and sound set to true
+</span></span></span></code></pre><p>There are some warns and sadly the sound doesn't work. I think the issue is
+related because of my usage of PipeWire and the binary may work in a pure ALSA
+system, but I don't have access to one. Maybe adding <code>pipewire</code> to
+<code>buildInputs</code> would fix this issue, but I can't get <code>pipewire</code> to be compiled
+statically (because of its dependencies). I think this is a good show how easy
+it is to statically compilation is in Nix, but also how complex static binaries
+are to get correctly.</p>
+<p>Bonus points for
+<a href="https://nix.dev/tutorials/cross-compilation.html">cross-compilation</a>. We can
+easily cross-compile by using <code>pkgsCross</code>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"> <span class="n">outputs</span> <span class="o">=</span> <span class="p">{</span> <span class="n">self</span><span class="o">,</span> <span class="n">nixpkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">packages</span> <span class="o">=</span> <span class="n">forAllSystems</span> <span class="p">(</span><span class="n">system</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span> <span class="n">pkgs</span> <span class="o">=</span> <span class="n">nixpkgsFor</span><span class="o">.</span><span class="si">${</span><span class="n">system</span><span class="si">}</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">twenty-twenty-twenty-static-aarch64</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">pkgsCross</span><span class="o">.</span><span class="n">aarch64-multiplatform</span><span class="o">.</span><span class="n">pkgsStatic</span><span class="o">.</span><span class="n">callPackage</span> <span class="sr">./twenty-twenty-twenty.nix</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">withStatic</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">});</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>The idea of <code>pkgsCross</code> is to select a target platform (e.g.:
+<code>aarch64-multiplatform</code>) and use it as any other <code>pkgs</code>. We can even chain
+<code>pkgsStatic</code> to statically cross compile binaries:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix build .#twenty-twenty-twenty-static-aarch64
+</span></span><span class="line"><span class="cl"><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> file result/bin/twenty-twenty-twenty
+</span></span><span class="line"><span class="cl"><span class="go">result/bin/twenty-twenty-twenty: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, stripped
+</span></span></span></code></pre></description><pubDate>Sun, 11 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/building-static-binaries-in-nix/</guid></item><item><title>Meta: are quick bits really quick?</title><link>https://kokada.dev/blog/meta-are-quick-bits-really-quick/</link><description><p>When I wrote my first <a href="https://kokada.dev/blog/quick-bits-nix-shell-is-cursed">quick
+bits</a> post in this
+blog, I gave that title prefix without much thought: I knew it was supposed to
+be a quicker post than my previous one, but I never thought too deeply about
+it. But after:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ls -lah **/*quick-bits*.md <span class="p">|</span> wc -l
+</span></span><span class="line"><span class="cl"><span class="go">4
+</span></span></span></code></pre><p>Well, 4 blog posts starting with the same prefix, I was curious: are those
+quick bits really quick, or at least quicker? Let's see:</p>
+<pre><code>$ wc -w **/*.md
+ 1107 2024-07-26/01-writing-nixos-tests-for-fun-and-profit.md
+ 1220 2024-07-26/02-using-github-as-a-bad-blog-platform.md
+ 286 2024-07-27/01-quick-bits-nix-shell-is-cursed.md
+ 387 2024-07-29/01-quick-bits-why-you-should-automate-everything.md
+ 1060 2024-07-29/02-go-a-reasonable-good-language.md
+ 1380 2024-07-30/01-first-impressions-fpgbc.md
+ 1238 2024-07-31/01-generating-yaml-files-with-nix.md
+ 2308 2024-08-01/01-troubleshooting-zsh-lag-and-solutions-with-nix.md
+ 504 2024-08-01/02-quick-bits-realise-nix-symlinks.md
+ 834 2024-08-04/01-make-nixd-modules-completion-work-anywhere-with-flakes.md
+ 1147 2024-08-05/01-my-favorite-device-is-a-chromebook.md
+ 394 2024-08-07/01-quick-bits-is-crostini-a-microvm.md
+ 120 README.md
+11985 total
+</code></pre>
+<p>While using <code>wc</code> is probably not the best way to measure word count (especially
+in this blog, since I tend to write lots of code snippets), I think this at
+least it gives me a good insight: yes, quick bits are quicker, and they're
+basically posts with a soft limit around 500 words. So expect in future this
+limit to be used.</p>
+<p>By the way, at:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> wc -w 2024-08-07/02-meta-are-quick-bits-really-quick.md
+</span></span><span class="line"><span class="cl"><span class="go">220 2024-08-07/02-meta-are-quick-bits-really-quick.md
+</span></span></span></code></pre><p>This post is also technically a quick bits post, but &quot;quick bits meta&quot; would be
+too much. And yes, that last block of code is also meta ;).</p></description><pubDate>Wed, 07 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/meta-are-quick-bits-really-quick/</guid></item><item><title>Quick bits: is Crostini a micro VM?</title><link>https://kokada.dev/blog/quick-bits-is-crostini-a-micro-vm/</link><description><p><strong>Disclaimer</strong>: I am not a Virtual Machine specialist, this post is mainly the
+conclusion I got after some searching.</p>
+<p>Someone asked me in my <a href="https://kokada.dev/blog/my-favorite-device-is-a-chromebook">previous
+post</a> about my
+Chromebook if Crostini could be considered a micro VM. This was a interesting
+question, so I decided to do another post.</p>
+<p>To start, it is really difficult to get a good definition of what a &quot;micro VM&quot;
+is. <a href="https://firecracker-microvm.github.io/">Firecracker</a> defines itself as a
+micro VM, and describes itself in its website as:</p>
+<blockquote>
+<p>Firecracker is a virtual machine monitor (VMM) that uses the Linux
+Kernel-based Virtual Machine (KVM) to create and manage microVMs. Firecracker
+has a minimalist design. It excludes unnecessary devices and guest
+functionality to reduce the memory footprint and attack surface area of each
+microVM. This improves security, decreases the startup time, and increases
+hardware utilization.</p>
+</blockquote>
+<p>Now looking at Crostini, its heart is a VMM called
+<a href="https://crosvm.dev/">crosvm</a>. It is described in its
+<a href="https://chromium.googlesource.com/chromiumos/platform/crosvm/+/HEAD/README.md">README</a>
+as:</p>
+<blockquote>
+<p>crosvm is a virtual machine monitor (VMM) based on Linux’s KVM hypervisor,
+with a focus on simplicity, security, and speed. crosvm is intended to run
+Linux guests, originally as a security boundary for running native
+applications on the ChromeOS platform. Compared to QEMU, crosvm doesn’t
+emulate architectures or real hardware, instead concentrating on
+paravirtualized devices, such as the virtio standard.</p>
+</blockquote>
+<p>Similar descriptions right? Actually Firecracker website says it &quot;started from
+Chromium OS's Virtual Machine Monitor, crosvm, an open source VMM written in
+Rust&quot;. So I would say it is safe to say crosvm itself is a micro VM.</p>
+<p>But
+<a href="https://www.chromium.org/chromium-os/developer-library/guides/containers/containers-and-vms/">Crostini</a>
+itself is a combination of virtualization AND containerization. Basically
+inside the VM it runs a Linux kernel and <a href="https://linuxcontainers.org/">LXC</a>,
+that can start arbitrary containers inside it. From the Crostini documentation
+this choice seems to be to keep startup times down, and also to increase
+security (e.g.: in case of a security issue inside the container).</p>
+<p>This is definitely an interesting choice, since containers allow the overhead
+of each distro that you run inside Crostini to be low, and the main VM itself
+(called
+<a href="https://chromium.googlesource.com/chromiumos/overlays/board-overlays/+/HEAD/project-termina/">Termina</a>)
+should have low overhead too thanks to crosvm.</p>
+<p>By the way, if you want to learn more how &quot;devices&quot; works inside a micro VM
+like crosvm, I recommend <a href="https://prilik.com/blog/post/crosvm-paravirt/">this blog
+post</a> talking about
+paravirtualized devices in crosvm.</p></description><pubDate>Wed, 07 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/quick-bits-is-crostini-a-micro-vm/</guid></item><item><title>My favorite device is a Chromebook</title><link>https://kokada.dev/blog/my-favorite-device-is-a-chromebook/</link><description><p>Most of the posts in this blog (including this one) and most of I would call
+&quot;personal computing&quot; that I do nowadays is mostly done in one of the most
+unremarkable devices that I own: a cheap <a href="https://www.lenovo.com/us/en/p/laptops/lenovo/lenovo-edu-chromebooks/ideapad-duet-3-chromebook-11-inch,-qlc/len101i0034">Chromebook Duet
+3</a>,
+that I bought for around EUR300. I was thinking why, because it is woefully
+underpowered: a <a href="https://www.anandtech.com/show/16696/qualcomm-announces-snapdragon-7c-gen-2-entrylevel-pc-and-chromebook-refresh">Snapdragon 7c Gen
+2</a>,
+a CPU that was already considered slow 3 years ago, coupled with an eMMC for
+storage, that is not much faster than a HDD. At least I have the 8GB RAM
+version instead of the 4GB one.</p>
+<p>It is a hybrid device, one that can be used as either a tablet or laptop, but
+it is compromised experience in both cases: as a tablet, it lacks the better
+touch optimised interface from iOS or Android; as a laptop, you have to depend
+on the stand to adjust the screen, and the detachable keyboard is worse than
+any laptop I have ever owned: getting keys stucked and characters being
+duplicated as a result is a common occurence. It is not so bad that I can't get
+things done though. About the trackpad: its biggest quality is that I never
+feel the need to use the touchscreen in laptop mode, that is to say that it is
+acceptable. Just crank up the pointer speed in ChromeOS settings, otherwise you
+never get anywhere since the trackpad is so small. There is also an active
+stylus, that helped me sometimes when I needed to sign something but otherwise
+I can't comment too much.</p>
+<p>But I really love this device. It is generally the only device that I bring in
+trips nowadays, because while it is compromised it works well enough: I can use
+to consume media in tablet mode (the fact that ChromeOS supports Android apps
+is a plus in those cases), browse the web and even do Linux stuff (more about
+this later). The fact that it is small (the size remembers me of a
+<a href="https://en.wikipedia.org/wiki/Netbook">netbook</a>), lightweight (~1KG, including
+the keyboard), has a good screen (that is bright and HiDPI) and good battery
+life (I don't have numbers but I almost never worry about it) is what makes
+this device the perfect companion to trips.</p>
+<p>Also, it has 2 USB-C ports and supports DisplayPort alt-mode, so it means you
+can charge it, connect to a external display and peripherals, all at the same
+time. Sadly, the maximum output resolution I got was 1080p (2560x1080),
+although some people at Reddit <a href="https://www.reddit.com/r/chromeos/comments/zh27tg/comment/izku724/?utm_source=share&amp;utm_medium=web3x&amp;utm_name=web3xcss&amp;utm_term=1&amp;utm_content=share_button">seems to have
+success</a>
+at 1440p, and the specs suggests it supports 4k. It may be my Dell S3423DWC
+monitor being wonky, the fact that it is Ultrawide or the cable, who knows? I
+even tried to change the monitor to &quot;High Resolution&quot; mode in settings, but to
+no avail.</p>
+<p><em>Update:</em> looking at the <a href="https://www.qualcomm.com/content/dam/qcomm-martech/dm-assets/documents/prod_brief_qcom_sd7c_gen2.pdf">product
+brief</a>
+for Snapdragon 7c Gen 2, it seems it supports up to QHD@60Hz (1440p) for the
+external display, and not 4k. This explains why it doesn't work at maximum
+resolution in my Dell S3423DWC, since while it is 1440p it is Ultrawide, so the
+resolution is bigger than QHD (3440x1440 vs 2560x1440).</p>
+<p>ChromeOS is also really interesting nowadays. To start, it is designed from the
+ground up to be a <a href="https://support.google.com/chromebook/answer/3438631">secure computing
+environment</a>, probably
+the most secure OS for consumers right now. Being a Chrome-first OS makes it a
+compromised experience, for example, it is the only device that I use Chrome as
+my main browser (since I personally prefer Firefox). But having a OS that boots
+fast is great: I never worry about OS updates because I know the device will be
+ready in seconds after a reboot. And the whole desktop experience inside the
+ChromeOS desktop is good, having shortcuts for many operations so you can get
+things done fast, and support for virtual desktops (ChromeOS call it &quot;desks&quot;)
+means you can organise your windows as much as you want.</p>
+<p>And what I think makes ChromeOS really powerful is
+<a href="https://chromeos.dev/en/linux">Crostini</a>, a full Linux VM that you can run
+inside ChromeOS. It runs Debian (it seems you can <a href="https://www.reddit.com/r/Crostini/wiki/howto/run-other-distros/">run other
+distros</a>
+though) with a deep integration with ChromeOS, so you can run even graphical
+programs without issues (including OpenGL!):</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-05/Screenshot_2024-08-05_21.22.29.png"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-05/Screenshot_2024-08-05_21.22.29.png" alt="Fastfetch inside Crostini with gitk running side-by-side."></a></p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-05/Screenshot_2024-08-05_21.39.58.png"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-08-05/Screenshot_2024-08-05_21.39.58.png" alt="Running glxgears inside Crostini."></a></p>
+<p>This is all thanks to
+<a href="https://chromium.googlesource.com/chromiumos/platform2/+/HEAD/vm_tools/sommelier/README.md">Sommelier</a>,
+a nested Wayland compositor that runs inside Crostini and allow both Wayland
+and X11 applications to be forwarded to ChromeOS. The integration is so good
+that I can run Firefox inside Crostini and works well enough, but sadly Firefox
+is too slow in this device (I am not sure if the issue is ChromeOS or Firefox,
+but I suspect the later since Google does some optimisation per device).</p>
+<p>One interesting tidbit about the OpenGL situation in this device: this seems to
+be the first Chromebook to ship with open source drivers, thanks to Freedreno.
+There is <a href="https://www.youtube.com/watch?v=8mnjSmN03VM">this</a> very interesting
+presentation done by Rob Clark in XDC 2021, that I recommended anyone
+interested in free drivers to watch (the reference design of Duet 3 is
+<a href="https://chromeunboxed.com/chromebook-tablet-snapdragon-7c-homestar-coachz-strongbad">Strongbad</a>).</p>
+<p>The Crostini integration is probably the best VM integration with Linux I ever
+saw in an OS: you can manage files inside the VM, share directories between the
+OS and VM, copy and paste works between the two, GUI applications installed
+inside the VM appear in the ChromeOS menu, memory allocation inside the VM is
+transparent, etc. Even the themes for Linux GUI applications are customised to
+match ChromeOS. It is unironically one of the best Linux desktop experiences I
+ever had.</p>
+<p>Of course I am using Nix, but since the Crostini integration depends on some
+services being configured and installed, I decided to run Nix inside Debian
+instead of NixOS and run <a href="https://nix-community.github.io/home-manager/index.xhtml#sec-install-standalone">Home-Manager
+standalone</a>.
+I recommend checking the official <a href="https://wiki.nixos.org/wiki/Installing_Nix_on_Crostini">NixOS Wiki article about
+Crostini</a>, that details
+how to register applications in ChromeOS (so desktop applications appear in
+menu) and use <a href="https://github.com/nix-community/nixGL">nixGL</a> to make OpenGL
+applications work.</p>
+<p>Like I said at the start of the article, the device is woefully slow thanks to
+its CPU and eMMC. It does mean that, for example, activating my Home-Manager
+configuration takes a while (around 1 minute, vs a few seconds in my laptop).
+But it is much faster than say,
+<a href="https://github.com/nix-community/nix-on-droid-app">nix-on-droid</a>, that the
+last time I tried in a much more powerful device (<a href="https://www.gsmarena.com/xiaomi_pad_5-11042.php">Xiaomi Pad
+5</a>), took 30 minutes until I
+just decided to cancel the operation. Having a proper VM instead of
+<a href="https://wiki.termux.com/wiki/PRoot">proot</a> makes all the difference here.</p>
+<p>I can even do some light programming here: using my
+<a href="https://kokada.dev/blog/troubleshoting-zsh-lag-and-solutions-with-nix">ZSH</a>
+and neovim configuration (including LSP for coding) is reasonable fast. For
+example, I did most of the code that <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">powers this
+blog</a>
+using this Chromebook. If I need more power, I can use the <a href="https://tailscale.com/kb/1267/install-chromebook">Tailscale app for
+Android</a> to connect to any
+other of my hosts via SSH. Yes, the Tailscale app works in Crostini, sadly
+without MagicDNS, so you need to use the internal Tailscale IPs instead.</p>
+<p>Until Google decides to give us a proper VM or user namespaces in Android or
+release a hybrid Chromebook device with better specs, this small Chromebook
+will probably stay as my travel companion, and is one of my favorite devices.</p></description><pubDate>Mon, 05 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/my-favorite-device-is-a-chromebook/</guid></item><item><title>Make nixd module completion to work anywhere (with Flakes)</title><link>https://kokada.dev/blog/make-nixd-module-completion-to-work-anywhere-with-flakes/</link><description><p>If you want the TL;DR, go to the bottom of the post (search for &quot;final
+result&quot;).</p>
+<p>I recently switched from <a href="https://github.com/oxalica/nil">nil</a> to
+<a href="https://github.com/nix-community/nixd">nixd</a> as my LSP of choice for Nix. I
+was curious in <code>nixd</code> for a long time since the fact that it can eval Nix code
+means it can offer much more powerful completion than the <code>nil</code>'s static
+analysis, however it used to be difficult to setup. Nowadays it is much easier,
+basically doing the right thing as long as you have <code>NIX_PATH</code> setup, and you
+get both package and NixOS modules completion.</p>
+<p>Getting Home-Manager modules though needs some setup. The recommended way to
+setup accordingly to the <a href="https://github.com/nix-community/nixd/blob/fe202307eaf7e89c4366ed927af761482a6065c8/nixd/docs/configuration.md">official
+documentation</a>
+is to use the following for Flake based configurations (using neovim
+configuration here, but it should be easy to adapt to other editors):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s2">&#34;import &lt;nixpkgs&gt; { }&#34;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="n">options</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixos</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;(builtins.getFlake (&#34;git+file://&#34; + toString ./.)).nixosConfigurations.miku-nixos.options&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="n">home_manager</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;(builtins.getFlake (&#34;git+file://&#34; + toString ./.)).homeConfigurations.home-linux.options&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="c1">-- ...</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This works, but it should be pretty clear the limitations of using <code>./.</code>: this
+will only work if you open your editor in your <a href="https://github.com/thiagokokada/nix-configs">Nix configuration
+repository</a>. For any other
+repository, <code>nixosConfigurations.miku-nixos</code> or <code>homeConfigurations.home-linux</code>
+will not exist and the completion will not work.</p>
+<p>It may look like this is easy to fix if you have
+<a href="https://nixos.org/manual/nixos/unstable/options#opt-_module.args"><code>specialArgs</code></a>
+(or <code>extraSpecialArgs</code> in Home-Manager) set to have your
+Flakes inputs, but:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1"># By the way, ${self} does not exist in the Flake output by default, you need</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># to explicit add `inherit self` to your outputs:</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># https://discourse.nixos.org/t/who-is-self-in-flake-outputs/31859/4</span>
+</span></span><span class="line"><span class="cl"><span class="n">nix-repl</span><span class="o">&gt;</span> <span class="p">(</span><span class="nb">builtins</span><span class="o">.</span><span class="n">getFlake</span> <span class="s2">&#34;git+file://</span><span class="si">${</span><span class="n">self</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">nixosConfigurations</span><span class="o">.</span><span class="n">miku-linux</span><span class="o">.</span><span class="n">options</span>
+</span></span><span class="line"><span class="cl"><span class="n">error</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="err">…</span> <span class="n">while</span> <span class="n">calling</span> <span class="n">the</span> <span class="err">&#39;</span><span class="n">getFlake&#39;</span> <span class="n">builtin</span>
+</span></span><span class="line"><span class="cl"> <span class="n">at</span> <span class="err">«</span><span class="n">string</span><span class="err">»</span><span class="p">:</span><span class="mi">1</span><span class="p">:</span><span class="mi">2</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="mi">1</span><span class="err">|</span> <span class="p">(</span><span class="nb">builtins</span><span class="o">.</span><span class="n">getFlake</span> <span class="s2">&#34;git+file://</span><span class="si">${</span><span class="n">self</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="err">|</span> <span class="err">^</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="err">…</span> <span class="n">while</span> <span class="n">evaluating</span> <span class="n">the</span> <span class="n">argument</span> <span class="n">passed</span> <span class="n">to</span> <span class="nb">builtins</span><span class="o">.</span><span class="n">getFlake</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">error</span><span class="p">:</span> <span class="n">the</span> <span class="n">string</span> <span class="err">&#39;</span><span class="sd">git+file:///nix/store/avr1lcmznj8ghynh5vj1kakgfdf0zrxx-source&#39;</span> <span class="n">is</span> <span class="n">not</span> <span class="n">allowed</span> <span class="n">to</span> <span class="n">refer</span> <span class="n">to</span> <span class="n">a</span> <span class="n">store</span> <span class="n">path</span> <span class="p">(</span><span class="n">such</span> <span class="n">as</span> <span class="err">&#39;</span><span class="n">avr1lcmznj8ghynh5vj1kakgfdf0zrxx-source&#39;</span><span class="p">)</span>
+</span></span></code></pre><p>Well, it was worth a try. Another option would be to:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">(</span><span class="nb">builtins</span><span class="o">.</span><span class="n">getFlake</span> <span class="s2">&#34;github:thiagokokada/nix-configs&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">nixosConfigurations</span><span class="o">.</span><span class="n">miku-linux</span><span class="o">.</span><span class="n">options</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># Or even something like this</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># However, using ${rev} means this wouldn&#39;t work in dirty Flake repos, since</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># ${rev} is not set in those cases</span>
+</span></span><span class="line"><span class="cl"><span class="p">(</span><span class="nb">builtins</span><span class="o">.</span><span class="n">getFlake</span> <span class="s2">&#34;github:thiagokokada/nix-configs/</span><span class="si">${</span><span class="n">rev</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">nixosConfigurations</span><span class="o">.</span><span class="n">miku-linux</span><span class="o">.</span><span class="n">options</span>
+</span></span></code></pre><p>But while it works, it is slow, because it needs network to evaluate (and it is
+impure, since there is no <code>flake.lock</code>).</p>
+<p>The default configuration for <code>nixd</code> makes NixOS completion work even outside
+of my configuration repo, and it is fast. How? I decided to take a look at the
+<code>nixd</code> source code and found
+<a href="https://github.com/nix-community/nixd/blob/d938026c55c7c36a6e79afd9627459160b4924ed/nixd/lib/Controller/LifeTime.cpp#L33C11-L35C76">this</a>
+(formatted here for legibility):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="sr">&lt;nixpkgs&gt;</span> <span class="p">{</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">(</span><span class="n">pkgs</span><span class="o">.</span><span class="n">lib</span><span class="o">.</span><span class="n">evalModules</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">modules</span> <span class="o">=</span> <span class="p">(</span><span class="kn">import</span> <span class="sr">&lt;nixpkgs/nixos/modules/module-list.nix&gt;</span><span class="p">)</span> <span class="o">++</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="p">({</span> <span class="o">...</span> <span class="p">}:</span> <span class="p">{</span> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">hostPlatform</span> <span class="o">=</span> <span class="nb">builtins</span><span class="o">.</span><span class="n">currentSystem</span><span class="p">;</span> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span><span class="o">.</span><span class="n">options</span>
+</span></span></code></pre><p>Interesting, so they're manually loading the modules using <code>evalModules</code>. As I
+said above, it depends in <code>NIX_PATH</code> being correctly set. Can we fix this to
+use our Flake inputs instead? After some tries in the Nix REPL, I got the
+following:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="s2">&#34;</span><span class="si">${</span><span class="n">inputs</span><span class="o">.</span><span class="n">nixpkgs</span><span class="si">}</span><span class="s2">&#34;</span> <span class="p">{</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">(</span><span class="n">pkgs</span><span class="o">.</span><span class="n">lib</span><span class="o">.</span><span class="n">evalModules</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">modules</span> <span class="o">=</span> <span class="p">(</span><span class="kn">import</span> <span class="s2">&#34;</span><span class="si">${</span><span class="n">inputs</span><span class="o">.</span><span class="n">nixpkgs</span><span class="si">}</span><span class="s2">/nixos/modules/module-list.nix&#34;</span><span class="p">)</span> <span class="o">++</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="p">({</span> <span class="o">...</span> <span class="p">}:</span> <span class="p">{</span> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">hostPlatform</span> <span class="o">=</span> <span class="nb">builtins</span><span class="o">.</span><span class="n">currentSystem</span><span class="p">;</span> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span><span class="o">.</span><span class="n">options</span>
+</span></span></code></pre><p>So we can adapt this to the neovim configuration:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">options</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixos</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;(let pkgs = import &#34;${inputs.nixpkgs}&#34; { }; in (pkgs.lib.evalModules { modules = (import &#34;${inputs.nixpkgs}/nixos/modules/module-list.nix&#34;) ++ [ ({...}: { nixpkgs.hostPlatform = builtins.currentSystem;} ) ] ; })).options&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>This was easy. But the main issue is Home-Manager. How can we fix it? I needed
+to take a look at the Home-Manager <a href="https://github.com/nix-community/home-manager/blob/master/docs/default.nix#L161-L169">source
+code</a>
+to find the answer:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">(</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="s2">&#34;</span><span class="si">${</span><span class="n">inputs</span><span class="o">.</span><span class="n">nixpkgs</span><span class="si">}</span><span class="s2">&#34;</span> <span class="p">{</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="n">lib</span> <span class="o">=</span> <span class="kn">import</span> <span class="s2">&#34;</span><span class="si">${</span><span class="n">inputs</span><span class="o">.</span><span class="n">home-manager</span><span class="si">}</span><span class="s2">/modules/lib/stdlib-extended.nix&#34;</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">lib</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">(</span><span class="n">lib</span><span class="o">.</span><span class="n">evalModules</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">modules</span> <span class="o">=</span> <span class="p">(</span><span class="kn">import</span> <span class="s2">&#34;</span><span class="si">${</span><span class="n">inputs</span><span class="o">.</span><span class="n">home-manager</span><span class="si">}</span><span class="s2">/modules/modules.nix&#34;</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">inherit</span> <span class="n">lib</span> <span class="n">pkgs</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">check</span> <span class="o">=</span> <span class="no">false</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">})</span>
+</span></span><span class="line"><span class="cl"><span class="p">)</span><span class="o">.</span><span class="n">options</span>
+</span></span></code></pre><p>The interesting part is: Home-Manager has its own extension of the module
+system (including <code>evalModules</code>). This includes e.g.: extra types used in
+Home-Manager only. Also, we need to disable <code>checks</code>, otherwise we will hit
+some validations (e.g.: missing <code>stateVersion</code>). I am not sure if this causes
+any issue for module completion yet, I may set it in the future.</p>
+<p>And for the final result:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;import &#34;${flake.inputs.nixpkgs}&#34; { }&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="n">options</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixos</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;(let pkgs = import &#34;${inputs.nixpkgs}&#34; { }; in (pkgs.lib.evalModules { modules = (import &#34;${inputs.nixpkgs}/nixos/modules/module-list.nix&#34;) ++ [ ({...}: { nixpkgs.hostPlatform = builtins.currentSystem;} ) ] ; })).options&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="n">home_manager</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">expr</span> <span class="o">=</span> <span class="s1">&#39;(let pkgs = import &#34;${inputs.nixpkgs}&#34; { }; lib = import &#34;${inputs.home-manager}/modules/lib/stdlib-extended.nix&#34; pkgs.lib; in (lib.evalModules { modules = (import &#34;${inputs.home-manager}/modules/modules.nix&#34;) { inherit lib pkgs; check = false; }; })).options&#39;</span><span class="p">,</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"> <span class="p">},</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Yes, it is quite a mouthful, but it makes module completion work in any
+repository, as long as you're using Flakes. And it is fast, since it doesn't
+need any network access. Since we are already here, let's define <code>nixpkgs</code> to
+not depend in the <code>NIX_PATH</code> being set too.</p></description><pubDate>Sun, 04 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/make-nixd-module-completion-to-work-anywhere-with-flakes/</guid></item><item><title>Troubleshooting: ZSH lag and solutions with Nix</title><link>https://kokada.dev/blog/troubleshoting-zsh-lag-and-solutions-with-nix/</link><description><p>Inspired by this <a href="https://lock.cmpxchg8b.com/slowterm.html">blog post from
+Tavis</a>, I decided to document my own
+recent journey of reducing terminal (ZSH) lag startup. This post is way less
+interesting than the one from Tavis that uses a debugger to patch applications
+on the fly, but should still be interesting for some. And it also shows how
+powerful Nix can be for some things.</p>
+<p>For context, I have basically 3 systems where I interact with terminal
+frequently:</p>
+<ul>
+<li><a href="https://www.notebookcheck.net/Lenovo-ThinkPad-P14s-Gen-1-Laptop-Review-AMD-workstation-sans-dedicated-GPU.528746.0.html">Thinkpad P14s Gen 1</a>
+running NixOS, with a reasonable fast CPU (<a href="https://www.notebookcheck.net/AMD-Ryzen-7-PRO-4750U-Processor-Benchmarks-and-Specs.464396.0.html">AMD Ryzen 7 PRO
+4750U</a>)
+and disk (NVMe)</li>
+<li><a href="https://everymac.com/systems/apple/macbook_pro/specs/macbook-pro-m1-pro-10-core-cpu-16-core-gpu-16-2021-specs.html">MacBook
+Pro</a>
+with a really fast CPU (M1 Pro) and disk, but of course running macOS, being
+phased-out since this is a job owned machine and I am changing jobs right
+now, but should be replaced with another one soon™</li>
+<li><a href="https://chromeunboxed.com/lenovo-chromebook-duet-3-review-perfect-sequel">Chromebook Duet
+3</a>
+running ChromeOS, with slow CPU (<a href="https://www.notebookcheck.net/Qualcomm-Snapdragon-7c-Gen-2-Processor-Benchmarks-and-Specs.554426.0.html">Snapdragon 7c Gen
+2</a>)
+and disk (eMMC, really?)</li>
+</ul>
+<p>My experience is similar to Tavis, at around 300ms of startup time I don't care
+too much, but around 500ms+ is where I start to notice. I never had any issues
+with startup time in NixOS itself (I had issues with macOS before, but it was
+not actually the fault of macOS), but in the Chromebook it was awful: 600ms+
+with <a href="https://www.instabug.com/blog/understanding-cold-hot-and-warm-app-launch-time">hot
+start</a>,
+while cold start it could take multiple seconds.</p>
+<p>We can check how long ZSH takes to start by using:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> <span class="nb">time</span> zsh -ci <span class="nb">exit</span>
+</span></span><span class="line"><span class="cl"><span class="go">zsh -ic exit 0.04s user 0.10s system 100% cpu 0.143 total
+</span></span></span></code></pre><p>The <code>-i</code> flag here is important, because we are interested in the interactive
+use of ZSH. Without this flag ZSH will ignore your <code>~/.zshrc</code> file, and the
+results will be meaningless.</p>
+<p>To do a more interesting benchmark, we can use
+<a href="https://github.com/sharkdp/hyperfine"><code>hyperfine</code></a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine <span class="s2">&#34;zsh -ic exit&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: zsh -ic exit
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 145.4 ms ± 4.2 ms [User: 49.8 ms, System: 97.3 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 138.6 ms … 155.3 ms 19 runs
+</span></span></span></code></pre><p>Hyperfine will run the command multiple times and take care of things like
+shell startup time. A really great tool to have in your toolbox by the way, but
+I digress.</p>
+<p>So let's do a little time travelling. Going back to commit
+<a href="https://github.com/thiagokokada/nix-configs/tree/b12757f90889653e359a1ab0a8cfd2f90cfabf31"><code>b12757f</code></a>
+from <a href="https://github.com/thiagokokada/nix-configs/">nix-configs</a>. Running
+<code>hyperfine</code> like above from my NixOS laptop, we have:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine <span class="s2">&#34;zsh -ic exit&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: zsh -ic exit
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 218.6 ms ± 5.1 ms [User: 70.6 ms, System: 151.5 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 210.3 ms … 227.0 ms 13 runs
+</span></span></span></code></pre><p>This doesn't look that bad, but let's see the same commit in my Chromebook:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine <span class="s2">&#34;zsh -ic exit&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: zsh -ic exit
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 679.7 ms ± 40.2 ms [User: 230.8 ms, System: 448.5 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 607.3 ms … 737.0 ms 10 runs
+</span></span></span></code></pre><p>Yikes, this is much worse. And those are the results after I retried the
+benchmark (so it is a hot start). The cold start times were above 3s. So let's
+investigate what is happening here. We can profile what is taking time during
+the startup of ZSH using <a href="https://www.bigbinary.com/blog/zsh-profiling">zprof</a>.
+You can add the following in your <code>~/.zshrc</code>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1"># At the top of your ~/.zshrc file</span>
+</span></span><span class="line"><span class="cl">zmodload zsh/zprof
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># At the end of your ~/.zshrc file</span>
+</span></span><span class="line"><span class="cl">zprof
+</span></span></code></pre><p>Or if using Home-Manager, use the
+<a href="https://nix-community.github.io/home-manager/options.xhtml#opt-programs.zsh.zprof.enable"><code>programs.zsh.zprof.enable</code></a>
+option. Once we restart ZSH, we will have something like:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="go">num calls time self name
+</span></span></span><span class="line"><span class="cl"><span class="go">-----------------------------------------------------------------------------------
+</span></span></span><span class="line"><span class="cl"><span class="go"> 1) 1 36.91 36.91 34.29% 30.47 30.47 28.31% (anon) [/home/thiagoko/.zsh/plugins/zim-completion/init.zsh:13]
+</span></span></span><span class="line"><span class="cl"><span class="go"> 2) 1 25.43 25.43 23.63% 25.43 25.43 23.63% (anon) [/home/thiagoko/.zsh/plugins/zim-ssh/init.zsh:6]
+</span></span></span><span class="line"><span class="cl"><span class="go"> 3) 1 22.00 22.00 20.45% 21.92 21.92 20.36% _zsh_highlight_load_highlighters
+</span></span></span><span class="line"><span class="cl"><span class="go"> 4) 1 12.32 12.32 11.45% 12.32 12.32 11.45% autopair-init
+</span></span></span><span class="line"><span class="cl"><span class="go"> 5) 1 6.44 6.44 5.98% 6.44 6.44 5.98% compinit
+</span></span></span><span class="line"><span class="cl"><span class="go"> 6) 1 3.56 3.56 3.31% 3.48 3.48 3.23% prompt_pure_state_setup
+</span></span></span><span class="line"><span class="cl"><span class="go"> 7) 2 3.79 1.89 3.52% 2.85 1.43 2.65% async
+</span></span></span><span class="line"><span class="cl"><span class="go"> 8) 1 0.93 0.93 0.87% 0.93 0.93 0.87% async_init
+</span></span></span><span class="line"><span class="cl"><span class="go"> 9) 6 0.93 0.15 0.86% 0.93 0.15 0.86% is-at-least
+</span></span></span><span class="line"><span class="cl"><span class="go">10) 6 0.67 0.11 0.63% 0.67 0.11 0.63% add-zle-hook-widget
+</span></span></span><span class="line"><span class="cl"><span class="go">11) 1 8.25 8.25 7.66% 0.61 0.61 0.57% prompt_pure_setup
+</span></span></span><span class="line"><span class="cl"><span class="go">12) 1 0.40 0.40 0.37% 0.40 0.40 0.37% (anon) [/nix/store/p1zqypy7600fvfyl1v571bljx2l8zhay-zsh-autosuggestions-0.7.0/share/zsh-autosuggestions/zsh-autosuggestions.zsh:458]
+</span></span></span><span class="line"><span class="cl"><span class="go">13) 5 0.31 0.06 0.29% 0.31 0.06 0.29% add-zsh-hook
+</span></span></span><span class="line"><span class="cl"><span class="go">14) 1 0.60 0.60 0.56% 0.29 0.29 0.27% (anon) [/home/thiagoko/.zsh/plugins/zim-input/init.zsh:5]
+</span></span></span><span class="line"><span class="cl"><span class="go">15) 1 0.21 0.21 0.20% 0.21 0.21 0.20% compdef
+</span></span></span><span class="line"><span class="cl"><span class="go">16) 1 0.10 0.10 0.09% 0.10 0.10 0.09% _zsh_highlight__function_is_autoload_stub_p
+</span></span></span><span class="line"><span class="cl"><span class="go">17) 1 0.26 0.26 0.24% 0.08 0.08 0.08% _zsh_highlight__function_callable_p
+</span></span></span><span class="line"><span class="cl"><span class="go">18) 1 0.08 0.08 0.08% 0.08 0.08 0.08% prompt_pure_is_inside_container
+</span></span></span><span class="line"><span class="cl"><span class="go">19) 1 0.07 0.07 0.07% 0.07 0.07 0.07% _zsh_highlight__is_function_p
+</span></span></span><span class="line"><span class="cl"><span class="go">20) 1 0.01 0.01 0.01% 0.01 0.01 0.01% __wezterm_install_bash_prexec
+</span></span></span><span class="line"><span class="cl"><span class="go">21) 1 0.00 0.00 0.00% 0.00 0.00 0.00% _zsh_highlight_bind_widgets
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="gp">#</span> ...
+</span></span></code></pre><p>I ommited some output for brevit. The first 2 things that shows are from the
+<a href="https://github.com/zimfw/zimfw">zimfw</a>, the framework that I use to configure
+my ZSH (similar to Oh-My-Zsh). I actually don't use <code>zimfw</code> directly, instead I
+just load some modules that I find useful, like the <code>zim-completion</code> and
+<code>zim-ssh</code> that we can see above. By the way, Zim is generally really well
+optimised for startup time, but those 2 modules are kind slow.</p>
+<p>For <a href="https://github.com/zimfw/completion"><code>zim-completion</code></a>, after taking a
+look at it, there isn't much I could do. It seems that the reason
+<code>zim-completion</code> takes so long during startup is because it is trying to decide
+if it needs to recompile the completions (and replacing it with just a naive
+<code>autoload -U compinit &amp;&amp; compinit</code> is even worse for startup performance). I
+may eventually replace it for something else, but I really like what Zim brings
+here, so I decided to not touch it for now.</p>
+<p>However <a href="https://github.com/zimfw/ssh"><code>zim-ssh</code></a> is another history. The only
+reason I used it is to start a <code>ssh-agent</code> and keep it between multiple ZSH
+sessions. It shouldn't have that much influence in startup time. So I took a
+look the code (since it is small, I am reproducing it here):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1">#</span>
+</span></span><span class="line"><span class="cl"><span class="c1"># Set up ssh-agent</span>
+</span></span><span class="line"><span class="cl"><span class="c1">#</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># Don&#39;t do anything unless we can actually use ssh-agent</span>
+</span></span><span class="line"><span class="cl"><span class="o">((</span> <span class="si">${</span><span class="p">+commands[ssh-agent]</span><span class="si">}</span> <span class="o">))</span> <span class="o">&amp;&amp;</span> <span class="o">()</span> <span class="o">{</span>
+</span></span><span class="line"><span class="cl"> ssh-add -l <span class="p">&amp;</span>&gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">((</span> ? <span class="o">==</span> <span class="m">2</span> <span class="o">))</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Unable to contact the authentication agent</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Load stored agent connection info</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">local</span> -r <span class="nv">ssh_env</span><span class="o">=</span><span class="si">${</span><span class="nv">HOME</span><span class="si">}</span>/.ssh-agent
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">[[</span> -r <span class="si">${</span><span class="nv">ssh_env</span><span class="si">}</span> <span class="o">]]</span> <span class="nb">source</span> <span class="si">${</span><span class="nv">ssh_env</span><span class="si">}</span> &gt;/dev/null
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> ssh-add -l <span class="p">&amp;</span>&gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">((</span> ? <span class="o">==</span> <span class="m">2</span> <span class="o">))</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Start agent and store agent connection info</span>
+</span></span><span class="line"><span class="cl"> <span class="o">(</span><span class="nb">umask</span> 066<span class="p">;</span> ssh-agent &gt;! <span class="si">${</span><span class="nv">ssh_env</span><span class="si">}</span><span class="o">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">source</span> <span class="si">${</span><span class="nv">ssh_env</span><span class="si">}</span> &gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Load identities</span>
+</span></span><span class="line"><span class="cl"> ssh-add -l <span class="p">&amp;</span>&gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">((</span> ? <span class="o">==</span> <span class="m">1</span> <span class="o">))</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">local</span> -a zssh_ids
+</span></span><span class="line"><span class="cl"> zstyle -a <span class="s1">&#39;:zim:ssh&#39;</span> ids <span class="s1">&#39;zssh_ids&#39;</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">((</span> <span class="si">${#</span><span class="nv">zssh_ids</span><span class="si">}</span> <span class="o">))</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> ssh-add <span class="si">${</span><span class="nv">HOME</span><span class="si">}</span>/.ssh/<span class="si">${</span><span class="p">^zssh_ids</span><span class="si">}</span> 2&gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">else</span>
+</span></span><span class="line"><span class="cl"> ssh-add 2&gt;/dev/null
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl"><span class="o">}</span>
+</span></span></code></pre><p>Well, this is bad. Let's assume the common path, where the <code>ssh-agent</code> is
+already running but you open a new shell instance (that doesn't have the
+connection info yet so it will need to load). This will run <code>ssh-add</code> at 4
+times. How long does <code>ssh-add</code> takes to run?</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine -Ni <span class="s2">&#34;ssh-add -l&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: ssh-add -l
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 4.6 ms ± 1.1 ms [User: 2.0 ms, System: 2.0 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 3.4 ms … 8.7 ms 619 runs
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="go"> Warning: Ignoring non-zero exit code.
+</span></span></span></code></pre><p>For those curious, <code>-N</code> disables the Shell usage, that works better when the
+command being tested is too fast.</p>
+<p>In average we have 4x4ms=16ms of startup time. But keep in mind the worst case
+can be much worse. The question is, how can we improve the situation here?</p>
+<p>After taking a look, I decided to write my own code, based in some ideas stolen
+from <a href="https://github.com/ohmyzsh/ohmyzsh/blob/67581c53c6458566e174620361e84b364b9034d2/plugins/ssh-agent/ssh-agent.plugin.zsh">Oh-My-Zsh ssh-agent
+plugin</a>.
+Here is final version of my
+<a href="https://github.com/thiagokokada/nix-configs/blob/e45a888f2bf3ce5644c3966f0b6371414d0291e2/home-manager/cli/ssh/ssh-agent.zsh">code</a>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl">zmodload zsh/net/socket
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl">_check_agent<span class="o">(){</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">[[</span> -S <span class="s2">&#34;</span><span class="nv">$SSH_AUTH_SOCK</span><span class="s2">&#34;</span> <span class="o">]]</span> <span class="o">&amp;&amp;</span> zsocket <span class="s2">&#34;</span><span class="nv">$SSH_AUTH_SOCK</span><span class="s2">&#34;</span> 2&gt;/dev/null<span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="m">0</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="m">1</span>
+</span></span><span class="line"><span class="cl"><span class="o">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl">_start_agent<span class="o">()</span> <span class="o">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Test if $SSH_AUTH_SOCK is visible, in case we start e.g.: ssh-agent via</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># systemd service</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> _check_agent<span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="m">0</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Get the filename to store/lookup the environment from</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">local</span> -r <span class="nv">ssh_env_cache</span><span class="o">=</span><span class="s2">&#34;</span><span class="nv">$HOME</span><span class="s2">/.ssh-agent&#34;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Check if ssh-agent is already running</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="o">[[</span> -f <span class="s2">&#34;</span><span class="nv">$ssh_env_cache</span><span class="s2">&#34;</span> <span class="o">]]</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">source</span> <span class="s2">&#34;</span><span class="nv">$ssh_env_cache</span><span class="s2">&#34;</span> &gt; /dev/null
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Test if $SSH_AUTH_SOCK is visible, e.g.: the ssh-agent is still alive</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> _check_agent<span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="m">0</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl"> <span class="k">fi</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># start ssh-agent and setup environment</span>
+</span></span><span class="line"><span class="cl"> <span class="o">(</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">umask</span> <span class="m">066</span>
+</span></span><span class="line"><span class="cl"> ssh-agent -s &gt;! <span class="s2">&#34;</span><span class="nv">$ssh_env_cache</span><span class="s2">&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="o">)</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">source</span> <span class="s2">&#34;</span><span class="nv">$ssh_env_cache</span><span class="s2">&#34;</span> &gt; /dev/null
+</span></span><span class="line"><span class="cl"><span class="o">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl">_start_agent
+</span></span><span class="line"><span class="cl">unfunction _check_agent _start_agent
+</span></span></code></pre><p>The idea here is simple: using
+<a href="https://zsh.sourceforge.io/Doc/Release/Zsh-Modules.html#The-zsh_002fnet_002fsocket-Module"><code>zsocket</code></a>
+module from ZSH itself to check if the <code>ssh-agent</code> is working instead of
+executing <code>ssh-add -l</code>. The only case we run any program now is to start the
+agent itself if needed. Let's run <code>hyperfine</code> again:</p>
+<pre><code>$ hyperfine &quot;zsh -ic exit&quot;
+Benchmark 1: zsh -ic exit
+ Time (mean ± σ): 188.3 ms ± 8.2 ms [User: 61.1 ms, System: 130.0 ms]
+ Range (min … max): 170.9 ms … 198.4 ms 16 runs
+</code></pre>
+<p>Got a good improvement here already. Let's see <code>zprof</code> again:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="go">num calls time self name
+</span></span></span><span class="line"><span class="cl"><span class="go">-----------------------------------------------------------------------------------
+</span></span></span><span class="line"><span class="cl"><span class="go"> 1) 1 41.23 41.23 48.66% 33.52 33.52 39.56% (anon) [/home/thiagoko/.zsh/plugins/zim-completion/init.zsh:13]
+</span></span></span><span class="line"><span class="cl"><span class="go"> 2) 1 22.23 22.23 26.24% 22.12 22.12 26.10% _zsh_highlight_load_highlighters
+</span></span></span><span class="line"><span class="cl"><span class="go"> 3) 1 8.90 8.90 10.51% 8.90 8.90 10.51% Gautopair-init
+</span></span></span><span class="line"><span class="cl"><span class="go"> 4) 1 7.71 7.71 9.10% 7.71 7.71 9.10% compinit
+</span></span></span><span class="line"><span class="cl"><span class="go"> 5) 1 5.74 5.74 6.77% 5.60 5.60 6.60% prompt_pure_state_setup
+</span></span></span><span class="line"><span class="cl"><span class="go"> 6) 6 1.19 0.20 1.41% 1.19 0.20 1.41% add-zle-hook-widget
+</span></span></span><span class="line"><span class="cl"><span class="go"> 7) 2 1.97 0.99 2.33% 1.14 0.57 1.34% async
+</span></span></span><span class="line"><span class="cl"><span class="go"> 8) 6 0.87 0.15 1.03% 0.87 0.15 1.03% is-at-least
+</span></span></span><span class="line"><span class="cl"><span class="go"> 9) 1 0.84 0.84 0.99% 0.84 0.84 0.99% async_init
+</span></span></span><span class="line"><span class="cl"><span class="go">10) 1 9.30 9.30 10.97% 0.72 0.72 0.84% prompt_pure_setup
+</span></span></span><span class="line"><span class="cl"><span class="go">11) 5 0.63 0.13 0.75% 0.63 0.13 0.75% add-zsh-hook
+</span></span></span><span class="line"><span class="cl"><span class="go">12) 1 0.41 0.41 0.48% 0.41 0.41 0.48% _start_agent
+</span></span></span><span class="line"><span class="cl"><span class="go">13) 1 0.31 0.31 0.37% 0.31 0.31 0.37% (anon) [/nix/store/p1zqypy7600fvfyl1v571bljx2l8zhay-zsh-autosuggestions-0.7.0/share/zsh-autosuggestions/zsh-autosuggestions.zsh:458]
+</span></span></span><span class="line"><span class="cl"><span class="go">14) 1 0.55 0.55 0.64% 0.24 0.24 0.28% (anon) [/home/thiagoko/.zsh/plugins/zim-input/init.zsh:5]
+</span></span></span><span class="line"><span class="cl"><span class="go">15) 1 0.14 0.14 0.16% 0.14 0.14 0.16% prompt_pure_is_inside_container
+</span></span></span><span class="line"><span class="cl"><span class="go">16) 1 0.14 0.14 0.16% 0.14 0.14 0.16% compdef
+</span></span></span><span class="line"><span class="cl"><span class="go">17) 1 0.09 0.09 0.11% 0.09 0.09 0.11% _zsh_highlight__function_is_autoload_stub_p
+</span></span></span><span class="line"><span class="cl"><span class="go">18) 1 0.25 0.25 0.29% 0.08 0.08 0.09% _zsh_highlight__function_callable_p
+</span></span></span><span class="line"><span class="cl"><span class="go">19) 1 0.07 0.07 0.09% 0.07 0.07 0.09% _zsh_highlight__is_function_p
+</span></span></span><span class="line"><span class="cl"><span class="go">20) 1 0.01 0.01 0.01% 0.01 0.01 0.01% __wezterm_install_bash_prexec
+</span></span></span><span class="line"><span class="cl"><span class="go">21) 1 0.01 0.01 0.01% 0.01 0.01 0.01% _zsh_highlight_bind_widgets
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="gp">#</span> ...
+</span></span></code></pre><p>Well, there is nothing interesting here anymore. I mean, <code>zim-completion</code> is
+still the main culprit, but nothing to do for now. Instead of looking at
+<code>zproof</code>, let's take a look at my <code>~/.zshrc</code> instead:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="o">[[</span> <span class="nv">$options</span><span class="o">[</span>zle<span class="o">]</span> <span class="o">=</span> on <span class="o">]]</span><span class="p">;</span> <span class="k">then</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">eval</span> <span class="s2">&#34;</span><span class="k">$(</span>/nix/store/sk6wsgp4h477baxypksz9rl8ldwwh9yg-fzf-0.54.0/bin/fzf --zsh<span class="k">)</span><span class="s2">&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="k">fi</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl">/nix/store/x3yblr73r5x76dmaanjk3333mvzxc49r-any-nix-shell-1.2.1/bin/any-nix-shell zsh <span class="p">|</span> <span class="nb">source</span> /dev/stdin
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"><span class="nb">eval</span> <span class="s2">&#34;</span><span class="k">$(</span>/nix/store/330d6k81flfs6w46b44afmncxk57qggv-zoxide-0.9.4/bin/zoxide init zsh <span class="k">)</span><span class="s2">&#34;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"><span class="nb">eval</span> <span class="s2">&#34;</span><span class="k">$(</span>/nix/store/8l9j9kdv9m0z0s30lp4yvrc9s5bcbgmx-direnv-2.34.0/bin/direnv hook zsh<span class="k">)</span><span class="s2">&#34;</span>
+</span></span></code></pre><p>So you see, starting all those programs during ZSH startup can hurt the shell
+startup considerable. Not necessary for commands fast like <code>fzf</code> (that is
+written in Go), but let's see
+<a href="https://github.com/haslersn/any-nix-shell"><code>any-nix-shell</code></a>, that is written
+in shell script:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine <span class="s2">&#34;any-nix-shell zsh&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: any-nix-shell zsh
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 16.0 ms ± 1.8 ms [User: 5.6 ms, System: 10.5 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 11.3 ms … 20.3 ms 143 runs
+</span></span></span></code></pre><p>This is bad, consistently bad actually. Even for commands that are fast, keep
+in mind that there is a difference between the cold and hot start again. For
+example, <code>fzf</code>:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> hyperfine -N <span class="s2">&#34;fzf --zsh&#34;</span>
+</span></span><span class="line"><span class="cl"><span class="go">Benchmark 1: fzf --zsh
+</span></span></span><span class="line"><span class="cl"><span class="go"> Time (mean ± σ): 2.9 ms ± 0.9 ms [User: 0.6 ms, System: 2.3 ms]
+</span></span></span><span class="line"><span class="cl"><span class="go"> Range (min … max): 1.7 ms … 6.8 ms 1113 runs
+</span></span></span></code></pre><p>See the range? While 1.7ms is something that is probably difficult to notice,
+6.8ms can be noticiable, especially if this accumulates with other slow
+starting apps.</p>
+<p>And the thing is, all those commands are just generating in the end a fixed
+output, at least for the current version of the program. Can we pre-generate
+them instead? If using Nix, of course we can:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1"># You need to disable the default integration</span>
+</span></span><span class="line"><span class="cl"><span class="n">programs</span><span class="o">.</span><span class="n">direnv</span><span class="o">.</span><span class="n">enableZshIntegration</span> <span class="err">=</span> <span class="no">false</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="n">programs</span><span class="o">.</span><span class="n">fzf</span><span class="o">.</span><span class="n">enableZshIntegration</span> <span class="err">=</span> <span class="no">false</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="n">programs</span><span class="o">.</span><span class="n">zoxide</span><span class="o">.</span><span class="n">enableZshIntegration</span> <span class="err">=</span> <span class="no">false</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="n">programs</span><span class="o">.</span><span class="n">zsh</span><span class="o">.</span><span class="n">initExtra</span> <span class="err">=</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># bash</span>
+</span></span><span class="line"><span class="cl"> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> # any-nix-shell
+</span></span></span><span class="line"><span class="cl"><span class="s1"> source </span><span class="si">${</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span><span class="o">.</span><span class="n">runCommand</span> <span class="s2">&#34;any-nix-shell-zsh&#34;</span> <span class="p">{</span> <span class="p">}</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> </span><span class="si">${</span><span class="n">lib</span><span class="o">.</span><span class="n">getExe</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">any-nix-shell</span><span class="si">}</span><span class="s1"> zsh &gt; $out
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span>
+</span></span><span class="line"><span class="cl"> <span class="si">}</span><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> # fzf
+</span></span></span><span class="line"><span class="cl"><span class="s1"> source </span><span class="si">${</span><span class="n">config</span><span class="o">.</span><span class="n">programs</span><span class="o">.</span><span class="n">fzf</span><span class="o">.</span><span class="n">package</span><span class="si">}</span><span class="s1">/share/fzf/completion.zsh
+</span></span></span><span class="line"><span class="cl"><span class="s1"> source </span><span class="si">${</span><span class="n">config</span><span class="o">.</span><span class="n">programs</span><span class="o">.</span><span class="n">fzf</span><span class="o">.</span><span class="n">package</span><span class="si">}</span><span class="s1">/share/fzf/key-bindings.zsh
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> # zoxide
+</span></span></span><span class="line"><span class="cl"><span class="s1"> source </span><span class="si">${</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span><span class="o">.</span><span class="n">runCommand</span> <span class="s2">&#34;zoxide-init-zsh&#34;</span> <span class="p">{</span> <span class="p">}</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> </span><span class="si">${</span><span class="n">lib</span><span class="o">.</span><span class="n">getExe</span> <span class="n">config</span><span class="o">.</span><span class="n">programs</span><span class="o">.</span><span class="n">zoxide</span><span class="o">.</span><span class="n">package</span><span class="si">}</span><span class="s1"> init zsh &gt; $out
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span>
+</span></span><span class="line"><span class="cl"> <span class="si">}</span><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> # direnv
+</span></span></span><span class="line"><span class="cl"><span class="s1"> source </span><span class="si">${</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span><span class="o">.</span><span class="n">runCommand</span> <span class="s2">&#34;direnv-hook-zsh&#34;</span> <span class="p">{</span> <span class="p">}</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> </span><span class="si">${</span><span class="n">lib</span><span class="o">.</span><span class="n">getExe</span> <span class="n">config</span><span class="o">.</span><span class="n">programs</span><span class="o">.</span><span class="n">direnv</span><span class="o">.</span><span class="n">package</span><span class="si">}</span><span class="s1"> hook zsh &gt; $out
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span>
+</span></span><span class="line"><span class="cl"> <span class="si">}</span><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span></code></pre><p>So we can use <code>pkgs.runCommand</code> to run those commands during build time and
+<code>source</code> the result. <code>fzf</code> actually doesn't need this since we have the files
+already generated in the package. I think this is one of those things that
+really shows the power of Nix: I wouldn't do something similar if I didn't use
+Nix because the risk of breaking something later is big (e.g.: forgetting to
+update the generated files), but Nix makes those things trivial.</p>
+<p>Let's run <code>hyperfine</code> again:</p>
+<pre><code>$ hyperfine &quot;zsh -ic exit&quot;
+Benchmark 1: zsh -ic exit
+ Time (mean ± σ): 162.3 ms ± 4.9 ms [User: 52.7 ms, System: 111.1 ms]
+ Range (min … max): 153.0 ms … 173.4 ms 19 runs
+</code></pre>
+<p>Another good improvement. The last change I did is switching between
+<a href="https://github.com/zsh-users/zsh-syntax-highlighting"><code>zsh-syntax-highlighting</code></a>
+to
+<a href="https://github.com/zdharma-continuum/fast-syntax-highlighting"><code>zsh-fast-syntax-highlighting</code></a>,
+that is supposed to be faster and have better highlighting too. I got that from
+<code>_zsh_highlight_load_highlighters</code> using 26% of the time from my <code>zprof</code> above.
+And for the final <code>hyperfine</code> in my laptop:</p>
+<pre><code>$ hyperfine &quot;zsh -ic exit&quot;
+Benchmark 1: zsh -ic exit
+ Time (mean ± σ): 138.3 ms ± 7.1 ms [User: 47.5 ms, System: 91.9 ms]
+ Range (min … max): 123.8 ms … 157.9 ms 21 runs
+</code></pre>
+<p>A ~36% improvement, not bad. Let's see how it fares in my Chromebook:</p>
+<pre><code>$ hyperfine &quot;zsh -ic exit&quot;
+Benchmark 1: zsh -ic exit
+ Time (mean ± σ): 278.2 ms ± 46.9 ms [User: 88.0 ms, System: 184.8 ms]
+ Range (min … max): 204.7 ms … 368.5 ms 11 runs
+</code></pre>
+<p>An even more impressive ~59% improvement. And yes, the shell startup now feels
+much better.</p></description><pubDate>Thu, 01 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/troubleshoting-zsh-lag-and-solutions-with-nix/</guid></item><item><title>Quick bits: realise Nix symlinks</title><link>https://kokada.dev/blog/quick-bits-realise-nix-symlinks/</link><description><p>When you are using Nix, especially with
+<a href="https://github.com/nix-community/home-manager/">Home-Manager</a>, there are times
+when you want to test something or maybe debug some issue in your
+configuration. Those times it would be really convenient if you could avoid a
+rebuild of your Home-Manager configuration, since this takes time until
+evaluation and activation.</p>
+<p>For those times I have this small script in my Nix configuration called
+<code>realise-symlinks</code>, that is defined as:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span> <span class="n">pkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"><span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">realise-symlink</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">writeShellApplication</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;realise-symlink&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">runtimeInputs</span> <span class="o">=</span> <span class="k">with</span> <span class="n">pkgs</span><span class="p">;</span> <span class="p">[</span> <span class="n">coreutils</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="n">text</span> <span class="o">=</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> for file in &#34;$@&#34;; do
+</span></span></span><span class="line"><span class="cl"><span class="s1"> if [[ -L &#34;$file&#34; ]]; then
+</span></span></span><span class="line"><span class="cl"><span class="s1"> if [[ -d &#34;$file&#34; ]]; then
+</span></span></span><span class="line"><span class="cl"><span class="s1"> tmpdir=&#34;</span><span class="se">&#39;&#39;$</span><span class="s1">{file}.tmp&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> mkdir -p &#34;$tmpdir&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> cp --verbose --recursive &#34;$file&#34;/* &#34;$tmpdir&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> unlink &#34;$file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> mv &#34;$tmpdir&#34; &#34;$file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> chmod --changes --recursive +w &#34;$file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> else
+</span></span></span><span class="line"><span class="cl"><span class="s1"> cp --verbose --remove-destination &#34;$(readlink &#34;$file&#34;)&#34; &#34;$file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> chmod --changes +w &#34;$file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> fi
+</span></span></span><span class="line"><span class="cl"><span class="s1"> else
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &gt;&amp;2 echo &#34;Not a symlink: $file&#34;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> exit 1
+</span></span></span><span class="line"><span class="cl"><span class="s1"> fi
+</span></span></span><span class="line"><span class="cl"><span class="s1"> done
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="k">in</span>
+</span></span><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">home</span><span class="o">.</span><span class="n">packages</span> <span class="o">=</span> <span class="p">[</span> <span class="n">realise-symlink</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>The idea of this script is that you can call it against a symlink against Nix
+store and it will realise, e.g.: convert to an &quot;actual&quot; file, e.g.:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ls -lah .zshrc
+</span></span><span class="line"><span class="cl"><span class="go">lrwxrwxrwx 1 thiagoko users 69 Aug 1 00:10 .zshrc -&gt; /nix/store/glz018yyh0qfqc9lywx1yhr7c3l96lv7-home-manager-files/.zshrc
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> realise-symlink .zshrc
+</span></span><span class="line"><span class="cl"><span class="go">removed &#39;.zshrc&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">&#39;/nix/store/glz018yyh0qfqc9lywx1yhr7c3l96lv7-home-manager-files/.zshrc&#39; -&gt; &#39;.zshrc&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;.zshrc&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> ls -lah .zshrc
+</span></span><span class="line"><span class="cl"><span class="go">-rw-r--r-- 1 thiagoko users 5.8K Aug 1 00:16 .zshrc
+</span></span></span></code></pre><p>It also add write permissions to the resulting file, to make it easier to edit.
+By the way, it also works with directories:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ls -lah zim-completion
+</span></span><span class="line"><span class="cl"><span class="go">lrwxrwxrwx 1 thiagoko users 90 Aug 1 00:10 zim-completion -&gt; /nix/store/glz018yyh0qfqc9lywx1yhr7c3l96lv7-home-manager-files/.zsh/plugins/zim-completion
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> realise-symlink zim-completion
+</span></span><span class="line"><span class="cl"><span class="go">&#39;zim-completion/init.zsh&#39; -&gt; &#39;zim-completion.tmp/init.zsh&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">&#39;zim-completion/init.zsh.zwc&#39; -&gt; &#39;zim-completion.tmp/init.zsh.zwc&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">&#39;zim-completion/LICENSE&#39; -&gt; &#39;zim-completion.tmp/LICENSE&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">&#39;zim-completion/README.md&#39; -&gt; &#39;zim-completion.tmp/README.md&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;zim-completion/init.zsh&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;zim-completion/init.zsh.zwc&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;zim-completion/LICENSE&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;zim-completion/README.md&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span><span class="line"><span class="cl"><span class="go"></span><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> ls -lah zim-completion
+</span></span><span class="line"><span class="cl"><span class="go">total 28K
+</span></span></span><span class="line"><span class="cl"><span class="go">drwxr-xr-x 1 thiagoko users 72 Aug 1 00:18 .
+</span></span></span><span class="line"><span class="cl"><span class="go">drwxr-xr-x 1 thiagoko users 130 Aug 1 00:18 ..
+</span></span></span><span class="line"><span class="cl"><span class="go">-rw-r--r-- 1 thiagoko users 5.3K Aug 1 00:18 init.zsh
+</span></span></span><span class="line"><span class="cl"><span class="go">-rw-r--r-- 1 thiagoko users 12K Aug 1 00:18 init.zsh.zwc
+</span></span></span><span class="line"><span class="cl"><span class="go">-rw-r--r-- 1 thiagoko users 1.3K Aug 1 00:18 LICENSE
+</span></span></span><span class="line"><span class="cl"><span class="go">-rw-r--r-- 1 thiagoko users 2.2K Aug 1 00:18 README.md
+</span></span></span></code></pre><p>After you finish whatever you are testing, to return to your configuration you
+can just delete those files and re-run your Home-Manager activation:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> rm -rf .zshrc
+</span></span><span class="line"><span class="cl"><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> sudo systemctl restart home-manager-&lt;user&gt;.service <span class="c1"># or `home-manager switch`</span>
+</span></span><span class="line"><span class="cl"><span class="err">
+</span></span></span><span class="line"><span class="cl"><span class="err"></span><span class="gp">$</span> ls -lah .zshrc
+</span></span><span class="line"><span class="cl"><span class="go">lrwxrwxrwx 1 thiagoko users 69 Aug 1 00:20 .zshrc -&gt; /nix/store/glz018yyh0qfqc9lywx1yhr7c3l96lv7-home-manager-files/.zshrc
+</span></span></span></code></pre><p>It even works with system files (i.e.: NixOS):</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> sudo realise-symlink /etc/nix/nix.conf
+</span></span><span class="line"><span class="cl"><span class="go">[sudo] password for thiagoko:
+</span></span></span><span class="line"><span class="cl"><span class="go">removed &#39;nix.conf&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">&#39;/etc/static/nix/nix.conf&#39; -&gt; &#39;nix.conf&#39;
+</span></span></span><span class="line"><span class="cl"><span class="go">mode of &#39;nix.conf&#39; changed from 0444 (r--r--r--) to 0644 (rw-r--r--)
+</span></span></span></code></pre><p>But I never needed for this case since it is more rare to me to experiment with
+OS level configuration.</p></description><pubDate>Thu, 01 Aug 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/quick-bits-realise-nix-symlinks/</guid></item><item><title>Generating YAML files with Nix</title><link>https://kokada.dev/blog/generating-yaml-files-with-nix/</link><description><p>I hate YAML. Instead of writing an essay on why I hate YAML, I can just link to
+<a href="https://noyaml.com/">noyaml.com</a>. In my personal projects I will never use it,
+preferring either JSON, <a href="https://toml.io/en/">TOML</a> or even plain old
+<a href="https://en.wikipedia.org/wiki/INI_file">INI</a> files depending on the use case.
+However the ship has sailed already, there are tons of projects everywhere that
+uses YAML: from most CI systems (<a href="https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions">GitHub
+Actions</a>,
+<a href="https://circleci.com/docs/introduction-to-yaml-configurations/">CircleCI</a>,
+<a href="https://docs.travis-ci.com/user/build-config-yaml">Travis</a>, <em>et tu</em>
+<a href="https://man.sr.ht/builds.sr.ht/">builds.sr.ht</a>), to
+<a href="https://kubernetes.io/docs/concepts/overview/working-with-objects/">Kubernetes</a>,
+or in almost every
+<a href="https://guides.rubyonrails.org/configuring.html#configuring-a-database">Rails</a>
+application.</p>
+<p>One way to avoid at least some issues with the language is to write YAML in
+another language. I will show my solution in one of my <a href="https://github.com/thiagokokada/nix-configs/">personal
+repositories</a>, writing Nix to
+generate GitHub Actions configuration files. Bonus points for validating the
+result against the schema of GitHub Actions, so the famous &quot;this is supposed to
+be string instead of a list of strings&quot; is gone.</p>
+<p>Let's start with the basics: YAML is supposed to be a <a href="https://stackoverflow.com/a/1729545">superset of
+JSON</a>. What that means is that a JSON file
+<a href="https://yaml.org/spec/1.2-old/spec.html#id2759572">can be parsed</a> by a YAML
+parser. And Nix itself generates JSON natively, after all, Nix can be imagined
+as <a href="https://nix.dev/tutorials/nix-language.html">&quot;JSON with functions&quot;</a>.</p>
+<p>To make things easier, I will assume that you have the <code>nix-commands</code> and
+<code>flakes</code> enabled as <code>experimental-features</code> in your Nix configuration. If not,
+go <a href="https://wiki.nixos.org/wiki/Flakes">here</a>.</p>
+<p>Using the <code>nix eval</code> command, we can generate a JSON expression from Nix by:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix <span class="nb">eval</span> --expr <span class="s1">&#39;{ foo = &#34;bar&#34;; }&#39;</span> --json
+</span></span><span class="line"><span class="cl"><span class="go">{&#34;foo&#34;:&#34;bar&#34;}
+</span></span></span></code></pre><p>However, typing long excerpts of Nix code inside the console would be
+impractical. We can write the following code inside a <code>foo.nix</code> file instead:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">foo</span> <span class="o">=</span> <span class="s2">&#34;bar&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>And:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix <span class="nb">eval</span> --file foo.nix --json
+</span></span><span class="line"><span class="cl"><span class="go">{&#34;foo&#34;:&#34;bar&#34;}
+</span></span></span></code></pre><p>While you can use a JSON output as an input for YAML parsers, it is probably
+not the <a href="https://metacpan.org/pod/JSON::XS#JSON-and-YAML">best idea</a>. Sadly (or
+maybe not), Nix has no native functionality to export data to YAML. However,
+since we are using Nix, it is trivial to use <code>nixpkgs</code> to use some program to
+convert from JSON to YAML.</p>
+<p>To start, let's create a new directory, move our <code>foo.nix</code> file to it, create a
+new <code>flake.nix</code> file and put the following contents:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">description</span> <span class="o">=</span> <span class="s2">&#34;Generate YAML files with Nix&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">inputs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">url</span> <span class="o">=</span> <span class="s2">&#34;github:NixOS/nixpkgs/nixos-unstable&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">outputs</span> <span class="o">=</span> <span class="p">{</span> <span class="n">nixpkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">packages</span><span class="o">.</span><span class="n">x86_64-linux</span> <span class="o">=</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="k">inherit</span> <span class="p">(</span><span class="n">nixpkgs</span><span class="p">)</span> <span class="n">lib</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="n">nixpkgs</span> <span class="p">{</span> <span class="n">system</span> <span class="o">=</span> <span class="s2">&#34;x86_64-linux&#34;</span><span class="p">;</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">toYAML</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">runCommand</span> <span class="s2">&#34;toYAML&#34;</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">buildInputs</span> <span class="o">=</span> <span class="k">with</span> <span class="n">pkgs</span><span class="p">;</span> <span class="p">[</span> <span class="n">yj</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="n">json</span> <span class="o">=</span> <span class="nb">builtins</span><span class="o">.</span><span class="n">toJSON</span> <span class="p">(</span><span class="kn">import</span> <span class="sr">./go.nix</span><span class="p">);</span>
+</span></span><span class="line"><span class="cl"> <span class="n">passAsFile</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;json&#34;</span> <span class="p">];</span> <span class="c1"># will be available as `$jsonPath`</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> mkdir -p $out
+</span></span></span><span class="line"><span class="cl"><span class="s1"> yj -jy &lt; &#34;$jsonPath&#34; &gt; $out/go.yaml
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>We are loading the <code>./foo.nix</code> as a Nix file, converting it to JSON with
+<code>builtins.toJSON</code> function, and finally, using <code>pkgs.runCommand</code> and its
+<code>passAsFile</code> option to load the contents of the JSON file into
+<a href="https://github.com/sclevine/yj">yj</a>, that converts between serialisation
+formats (<code>-jy</code> flag means &quot;JSON to YAML&quot;). The reason I choose <code>yj</code> is mostly
+because it is a single binary Go program, but you can use whatever you prefer.</p>
+<p>By the way, there is a
+<a href="https://github.com/NixOS/nixpkgs/blob/9f918d616c5321ad374ae6cb5ea89c9e04bf3e58/lib/generators.nix#L805"><code>lib.generators.toYAML</code></a>
+inside <code>nixpkgs.lib</code>, but as of the day of this post it only calls
+<code>lib.strings.toJSON</code> (that in turn, calls <code>builtins.toJSON</code>). So it doesn't
+really help here. Another option would be <code>pkgs.formats.yaml.generate</code>, that
+converts between formats, but it calls
+<a href="https://github.com/NixOS/nixpkgs/blob/008ceae1a2b47a84d7aa01e55f8468272c70b9ee/pkgs/pkgs-lib/formats.nix#L77-L84"><code>remarshal</code></a>
+(in Python), so not my favorite choice.</p>
+<p>If we run the following commands, we can see the result:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> nix build .#packages.x86_64-linux.toYAML
+</span></span><span class="line"><span class="cl"><span class="gp">$</span> cat result/foo.yaml
+</span></span><span class="line"><span class="cl"><span class="go">foo: bar
+</span></span></span></code></pre><p>That is the basic idea. To have a more realistic example, let's convert the
+<a href="https://github.com/thiagokokada/blog/blob/4e3f25485c6682f3e066b219df2290934bc0d256/.github/workflows/go.yml"><code>go.yml</code></a>,
+that builds this blog, to Nix:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;Go&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">on</span><span class="o">.</span><span class="n">push</span><span class="o">.</span><span class="n">branches</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;main&#34;</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">jobs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">build</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">runs-on</span> <span class="o">=</span> <span class="s2">&#34;ubuntu-latest&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">permissions</span><span class="o">.</span><span class="n">contents</span> <span class="o">=</span> <span class="s2">&#34;write&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">steps</span> <span class="o">=</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span> <span class="n">uses</span> <span class="o">=</span> <span class="s2">&#34;actions/checkout@v4&#34;</span><span class="p">;</span> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;Set up Go&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">uses</span> <span class="o">=</span> <span class="s2">&#34;actions/checkout@v4&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;with&#34;</span><span class="o">.</span><span class="n">go-version</span> <span class="o">=</span> <span class="s2">&#34;1.21&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;Update&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">run</span> <span class="o">=</span> <span class="s2">&#34;make&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;Publish&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">run</span> <span class="o">=</span> <span class="s2">&#34;make publish&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">env</span><span class="o">.</span><span class="n">MATAROA_TOKEN</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span><span class="se">&#39;&#39;$</span><span class="s1">{{ secrets.MATAROA_TOKEN }}&#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;Commit&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">uses</span> <span class="o">=</span> <span class="s2">&#34;stefanzweifel/git-auto-commit-action@v5&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;with&#34;</span><span class="o">.</span><span class="n">commit_message</span> <span class="o">=</span> <span class="s2">&#34;README/rss:update&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>Some interesting things to highlight: <code>with</code> is a reserved word in Nix, so we
+need to quote it. Not a problem, but something to be aware. And the template
+string in GitHub Actions uses the same <code>${}</code> that Nix uses, so we need to
+escape.</p>
+<p>And after running the following commands:</p>
+<pre><code>$ nix build .#packages.x86_64-linux.toYAML
+$ cat result/go.yaml
+jobs:
+ build:
+ permissions:
+ contents: write
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set up Go
+ uses: actions/checkout@v4
+ with:
+ go-version: &quot;1.21&quot;
+ - name: Update
+ run: make
+ - env:
+ MATAROA_TOKEN: ${{ secrets.MATAROA_TOKEN }}
+ name: Publish
+ run: make publish
+ - name: Commit
+ uses: stefanzweifel/git-auto-commit-action@v5
+ with:
+ commit_message: README/rss:update
+name: Go
+&quot;on&quot;:
+ push:
+ branches:
+ - main
+</code></pre>
+<p>Yes, the keys are not in the same order as we defined, since Nix, like most
+programming languages (with the exception of
+<a href="https://mail.python.org/pipermail/python-dev/2017-December/151283.html">Python</a>),
+do not guarantee the insertion order in maps/dicts/attrsets/whatever. But I
+really hope whatever is consuming your YAML is not relying in the order the
+keys are defined (this would be more cursed than YAML already is).</p>
+<p>So that is basically it. For the bonus points that I talked at the start of the
+post, we can modify <code>pkgs.runCommand</code> to run some kind of validator. I use
+<a href="https://github.com/mpalmer/action-validator"><code>action-validator</code></a>, one that I
+particularly packaged in
+<a href="https://github.com/NixOS/nixpkgs/pull/260217">nixpkgs</a> to use in those cases.
+But you could use e.g.: a validator of Kubernetes YAML. Or a generic YAML lint
+like this <a href="https://github.com/adrienverge/yamllint">one</a>. The possibilities are
+endless.</p>
+<p>Let's modify our <code>flake.nix</code> to add the validation:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># ...</span>
+</span></span><span class="line"><span class="cl"> <span class="n">outputs</span> <span class="o">=</span> <span class="p">{</span> <span class="n">nixpkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">packages</span><span class="o">.</span><span class="n">x86_64-linux</span> <span class="o">=</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="k">inherit</span> <span class="p">(</span><span class="n">nixpkgs</span><span class="p">)</span> <span class="n">lib</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="n">nixpkgs</span> <span class="p">{</span> <span class="n">system</span> <span class="o">=</span> <span class="s2">&#34;x86_64-linux&#34;</span><span class="p">;</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">toYAML</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">runCommand</span> <span class="s2">&#34;toYAML&#34;</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">buildInputs</span> <span class="o">=</span> <span class="k">with</span> <span class="n">pkgs</span><span class="p">;</span> <span class="p">[</span> <span class="n">action-validator</span> <span class="n">yj</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="n">json</span> <span class="o">=</span> <span class="nb">builtins</span><span class="o">.</span><span class="n">toJSON</span> <span class="p">(</span><span class="kn">import</span> <span class="sr">./go.nix</span><span class="p">);</span>
+</span></span><span class="line"><span class="cl"> <span class="n">passAsFile</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&#34;json&#34;</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> mkdir -p $out
+</span></span></span><span class="line"><span class="cl"><span class="s1"> yj -jy &lt; &#34;$jsonPath&#34; &gt; $out/go.yaml
+</span></span></span><span class="line"><span class="cl"><span class="s1"> action-validator -v $out/go.yaml
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>And let's add an error in our <code>go.nix</code> file:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gh">diff --git a/go.nix b/go.nix
+</span></span></span><span class="line"><span class="cl"><span class="gh">index 25e0596..8c00033 100644
+</span></span></span><span class="line"><span class="cl"><span class="gh"></span><span class="gd">--- a/go.nix
+</span></span></span><span class="line"><span class="cl"><span class="gd"></span><span class="gi">+++ b/go.nix
+</span></span></span><span class="line"><span class="cl"><span class="gi"></span><span class="gu">@@ -5,7 +5,7 @@
+</span></span></span><span class="line"><span class="cl"><span class="gu"></span> jobs = {
+</span></span><span class="line"><span class="cl"> build = {
+</span></span><span class="line"><span class="cl"> runs-on = &#34;ubuntu-latest&#34;;
+</span></span><span class="line"><span class="cl"><span class="gd">- permissions.contents = &#34;write&#34;;
+</span></span></span><span class="line"><span class="cl"><span class="gd"></span><span class="gi">+ permissions.contents = [ &#34;write&#34; ];
+</span></span></span><span class="line"><span class="cl"><span class="gi"></span> steps = [
+</span></span><span class="line"><span class="cl"> { uses = &#34;actions/checkout@v4&#34;; }
+</span></span><span class="line"><span class="cl"> {
+</span></span></code></pre><p>Finally, let's try to build our YAML file again:</p>
+<pre><code>$ nix build .#packages.x86_64-linux.toYAML
+error: builder for '/nix/store/j8wr6j1pvyf986sf74hqw8k31lvlzac5-toYAML.drv' failed with exit code 1;
+ last 25 log lines:
+ &gt; &quot;Additional property 'runs-on' is not allowed&quot;,
+ &gt; ),
+ &gt; path: &quot;/jobs/build&quot;,
+ &gt; title: &quot;Property conditions are not met&quot;,
+ &gt; },
+ &gt; Properties {
+ &gt; code: &quot;properties&quot;,
+ &gt; detail: Some(
+ &gt; &quot;Additional property 'steps' is not allowed&quot;,
+ &gt; ),
+ &gt; path: &quot;/jobs/build&quot;,
+ &gt; title: &quot;Property conditions are not met&quot;,
+ &gt; },
+ &gt; Required {
+ &gt; code: &quot;required&quot;,
+ &gt; detail: None,
+ &gt; path: &quot;/jobs/build/uses&quot;,
+ &gt; title: &quot;This property is required&quot;,
+ &gt; },
+ &gt; ],
+ &gt; },
+ &gt; ],
+ &gt; },
+ &gt; ],
+ &gt; }
+ For full logs, run 'nix log /nix/store/j8wr6j1pvyf986sf74hqw8k31lvlzac5-toYAML.drv'.
+</code></pre>
+<p>Yes, the output of <code>action-validator</code> is awfully verbose, but it is still
+better than making <a href="https://x.com/eric_sink/status/1430954572848287744">&quot;8 commits/push in one
+hour&quot;</a>.</p>
+<p>If you are interested in how a more advantage usage of this technique is,
+including usage of functions and constants to share common steps between
+different actions, please take a look at the
+<a href="https://github.com/thiagokokada/nix-configs/tree/master/actions">actions</a>
+(<a href="https://github.com/thiagokokada/nix-configs/tree/fbbc8f935cc7f774f691196e1612bbf7dd2054b5/actions">permalink</a>)
+in my <code>nix-config</code> repository.</p></description><pubDate>Wed, 31 Jul 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/generating-yaml-files-with-nix/</guid></item><item><title>First impressions: FPGBC</title><link>https://kokada.dev/blog/first-impressions-fpgbc/</link><description><p>Here is something for nostalgia: I just put together a <a href="https://en.wikipedia.org/wiki/Game_Boy_Color">Game Boy
+Color</a> made of completely new
+parts for a friend: here is the
+<a href="https://funnyplaying.com/products/fpgbc-kit">FPGBC</a>.</p>
+<p>The <em>FP</em> part of the name comes from
+<a href="https://en.wikipedia.org/wiki/Field-programmable_gate_array">FPGA</a>, because
+instead of software emulation this device use FPGA to reproduce the device.
+While I am not convinced that FPGA is necessary more accurate than a good
+software emulator, one advantage of FPGA is the (possible) lower input latency
+thanks to the avoidance of complexity to handle the user input (e.g.: the
+Operational System). A quick playthrough against <a href="https://en.wikipedia.org/wiki/Motocross_Maniacs">Motocross
+Maniacs</a> seems to be fine, but
+I can't see much difference from my <a href="https://retrogamecorps.com/2022/05/15/miyoo-mini-v2-guide/">Miyoo
+Mini+</a> (I will do
+more comparisons between the two devices later), that is a software emulation
+device.</p>
+<p>But I think focusing in accuracy is wrong, the main reason of getting a device
+like this one is for nostalgia, and this definitely hit the mark. The quality
+of the case is as good as I remember the original, and most of the details are
+replicate perfectly, including reproduction stickers in the back of the device.
+The only differences that I can find is the usage of USB-C port for charging in
+place of the barrel jack power adapter (thanks!), and the fact that the screen
+bezels are smaller compared to the original (because the screen is bigger) and
+doesn't include the Game Boy Color logo (that is fine in my opinion, since it
+would look weird in the fine bezels). It even has a supposedly working <a href="https://en.wikipedia.org/wiki/Game_Link_Cable">Link
+Cable</a> (I don't have another
+Game Boy to test). Sadly it is missing the infrared sensor, but the usage of
+that was pretty limited anyway.</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_175245569.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_175245569.jpg" alt="FPGBC running Tetris."></a></p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_175131157.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_175131157.jpg" alt="Back of FPGBC. It includes even reproduction stickers of the original."></a></p>
+<p>So how well does it work? I can't say for sure. I don't have any original games
+with me, so I am relying in backups and a
+<a href="https://en.wikipedia.org/wiki/Flashcard">flashcard</a> for now. Many games that I
+tested works fine, a few of them have graphical issues that can be fixed in the
+menu (more about it later), and some of them doesn't boot. But I don't know if
+the issue with the games not booting are because of the roms, the flashcard or
+the device itself.</p>
+<p>By the way, the flashcard I am using is a cheap knockoff of an <a href="https://gbatemp.net/review/everdrive-gb.141/">Everdrive
+GB</a>. This FPGBC came with
+firmware v1.09, while there is an update available for v1.10 in the
+<a href="https://funnyplaying.com/products/fpgbc-kit">website</a>. I had an weird issue in
+the new firmware where no games would boot with this knockoff Everdrive so I
+had to go back to v1.09, but again, I am not sure if the issue was fact that I
+am using a knockoff device or this would happen with an original Everdrive GB.
+If you are going to buy a proper Everdrive, you probably wouldn't get a
+Everdrive GB anyway since it is discontinued, and it seems the <a href="https://www.reddit.com/r/Gameboy/comments/1atwjh3/fpgbc_everdrive_compatibility/">newer
+versions</a>
+have better compatibility with FPGBC.</p>
+<p>Sadly that the update didn't work, since there is this
+<a href="https://github.com/makhowastaken/GWGBC_FW">repository</a> that patches the
+firmware to boot the original logo instead of the ugly FPGBC one. And yes, for
+some reason the v1.09 firmware from this repository still doesn't work with my
+knockoff Everdrive.</p>
+<p>By the way, it seems the device is not easy to brick: I borked the firmware
+update process once while trying to downgrade back to v1.09, resulting in a
+black screen when I turned on the console. But just connecting the device to
+the computer and powering on, I could flash the firmware again and the device
+came back to life.</p>
+<p>About the features of the device: if you press the volume button (yes, you can
+press it now), it opens the following menu:</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_210604830.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_210604830.jpg" alt="FPGBC menu."></a></p>
+<p>The first 2 options are the LCD backlight (<code>BKLT</code>) and volume (<code>VOL</code>). I didn't talk about
+those, but the LCD screen seems to be IPS, and the quality is really good, and
+also looks bright enough to play even under bad lightining conditions. And the
+speaker has good quality, the sound is better than I remember, but sadly the
+maximum volume is kind low. Still should be enough for playing in a quiet room.</p>
+<p><code>DISPMOD</code> is probably the most controversial option: it allow you to set which
+scale you want. Anything with <code>EMU</code> at the end means emulating the original
+colors, and as far I remember it gets really close. You can also chose betwen
+<code>X4</code>, <code>X4P</code> and <code>FUL</code>, the last one is the one shown in the photos where the
+image fills the whole screen at the cost of non-integer scaling. <code>X4</code> is
+integer scaling, however the image doesn't fill the whole screen. The <code>X4P</code>
+also includes a pixel effect that makes the image closer than the original
+screen. It actually looks good, but the fact that I chose a white border for
+this FPGBC makes the border really distracting. Maybe the black one is a better
+choice if you want integer scale.</p>
+<p><code>CORE</code> is simple: you can choose between <code>GB</code> (Game Boy) or <code>GBC</code> (Game Boy
+Color). For those who don't know, you can run Game Boy games in Game Boy Color
+and they will be automatically colorised. Some people don't like this and
+prefer the colors of <code>GB</code>, so you have this option. The <code>GB_PALETTE</code> allows you
+to chose the color in GB mode, for example, the green-ish colors from the
+original Game Boy or the blue-ish colors from <a href="https://nintendo.fandom.com/wiki/Game_Boy_Light">Game Boy
+Light</a>. And yes, you can
+choose the color palette for Game Boy games running in <code>GBC</code> mode by pressing a
+<a href="https://gbstudiocentral.com/tips/game-boy-color-modes/">button combination</a> at
+the boot screen, but it seems not working in my unit and again, not sure if the
+fault is my knockoff Everdrive.</p>
+<p><code>FRAME_MIX</code> basically is an option that makes some effects, like transparency
+in <a href="https://en.wikipedia.org/wiki/Wave_Race">Wave Race</a>, to work at the cost of
+introducing blurriness. The reason for this is that those effects depends in
+the fact that the Game Boy screen was slow refresh, so you could rely on it by
+rapidly changing pixels to create some interesting effects, but sadly those
+effects doesn't work well in modern displays.</p>
+<p><code>GB_CLRFIX</code> is the option I mentioned before, where some Game Boy games just
+get completely wrong colors for some reason, e.g.: <a href="https://en.wikipedia.org/wiki/The_Addams_Family_(video_game)">The Addams
+Family</a>. Turning
+on fixes those games, but I am not sure if this option breaks other games.</p>
+<p>Finally, <code>SPD</code> allows you to increase or decrease the CPU clock, slowing or
+speeding up the games (including the sound). The result can be hilarious, so I
+think this is a nice addition to the features. Sadly you can't know what the
+default speed is, so you need to rely on sound to adjust back to the default.</p>
+<p>So in the end, can I recommend a FPGBC? I am not sure. If you want a device to
+play games, I still think something like a Miyoo Mini+ is a better choice. Not
+only you will have access to more games from different platforms, you also
+don't need to rely on flashcards or cartridges. Also it has way more features
+than FPGBC, like wireless multiplayer,
+<a href="https://retroachievements.org/">RetroArchivements</a> and save states.</p>
+<p>But the actual reason to get a FPGBC is nostalgia, and for that I think the
+FPGBC is difficult to beat. The price of the <a href="https://funnyplaying.com/products/fpgbc-kit">kit to
+assemble</a> ($69.90) is cheaper than
+most Game Boy's in good condition you can find in eBay, and you get for that
+price a rechargable battery, an amazing quality screen, the PCB and the
+speaker. You need to buy separately the case and the buttons, but in total you
+will still end up paying less, and allows you to fully customise your build.
+And the result device is not only in mint condition, it is really convenient
+too: recharging batteries (via USB-C even) is much more convenient than buying
+AA batteries, and the screen not only is better but it even has backlight. You
+can also buy a fully built console for
+<a href="https://funnyplaying.com/products/fpgbc-console">$99.00</a>, but you have less
+options of customisation.</p>
+<p>This is the classic case of do what I say, don't do what I do. This FPGBC is a
+gift, and I will buy another one soon. Can't wait to play <a href="https://en.wikipedia.org/wiki/Pok%C3%A9mon_Gold_and_Silver">Pokémon
+Gold</a> in (almost)
+original hardware again.</p>
+<p><a href="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_123847458.jpg"><img src="https://github.com/thiagokokada/blog/raw/main/posts/2024-07-30/PXL_20240729_123847458.jpg" alt="The kit before assemble."></a></p></description><pubDate>Tue, 30 Jul 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/first-impressions-fpgbc/</guid></item><item><title>Quick bits: why you should automate everything</title><link>https://kokada.dev/blog/quick-bits-why-you-should-automate-everything/</link><description><p>If everything works as expected this blog post should appear in <a href="https://kokada.capivaras.dev/">in my
+blog</a> without I ever touching the
+<a href="https://capivaras.dev">capivaras.dev</a> website. I rewrote my <a href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform">previous Python
+script</a> to Go
+(<a href="https://github.com/thiagokokada/blog/blob/3c39e0f7cd58b1af885f69871490b05bf6fc7d99/blog.go">permalink</a>)
+since my attempt to generate proper description to the RSS feed resulted in
+slow startup times (not because of Python, but because of my usage of
+<code>nix-shell</code> since I didn't want to deal with
+<a href="https://docs.python.org/3/library/venv.html">venv</a> or anything to manage my
+Python dependencies).</p>
+<p>My previous workflow of this blog already involved me writing the texts in
+<a href="https://neovim.io/">neovim</a>, copying and pasting the result in the
+<a href="https://capivaras.dev">capivaras.dev</a> website and publishing. This was not
+that bad, except that it seems I have a heavy tendency of editing my posts
+multiple times. Copying and pasting data between neovim and the website became
+tedious, so I decided to give up and automate the whole process.</p>
+<p><a href="https://mataroa.blog/">Mataroa</a> (the blog platform
+<a href="https://capivaras.dev">capivaras.dev</a> run) has a reasonable good
+<a href="https://mataroa.blog/api/docs/">API</a>, and it only took a few hours to get a
+version of publishing working (it would take less if
+<a href="https://www.djangoproject.com/">Django</a>, the framework Mataroa is written, did
+not have a weird behavior with URLs missing a trailing <code>/</code>). An additional few
+lines of
+<a href="https://github.com/thiagokokada/blog/blob/51b20612335c7f4312a51a0f436235b4b701ce8b/.github/workflows/go.yml">YAML</a>
+to make GitHub Actions trigger a pipeline and now I should never have to
+manually update my blog again.</p>
+<p>I could have not done this. I mean, I probably wasted more time writing an
+automation than I actually wasted publishing manually. But the manual process
+is easy to miss, and I already did multiple mistakes publishing in the manual
+method. For example, when writing the Markdown files, each post is written in a
+particular format, where the first header is considered the title, so I need to
+remove it from the contents during publication. But of course, this is easy to
+miss, and I had to fix this multiple times already.</p>
+<p>So yes, I think this is a good lesson on why you should automate everything. It
+is more than just about <a href="https://xkcd.com/1205/">time savings</a>, it is about
+reducing mistakes and even documenting (even if poorly) a process. I mean, the
+code I wrote is not that great, but I can definitely rely on it in the future
+to remember what I need to do. It will be much faster than trying to learn from
+scratch again.</p></description><pubDate>Mon, 29 Jul 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/quick-bits-why-you-should-automate-everything/</guid></item><item><title>Go, a reasonable good language</title><link>https://kokada.dev/blog/go-a-reasonable-good-language/</link><description><p>Go was one of the languages that I always was interested to learn, but never
+got the hang of it. I first got interested in the language when I was in my
+first job, between 2016-2018. At the time the language was a completely
+different beast: no modules, no generics, no easy way to error wrap yet, etc.</p>
+<p>Go forward 2023 (no pun indented), I wrote my <a href="https://github.com/thiagokokada/twenty-twenty-twenty/">first project in
+Go</a>, wrote some scripts
+at <code>$CURRENT_JOB</code> in the language, and now wrote <a href="https://github.com/thiagokokada/hyprland-go/">my first
+library</a> (with an <a href="https://kokada.dev/blog/writing-nixos-tests-for-fun-and-profit">interesting
+way to run
+CI</a>). I am also
+writing more
+<a href="https://github.com/thiagokokada/nix-configs/blob/8c559527ed12e1d4f57a3fc5c72630b956f4c290/home-manager/desktop/wayland/hyprland/hyprtabs/hyprtabs.go">scripts</a>
+in the language, where I would prefer to use Bash or Python before. Heck, even
+this blog is automatically published with a <a href="https://kokada.dev/blog/quick-bits-why-you-should-automate-everything">Go
+script</a>,
+that used to be a <a href="https://kokada.dev/blog/using-github-as-a-bad-blog-platform">Python
+one</a> before. I can
+say that nowadays it is another language in my toolbox, and while it is still a
+love and hate relationship, recently it is more about love and less about hate.</p>
+<p>The points that I love about Go is probably obvious for some, but still
+interesting to talk about anyway. The fact that the language generates static
+binaries by default and have fast compilation times is something that I
+apreciate since I first heard about the language, and now that I am using the
+language frequently, are points thatI appreciate even more. Something about
+getting almost instant feedback after changing a line of code and running <code>go run</code> (even with its quirks) are great for the developer experience. This is the
+main reason why I am using the language more frequently for scripts.</p>
+<p>Then we have the fast startup times. I am kind of sensitive to latency,
+especially of command line utilities that need to answer fast when I expect
+them to be fast (e.g.: <code>foo --help</code>). This is one part where I could have
+issues in Python, especially for more complex programs, but in Go it is rarely
+an issue.</p>
+<p>Modules are also fantastic. It is not without its weirdness (like everything in
+Go ecossystem), but the fact that it is so easy to add and manage dependencies
+in a project using only the <code>go</code> CLI is great. I also like that it generates a
+hash of every dependency, making it reproducible (well, probably not at Nix
+level, but still reproducible).</p>
+<p>Since I started to talk about <code>go</code> CLI, what a great tool! The fact that you
+can manage dependencies, generate documentation, format code, lint, run
+tests/<a href="https://blog.logrocket.com/benchmarking-golang-improve-function-performance/">benchmarks</a>/<a href="https://go.dev/doc/security/fuzz/">fuzzing</a>,
+check code for <a href="https://go.dev/doc/articles/race_detector">races</a> etc., all
+with just the &quot;compiler&quot; for the language is excelent. Still probably one of
+the best developer experiences I know in any programming language.</p>
+<p>I will not even talk about the things that everyone talks about Go, like
+<a href="https://go.dev/doc/effective_go#goroutines">goroutines</a>, because I just don't
+think I can add anything interesting to the topic.</p>
+<p>Now for the parts that I like less, the test part still quirks me that it is
+not based in assertions, but thankfully it is easy to write assertions with
+generics nowadays:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">Equal</span><span class="p">[</span><span class="nx">T</span> <span class="nx">comparable</span><span class="p">](</span><span class="nx">t</span> <span class="o">*</span><span class="nx">testing</span><span class="p">.</span><span class="nx">T</span><span class="p">,</span> <span class="nx">got</span><span class="p">,</span> <span class="nx">want</span> <span class="nx">T</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">t</span><span class="p">.</span><span class="nf">Helper</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">got</span> <span class="o">!=</span> <span class="nx">want</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">t</span><span class="p">.</span><span class="nf">Errorf</span><span class="p">(</span><span class="s">&#34;got: %#v, want: %#v&#34;</span><span class="p">,</span> <span class="nx">got</span><span class="p">,</span> <span class="nx">want</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">GreaterOrEqual</span><span class="p">[</span><span class="nx">T</span> <span class="nx">cmp</span><span class="p">.</span><span class="nx">Ordered</span><span class="p">](</span><span class="nx">t</span> <span class="o">*</span><span class="nx">testing</span><span class="p">.</span><span class="nx">T</span><span class="p">,</span> <span class="nx">actual</span><span class="p">,</span> <span class="nx">expected</span> <span class="nx">T</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">t</span><span class="p">.</span><span class="nf">Helper</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">actual</span> <span class="p">&lt;</span> <span class="nx">expected</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">t</span><span class="p">.</span><span class="nf">Errorf</span><span class="p">(</span><span class="s">&#34;got: %v; want: &gt;=%v&#34;</span><span class="p">,</span> <span class="nx">actual</span><span class="p">,</span> <span class="nx">expected</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// etc...
+</span></span></span></code></pre><p>Just one of those things that I end up re-writing in every project. Yes, I know
+about <a href="https://github.com/stretchr/testify">testify</a> and other assertion
+libraries, but quoting <a href="https://www.youtube.com/watch?v=PAAkCSZUG1c&amp;t=568s">Rob
+Pike</a> here, &quot;a little
+copying is better than a little dependency&quot;. As long the code you write is
+trivial, it is better to duplicate the code than try to import a dependency.</p>
+<p>About another piece of code that generics allows me to write and I always end
+up re-writing in every project is the <code>must*</code> family of functions:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">must</span><span class="p">(</span><span class="nx">err</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">must1</span><span class="p">[</span><span class="nx">T</span> <span class="nx">any</span><span class="p">](</span><span class="nx">v</span> <span class="nx">T</span><span class="p">,</span> <span class="nx">err</span> <span class="kt">error</span><span class="p">)</span> <span class="nx">T</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nf">must</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">v</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="kd">func</span> <span class="nx">must2</span><span class="p">[</span><span class="nx">T1</span> <span class="nx">any</span><span class="p">,</span> <span class="nx">T2</span> <span class="nx">any</span><span class="p">](</span><span class="nx">v1</span> <span class="nx">T1</span><span class="p">,</span> <span class="nx">v2</span> <span class="nx">T2</span><span class="p">,</span> <span class="nx">err</span> <span class="kt">error</span><span class="p">)</span> <span class="nx">T</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nf">must</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">v1</span><span class="p">,</span> <span class="nx">v2</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// must3, must4, etc...
+</span></span></span></code></pre><p>Those functions are so useful, especially for scripts where I generally don't
+want to handle each error: if I have an error, I want the program to halt and
+print a stack trace (exactly as I would have with a language with exceptions).
+It basically allow me to convert code from:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="nx">contents</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nf">ReadFile</span><span class="p">(</span><span class="s">&#34;file&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>To:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="nx">contents</span> <span class="o">:=</span> <span class="nf">must1</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nf">ReadFile</span><span class="p">(</span><span class="s">&#34;file&#34;</span><span class="p">))</span>
+</span></span></code></pre><p>This brings Go closer to Python to me, and I think for scripts this is
+something great.</p>
+<p>Finally, for the things that I hate, well the biggest one currently is the lack
+of nullability (or in Go terms,
+<a href="https://github.com/golang/go/issues/49202">nillability</a>). After using
+languages that has it, like Kotlin, or even something like
+<a href="https://www.mypy-lang.org/">mypy</a>, this is one of those things that completely
+changes the developer experience. I also still don't like the error handling
+(but <code>must*</code> goes far by improving the situation, when it is possible to use
+it), especially because it is easy to lose context on it:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1">// bad
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="nf">readFileContents</span><span class="p">(</span><span class="nx">file</span><span class="p">)</span> <span class="p">([]</span><span class="kt">byte</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">contents</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nf">ReadFile</span><span class="p">(</span><span class="nx">file</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="kc">nil</span><span class="p">,</span> <span class="nx">err</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">contents</span><span class="p">,</span> <span class="kc">nil</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="c1">// good
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kd">func</span> <span class="nf">readFileContents</span><span class="p">(</span><span class="nx">file</span><span class="p">)</span> <span class="p">([]</span><span class="kt">byte</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="nx">contents</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nf">ReadFile</span><span class="p">(</span><span class="nx">file</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="kc">nil</span><span class="p">,</span> <span class="nx">fmt</span><span class="p">.</span><span class="nf">Errorf</span><span class="p">(</span><span class="s">&#34;readFileContents: error while reading a file: %w&#34;</span><span class="p">,</span> <span class="nx">err</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="nx">contents</span><span class="p">,</span> <span class="kc">nil</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>I also have some grips about the mutate everything approach of the language. I
+prefer immutability by default, but I find that in general as long as you split
+your functions at a reasonable size it is generally fine.</p>
+<p>And for a language that is supposed to be straightforward, it is strange on how
+much magic the language relies on, in the form of things like <a href="https://go.dev/doc/modules/layout"><code>internal</code> and
+<code>main</code></a> packages, name capitalisation to
+indicate visibility (<code>private</code> vs <code>Public</code>), conditional compiling by filenames
+(e.g.: <code>foo_amd64.go</code>, <code>bar_linux.go</code>), magic comments (e.g.: <code>//go:build</code>),
+etc.</p>
+<p>I expect to write more Go code going forward. Not because it is the perfect
+language or whatever, but just because it a is language that has some really
+good qualities that makes the language attractive even with the issues that I
+have. That makes it a reasonable good language, and at least for me this is
+good enough.</p></description><pubDate>Mon, 29 Jul 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/go-a-reasonable-good-language/</guid></item><item><title>Quick bits: nix-shell is cursed</title><link>https://kokada.dev/blog/quick-bits-nix-shell-is-cursed/</link><description><p>The other day I had to run a PHP project in my machine. I have no idea how PHP
+ecosystem work, I just wanted to get it to run.</p>
+<p>The easiest way to get a script to run if you use Nix is to use <code>nix-shell</code>. As
+many of you probably know, you can add <code>nix-shell</code> as a shebang in your scripts
+to run them as <code>./script</code>. This was a PHP script so I wanted to do the same.
+Easy right?</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1">#!/use/bin/env nix-shell
+</span></span></span><span class="line"><span class="cl"><span class="c1">#!nix-shell -i php -p php83
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="o">&lt;?</span><span class="nx">php</span>
+</span></span><span class="line"><span class="cl"><span class="k">declare</span><span class="p">(</span><span class="nx">strict_types</span><span class="o">=</span><span class="mi">1</span><span class="p">);</span>
+</span></span></code></pre><p>And:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ./index.php
+</span></span><span class="line"><span class="cl"><span class="go">Fatal error: strict_types declaration must be the very first statement in the script in index.php on line 4
+</span></span></span></code></pre><p>So it seems that <code>declare(strict_types=1)</code> needs to be the first line in a PHP
+script if used. I removed <code>declare(strict_types=1)</code> and while the script works,
+I don't have enough expertise in PHP to know if this would be safe or not.</p>
+<p>I decided to try something that initially looked really dumb:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="c1">#!/use/bin/env nix-shell
+</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="o">&lt;?</span><span class="nx">php</span>
+</span></span><span class="line"><span class="cl"><span class="k">declare</span><span class="p">(</span><span class="nx">strict_types</span><span class="o">=</span><span class="mi">1</span><span class="p">);</span>
+</span></span><span class="line"><span class="cl"><span class="c1">#!nix-shell -i php -p php83
+</span></span></span></code></pre><p>And:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="gp">$</span> ./index.php
+</span></span><span class="line"><span class="cl"><span class="go">Works
+</span></span></span></code></pre><p>Wat? I mean, it is not dumb if it works, but this at least looks cursed.</p>
+<p>Eventually I found this
+<a href="https://github.com/NixOS/nix/issues/2570#issuecomment-446220517">comment</a> in a
+Nix issue talking about cases where <code>nix-shell</code> shebang doesn't work. It looks
+like the classic case of a <a href="https://github.com/NixOS/nix/issues/2570#issuecomment-446222206">bug that becomes a
+feature</a>.</p>
+<p><em>Update:</em> after posting this in
+<a href="https://lobste.rs/s/gkcgza/quick_bits_nix_shell_is_cursed">Lobte.rs</a>, it seems
+someone decided to open a <a href="https://github.com/NixOS/nix/pull/11202">Pull
+Request</a> to document this behavior.
+Also the equivalent for the new <a href="https://nix.dev/manual/nix/2.23/command-ref/new-cli/nix#shebang-interpreter">nix
+CLI</a>
+explicitly documents this behavior:</p>
+<blockquote>
+<p>Note that the <code>#! nix</code> lines don't need to follow after the first line, to
+accomodate other interpreters.</p>
+</blockquote></description><pubDate>Sat, 27 Jul 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/quick-bits-nix-shell-is-cursed/</guid></item><item><title>Using GitHub as a (bad) blog platform</title><link>https://kokada.dev/blog/using-github-as-a-bad-blog-platform/</link><description><p>I finally started a new blog, thanks to the offer of
+<a href="https://gluer.org/">@ratsclub</a> to give me free access to
+<a href="https://capivaras.dev/">capivaras.dev</a>. But considering how small this blog
+platform is supposed to be, I want to have at least somewhere to have a backup
+of my posts. I know <a href="https://mataroa.blog/">Mataroa</a>, the blog platform that
+<a href="https://capivaras.dev/">capivaras.dev</a> runs, has automatic e-mail backups, but
+I want something more reliable.</p>
+<p>I am writing all my posts in Markdown (the format that <a href="https://1.mataroa.blog/guides/markdown/">Mataroa
+supports</a>) files inside
+<a href="https://neovim.io/">neovim</a> anyway, so why not store all my Markdown files in
+Git? So this is what I did, I now have an unofficial mirror in
+<a href="https://github.com/thiagokokada/blog">GitHub</a>.</p>
+<p>While I am here, why not overcomplicate? Can I make an usable blog platform
+from GitHub? And by that I don't mean GitHub pages, the repository itself. I
+mean, it already renders Markdown files by default, so no need to do anything
+in that space. To reach feature parity with
+<a href="https://capivaras.dev/">capivaras.dev</a>, I only need to have an index and RSS
+(since comments are not supported anyway). No need for newsletter since GitHub
+has a <a href="https://docs.github.com/en/account-and-profile/managing-subscriptions-and-notifications-on-github/managing-subscriptions-for-activity-on-github/viewing-your-subscriptions">watch
+feature</a>
+already.</p>
+<p>After a couple of hours hacking a Python script, you can see the result of this
+monstrosity <a href="https://github.com/thiagokokada/blog">here</a>. The script, called
+<code>gen_blog.py</code>, is available at the same repository (here is a
+<a href="https://github.com/thiagokokada/blog/blob/c8986d1ab1b94c0986fd814629bb8eb4034fb6e7/gen_blog.py">permalink</a>).
+It automatically generates an index at
+<a href="https://github.com/thiagokokada/blog/blob/main/README.md"><code>README.md</code></a> with
+each blog post and a
+<a href="https://raw.githubusercontent.com/thiagokokada/blog/main/rss.xml"><code>rss.xml</code></a>
+file at the root of the repository.</p>
+<p>Instead of trying to explain the code, I am going to explain the general idea,
+because I think that if you want to replicate this idea it is better to rewrite
+it in a way that you understand. It shouldn't take more than 2 hours in any
+decent programming language. But if you really want, the script itself is
+licensed in <a href="https://en.wikipedia.org/wiki/WTFPL">WTFPL</a> license. The code only
+uses Python 3's standard library and should work in any relatively recent
+version (anything newer than 3.9 should work).</p>
+<p>So the idea is basically to organise the repository and the Markdown files in a
+easy way that makes it trivial to parse in a deterministic way. For example, my
+repository is organised in the following way:</p>
+<pre><code>.
+├── 2024-07-26
+│ ├── 01-writing-nixos-tests-for-fun-and-profit.md
+│ └── 02-using-github-as-a-bad-blog-platform.md &lt;- this file
+├── gen_blog.py
+├── README.md
+└── rss.xml
+</code></pre>
+<p>Each day that you write a new blog post will be on its own directory. This is
+nice because Markdown files may include extra files than the posts themselves,
+e.g.: images, and this organisation make it trivial to organise everything.</p>
+<p>Each post has its own Markdown file. I put a two digit number before each post,
+to ensure that when publishing multiple posts at the same day I keep them in
+the same order of publishing. But if you don't care about it, you can just name
+the files whatever you want.</p>
+<p>Also, I am assuming that each Markdown file has a header starting with <code># </code>,
+and that is the title of the blog post.</p>
+<p>Using the above organisation, I have this function that scrapes the repository
+and collect the necessary information to generate the index and RSS files:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">grab_posts</span><span class="p">(</span><span class="n">pwd</span><span class="p">:</span> <span class="n">Path</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="n">posts</span> <span class="o">=</span> <span class="n">defaultdict</span><span class="p">(</span><span class="nb">list</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="nb">dir</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">pwd</span><span class="o">.</span><span class="n">iterdir</span><span class="p">(),</span> <span class="n">reverse</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Ignore non-directories or hidden files</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="ow">not</span> <span class="nb">dir</span><span class="o">.</span><span class="n">is_dir</span><span class="p">()</span> <span class="ow">or</span> <span class="nb">dir</span><span class="o">.</span><span class="n">name</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="s2">&#34;.&#34;</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">continue</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Try to parse date from directory name</span>
+</span></span><span class="line"><span class="cl"> <span class="k">try</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="n">date</span> <span class="o">=</span> <span class="n">datetime</span><span class="o">.</span><span class="n">strptime</span><span class="p">(</span><span class="nb">dir</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="s2">&#34;%Y-%m-</span><span class="si">%d</span><span class="s2">&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;WARN: ignoring non-date directory: </span><span class="si">{</span><span class="nb">dir</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">sys</span><span class="o">.</span><span class="n">stderr</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">continue</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Iterate between the files in the date directory</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="n">post</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="nb">dir</span><span class="o">.</span><span class="n">iterdir</span><span class="p">(),</span> <span class="n">reverse</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Ignore non-markdown files or hidden files (draft)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="ow">not</span> <span class="n">post</span><span class="o">.</span><span class="n">suffix</span> <span class="o">==</span> <span class="s2">&#34;.md&#34;</span> <span class="ow">or</span> <span class="n">post</span><span class="o">.</span><span class="n">name</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="s2">&#34;.&#34;</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="k">continue</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Grab the first H1 section to parse as title</span>
+</span></span><span class="line"><span class="cl"> <span class="n">text</span> <span class="o">=</span> <span class="n">post</span><span class="o">.</span><span class="n">read_text</span><span class="p">()</span>
+</span></span><span class="line"><span class="cl"> <span class="n">mTitle</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="sa">r</span><span class="s2">&#34;# (?P&lt;title&gt;.*)\r?\n&#34;</span><span class="p">,</span> <span class="n">text</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="k">if</span> <span class="n">mTitle</span> <span class="ow">and</span> <span class="p">(</span><span class="n">title</span> <span class="o">:=</span> <span class="n">mTitle</span><span class="o">.</span><span class="n">groupdict</span><span class="p">()</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&#34;title&#34;</span><span class="p">)):</span>
+</span></span><span class="line"><span class="cl"> <span class="n">posts</span><span class="p">[</span><span class="n">date</span><span class="p">]</span><span class="o">.</span><span class="n">append</span><span class="p">({</span><span class="s2">&#34;title&#34;</span><span class="p">:</span> <span class="n">title</span><span class="p">,</span> <span class="s2">&#34;file&#34;</span><span class="p">:</span> <span class="nb">str</span><span class="p">(</span><span class="n">post</span><span class="p">)})</span>
+</span></span><span class="line"><span class="cl"> <span class="k">else</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;WARN: did not find title for file: </span><span class="si">{</span><span class="n">post</span><span class="si">}</span><span class="s2">&#34;</span><span class="p">,</span> <span class="n">file</span><span class="o">=</span><span class="n">sys</span><span class="o">.</span><span class="n">stderr</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">return</span> <span class="n">posts</span>
+</span></span></code></pre><p>Some interesting tidbits: if a Markdown file has a <code>.</code> at the start I assume it
+is a draft post, and ignore it from my scraper. I added a bunch of <code>WARN</code>
+prints to make sure that the me in the future doesn't do anything dumb. Also,
+sorting in reverse since reverse chronological order is the one most people
+expect in blogs (i.e.: more recent blog posts at top).</p>
+<p>After running the function above, I have a resulting dictionary that I can use
+to generate either a <code>README.md</code> file or Markdown:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">gen_readme</span><span class="p">(</span><span class="n">posts</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="n">titles</span> <span class="o">=</span> <span class="p">[]</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="n">date</span><span class="p">,</span> <span class="n">dayPosts</span> <span class="ow">in</span> <span class="n">posts</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="n">post</span> <span class="ow">in</span> <span class="n">dayPosts</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># This creates a relative link to the Markdown file, .e.g.:</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># ./02-using-github-as-a-bad-blog-platform.md</span>
+</span></span><span class="line"><span class="cl"> <span class="n">link</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="s2">&#34;.&#34;</span><span class="p">,</span> <span class="n">post</span><span class="p">[</span><span class="s2">&#34;file&#34;</span><span class="p">])</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># This formats the title, e.g.:</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># - [Using GitHub as a (bad) blog platform](./2024-07-26/02-using-github-as-a-bad-blog-platform.md) - 2024-07-26</span>
+</span></span><span class="line"><span class="cl"> <span class="n">title</span> <span class="o">=</span> <span class="n">date</span><span class="o">.</span><span class="n">strftime</span><span class="p">(</span><span class="sa">f</span><span class="s2">&#34;- [</span><span class="si">{</span><span class="n">post</span><span class="p">[</span><span class="s1">&#39;title&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">](</span><span class="si">{</span><span class="n">link</span><span class="si">}</span><span class="s2">) - %Y-%m-%d&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># This appends to the list to generate the content later</span>
+</span></span><span class="line"><span class="cl"> <span class="n">titles</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">title</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># README_TEMPLATE is a string with the static part of the README</span>
+</span></span><span class="line"><span class="cl"> <span class="nb">print</span><span class="p">(</span><span class="n">README_TEMPLATE</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">posts</span><span class="o">=</span><span class="s2">&#34;</span><span class="se">\n</span><span class="s2">&#34;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">titles</span><span class="p">)))</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">gen_rss</span><span class="p">(</span><span class="n">posts</span><span class="p">):</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># Got most of the specification from here:</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># https://www.w3schools.com/XML/xml_rss.asp</span>
+</span></span><span class="line"><span class="cl"> <span class="n">rss</span> <span class="o">=</span> <span class="n">ET</span><span class="o">.</span><span class="n">Element</span><span class="p">(</span><span class="s2">&#34;rss&#34;</span><span class="p">,</span> <span class="n">version</span><span class="o">=</span><span class="s2">&#34;2.0&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Here are the RSS metadata for the blog itself</span>
+</span></span><span class="line"><span class="cl"> <span class="n">channel</span> <span class="o">=</span> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">rss</span><span class="p">,</span> <span class="s2">&#34;channel&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">channel</span><span class="p">,</span> <span class="s2">&#34;title&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="s2">&#34;kokada&#39;s blog&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">channel</span><span class="p">,</span> <span class="s2">&#34;link&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="s2">&#34;https://github.com/thiagokokada/blog&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">channel</span><span class="p">,</span> <span class="s2">&#34;description&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="s2">&#34;dd if=/dev/urandom of=/dev/brain0&#34;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># You create one item for each blog post</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="n">date</span><span class="p">,</span> <span class="n">dayPost</span> <span class="ow">in</span> <span class="n">posts</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
+</span></span><span class="line"><span class="cl"> <span class="k">for</span> <span class="n">post</span> <span class="ow">in</span> <span class="n">dayPost</span><span class="p">:</span>
+</span></span><span class="line"><span class="cl"> <span class="n">item</span> <span class="o">=</span> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">channel</span><span class="p">,</span> <span class="s2">&#34;item&#34;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="n">link</span> <span class="o">=</span> <span class="n">urljoin</span><span class="p">(</span><span class="n">RSS_POST_LINK_PREFIX</span><span class="p">,</span> <span class="n">post</span><span class="p">[</span><span class="s2">&#34;file&#34;</span><span class="p">])</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="s2">&#34;title&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="n">post</span><span class="p">[</span><span class="s2">&#34;title&#34;</span><span class="p">]</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="s2">&#34;guid&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="n">link</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="s2">&#34;link&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="n">link</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">SubElement</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="s2">&#34;pubDate&#34;</span><span class="p">)</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="n">date</span><span class="o">.</span><span class="n">strftime</span><span class="p">(</span><span class="s1">&#39;</span><span class="si">%a</span><span class="s1">, </span><span class="si">%d</span><span class="s1"> %b %Y %H:%M:%S GMT&#39;</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Generate the XML and indent</span>
+</span></span><span class="line"><span class="cl"> <span class="n">tree</span> <span class="o">=</span> <span class="n">ET</span><span class="o">.</span><span class="n">ElementTree</span><span class="p">(</span><span class="n">rss</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="n">ET</span><span class="o">.</span><span class="n">indent</span><span class="p">(</span><span class="n">tree</span><span class="p">,</span> <span class="n">space</span><span class="o">=</span><span class="s2">&#34;</span><span class="se">\t</span><span class="s2">&#34;</span><span class="p">,</span> <span class="n">level</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
+</span></span><span class="line"><span class="cl"> <span class="n">tree</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s2">&#34;rss.xml&#34;</span><span class="p">,</span> <span class="n">xml_declaration</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;UTF-8&#34;</span><span class="p">)</span>
+</span></span></code></pre><p>To publish a new Post, a basically write a Markdown file, run `./gen_readme.py</p>
+<blockquote>
+<p>README.md` at the root of the repository, and see the magic happen.</p>
+</blockquote>
+<p>It works much better than I initially anticipated. The <code>README.md</code> is properly
+populated with the titles and links. The RSS is kind of empty since it has no
+description, but it seems to work fine (at least in
+<a href="https://www.inoreader.com/">Inoreader</a>, my RSS reader of choice). I can
+probably fill the post description with more information if I really want, but
+it is enough for now (update: it is working now, you just need to render the
+Markdown as HTML and escape the tags;
+<a href="https://github.com/thiagokokada/blog/blob/9506051cc3d49f203304174b335ff62de9d17a05/gen_blog.py">permalink</a>
+for the updated script). Not sure who is that interested in my writing that
+will want to use this RSS feed instead the one available in
+<a href="https://kokada.capivaras.dev/rss/">capivaras.dev</a> anyway.</p>
+<p>Also, while I am using GitHub here, the same idea would work in GitLab, Gitea,
+sr.ht or whatever. As long as your source hub supports Markdown files it should
+work.</p>
+<p>So that is it. I am not saying this is a good idea for your primary blog
+platform or whatever, and I still prefer to publish to a platform that doesn't
+track users or have tons of JavaScript or whatever. But if you want a backup of
+your posts and you are already writing Markdown anyway, well, there are worse
+ways to do it I think.</p>
+<p><em>Update:</em> I rewrote the script again using Go
+(<a href="https://github.com/thiagokokada/blog/blob/3ece3853e7dd32977e7ec5238d2955e530ca4beb/blog.go">permalink</a>).
+The reason for it is because when I started rendering Markdown (for
+descriptions) the Python version got quite slow (not the fault of Python
+itself, mostly because of the usage of <code>nix-shell</code> to manage dependencies;
+something that Go doesn't need). Took about half an hour, showing how easy it
+is to do the same.</p></description><pubDate>Fri, 26 Jul 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/using-github-as-a-bad-blog-platform/</guid></item><item><title>Writing NixOS tests for fun and profit</title><link>https://kokada.dev/blog/writing-nixos-tests-for-fun-and-profit/</link><description><p>I recently started a <a href="https://github.com/thiagokokada/hyprland-go">new side
+project</a> writing an IPC library in
+Go for <a href="https://hyprland.org/">Hyprland</a>, a Window Manager for Wayland.</p>
+<p>Once I got past the Work-in-Progress phase, I realise I had an issue: I wrote
+some tests, but I was running then inside my system running Hyprland. And the
+tests themselves were annoying: since they send commands to the current running
+Hyprland instance, I was having programs being opened and settings being
+changed, because this was the only way to have a reasonable good confidence
+that what I was doing was correct. So I need to do like any good developer and
+implement a CI, but how?</p>
+<p>One approach would be to create something like a mock client and test against
+my mock. Since this mock wouldn't need a running Hyprland instance the tests
+could run everywhere (even in non-Linux systems!), but they wouldn't be much
+useful. Mocks are great for testing business logic, but not really for making
+sure everything is working correctly.</p>
+<p>I need something more akin to an integration test, but this is tricky. It is
+not like I am doing integration with e.g.: PostgreSQL that has thousands of
+libraries available to make integration tests easier, I am doing integration
+with a Window Manager that is a moving target with multiple breaking changes in
+each release. And this is where NixOS tests enter, a way to run tests inside
+Virtual Machines configured in Nix.</p>
+<p>I am a long time NixOS user and commiter, but I never wrote a NixOS test
+outside of <a href="https://github.com/NixOS/nixpkgs">nixpkgs</a> itself. However I knew
+it was possible, and after doing a quick reading of the <a href="https://wiki.nixos.org/wiki/NixOS_VM_tests">Wiki
+entry</a> about it, I was ready to
+start.</p>
+<p>The first part is to call <code>pkgs.testers.runNixOSTest</code> and configure the machine
+as any other NixOS system, e.g.:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span> <span class="n">pkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"><span class="n">pkgs</span><span class="o">.</span><span class="n">testers</span><span class="o">.</span><span class="n">runNixOSTest</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">name</span> <span class="o">=</span> <span class="s2">&#34;hyprland-go&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">nodes</span><span class="o">.</span><span class="n">machine</span> <span class="o">=</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span> <span class="n">config</span><span class="o">,</span> <span class="n">pkgs</span><span class="o">,</span> <span class="n">lib</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># bootloader related configuration</span>
+</span></span><span class="line"><span class="cl"> <span class="n">boot</span><span class="o">.</span><span class="n">loader</span><span class="o">.</span><span class="n">systemd-boot</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">boot</span><span class="o">.</span><span class="n">loader</span><span class="o">.</span><span class="n">efi</span><span class="o">.</span><span class="n">canTouchEfiVariables</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># enable hyprland</span>
+</span></span><span class="line"><span class="cl"> <span class="n">programs</span><span class="o">.</span><span class="n">hyprland</span><span class="o">.</span><span class="n">enable</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># create a user called alice</span>
+</span></span><span class="line"><span class="cl"> <span class="n">users</span><span class="o">.</span><span class="n">users</span><span class="o">.</span><span class="n">alice</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">isNormalUser</span> <span class="o">=</span> <span class="no">true</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># add some extra packages that we need during tests</span>
+</span></span><span class="line"><span class="cl"> <span class="n">environment</span><span class="o">.</span><span class="n">systemPackages</span> <span class="o">=</span> <span class="k">with</span> <span class="n">pkgs</span><span class="p">;</span> <span class="p">[</span> <span class="n">go</span> <span class="n">kitty</span> <span class="p">];</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># auto login as alice</span>
+</span></span><span class="line"><span class="cl"> <span class="n">services</span><span class="o">.</span><span class="n">getty</span><span class="o">.</span><span class="n">autologinUser</span> <span class="o">=</span> <span class="s2">&#34;alice&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># configure VM, increase memory and CPU and enable OpenGL via LLVMPipe</span>
+</span></span><span class="line"><span class="cl"> <span class="n">virtualisation</span><span class="o">.</span><span class="n">qemu</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">options</span> <span class="o">=</span> <span class="p">[</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;-smp 2&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;-m 4G&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;-vga none&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="s2">&#34;-device virtio-gpu-pci&#34;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">];</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="c1"># Start hyprland at login</span>
+</span></span><span class="line"><span class="cl"> <span class="n">programs</span><span class="o">.</span><span class="n">bash</span><span class="o">.</span><span class="n">loginShellInit</span> <span class="o">=</span> <span class="s2">&#34;Hyprland&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">testScript</span> <span class="o">=</span> <span class="s2">&#34;start_all()&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>A few details that I want to bring to attention. The first one is how easy it
+is to setup things like a normal user account, add some extra packages we need
+for testing, add Hyprland itself and configure auto-login. I have no idea how
+painful it would be to automatise all those steps in e.g.: Ansible, but here we
+are in a few lines of Nix code. This is, of course, thanks to all the
+contributors to nixpkgs that implement something that help their own use case,
+but once combined make it greater than the sum of the parts.</p>
+<p>Second is something that I took a while to figure out: how to enable GPU
+acceleration inside the VM. You see, Hyprland, different from other Window
+Managers, requires OpenGL support. This is basically why the flag <code>-device virtio-gpu-pci</code> is in <code>virtualisation.qemu.options</code>, this enables OpenGL
+rendering via LLVMPipe, that while being slow since it is rendered in CPU, is
+sufficient for this case.</p>
+<p>Putting the above code inside a
+<a href="https://wiki.nixos.org/wiki/Flakes"><code>flake.nix</code></a> for reproducibility, I had
+something similar to:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">description</span> <span class="o">=</span> <span class="s2">&#34;Hyprland&#39;s IPC bindings for Go&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">inputs</span> <span class="o">=</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">nixpkgs</span><span class="o">.</span><span class="n">url</span> <span class="o">=</span> <span class="s2">&#34;github:NixOS/nixpkgs/nixos-unstable&#34;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl">
+</span></span><span class="line"><span class="cl"> <span class="n">outputs</span> <span class="o">=</span> <span class="p">{</span> <span class="n">nixpkgs</span><span class="o">,</span> <span class="o">...</span> <span class="p">}:</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">checks</span><span class="o">.</span><span class="n">x86_64-linux</span> <span class="o">=</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">pkgs</span> <span class="o">=</span> <span class="kn">import</span> <span class="n">nixpkgs</span> <span class="p">{</span> <span class="n">system</span> <span class="o">=</span> <span class="s2">&#34;x86_64-linux&#34;</span><span class="p">;</span> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span>
+</span></span><span class="line"><span class="cl"> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">testVm</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">testers</span><span class="o">.</span><span class="n">runNixOSTest</span> <span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="c1"># the code above</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"> <span class="p">}</span>
+</span></span><span class="line"><span class="cl"> <span class="p">};</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>I can now run <code>nix build .#checks.x86_64-linux.testVm -L</code> to build and run the
+VM. However it is not really useful right now, since we didn't add any useful
+code in <code>testScript</code>, the core of the NixOS test framework. We can also run
+<code>nix build .#checks.x86_64-linux.testVm.driverInteractive</code> and
+<code>./result/bin/nixos-test-driver</code>: this will start a Python console where we can
+manually play with the VM (try typing <code>start_all()</code> for example).</p>
+<p>The <code>testScript</code> is a sequence of Python statements that perform various
+actions, such as starting VMs, executing commands in the VMs, and so on. More
+about it in the official
+<a href="https://nixos.org/manual/nixos/stable/index.html#sec-nixos-tests">documentation</a>.
+For our case we can start with something like this:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">testScript</span> <span class="o">=</span> <span class="cm">/* python */</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> start_all()
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> machine.wait_for_unit(&#34;multi-user.target&#34;)
+</span></span></span><span class="line"><span class="cl"><span class="s1"> machine.wait_for_file(&#34;/home/alice/test-finished&#34;)
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>The first statement, <code>start_all()</code>, starts all VMs, in this case we have only
+one, called <code>machine</code>. We send two further commands to <code>machine</code>:
+<code>wait_for_unit(&quot;multi-user.target&quot;)</code> and
+<code>wait_for_file(&quot;/home/alice/test-finished&quot;)</code>.</p>
+<p>The first command waits until systemd's <code>multi-user.target</code> is ready, a good
+way to ensure that the system is ready for further commands. The second one we
+wait for a file called <code>test-finished</code> to appear in Alice's <code>$HOME</code> (basically,
+a canary), but how can we generate this file?</p>
+<p>Remember that we added <code>programs.bash.loginShellInit = &quot;Hyprland&quot;</code>, that
+automatically starts Hyprland when Alice logs in. We need to modify that
+command to run the Go tests from our library. The good thing is that Hyprland
+configuration file supports a
+<a href="https://wiki.hyprland.org/Configuring/Keywords/#executing"><code>exec-once</code></a>
+command that runs a command during Hyprland launch. We can abuse this to launch
+a terminal emulator and run our tests:</p>
+<pre class="chroma"><code><span class="line"><span class="cl"><span class="p">{</span>
+</span></span><span class="line"><span class="cl"> <span class="n">programs</span><span class="o">.</span><span class="n">bash</span><span class="o">.</span><span class="n">loginShellInit</span> <span class="o">=</span>
+</span></span><span class="line"><span class="cl"> <span class="k">let</span>
+</span></span><span class="line"><span class="cl"> <span class="n">testScript</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">writeShellScript</span> <span class="s2">&#34;hyprland-go-test&#34;</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> set -euo pipefail
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> trap &#39;echo $? &gt; $HOME/test-finished&#39; EXIT # creates the canary when the script finishes
+</span></span></span><span class="line"><span class="cl"><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> cd </span><span class="si">${</span><span class="sr">./.</span><span class="si">}</span><span class="s1"> # go to the library directory
+</span></span></span><span class="line"><span class="cl"><span class="s1"> go test -v ./... &gt; $HOME/test.log 2&gt;&amp;1 # run Go tests
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="n">hyprlandConf</span> <span class="o">=</span> <span class="n">pkgs</span><span class="o">.</span><span class="n">writeText</span> <span class="s2">&#34;hyprland.conf&#34;</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> exec-once = kitty sh -c </span><span class="si">${</span><span class="n">testScript</span><span class="si">}</span><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"> <span class="k">in</span> <span class="s1">&#39;&#39;
+</span></span></span><span class="line"><span class="cl"><span class="s1"> Hyprland --config </span><span class="si">${</span><span class="n">hyprlandConf</span><span class="si">}</span><span class="s1">
+</span></span></span><span class="line"><span class="cl"><span class="s1"> &#39;&#39;</span><span class="p">;</span>
+</span></span><span class="line"><span class="cl"><span class="p">}</span>
+</span></span></code></pre><p>So we are basically creating a custom Hyprland config that starts a
+<a href="https://sw.kovidgoyal.net/kitty/">Kitty</a> terminal emulator, that then launches
+a shell script that runs the test. Since we have no way to get the results of
+the test, we pipe the output to a file that we can collect later (e.g.:
+<code>machine.succeded(&quot;cat /home/alice/test.log&quot;)</code>). And once the script exit, we
+create the canary file <code>$HOME/test-finished</code>, that allows the <code>testScript</code>
+knows that the test finished and it can destroy the VM safely.</p>
+<p>If you want to take a look at the final result, it is
+<a href="https://github.com/thiagokokada/hyprland-go/blob/v0.0.1/flake.nix">here</a>. This
+tests run in any Linux machine that supports KVM, and also works in <a href="https://github.com/thiagokokada/hyprland-go/actions/workflows/nix.yaml">GitHub
+Actions</a>
+thanks to the the
+<a href="https://github.com/DeterminateSystems/nix-installer-action">nix-installer-action</a>.</p>
+<p>And now I have a proper CI pipeline in a way that I never imagined would be
+possible, especially considering how simple it was.</p></description><pubDate>Fri, 26 Jul 2024 00:00:00 +0000</pubDate><guid>https://kokada.dev/blog/writing-nixos-tests-for-fun-and-profit/</guid></item></channel></rss>
+\ No newline at end of file