<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>HiPhish&apos;s Workshop: Blog</title><description>Software projects, various thoughts and ramblings</description><link>https://hiphish.github.io/</link><language>en</language><generator>Astro</generator><item><title>GitHub does not have to be your only forge</title><link>https://hiphish.github.io/blog/2026/05/01/github-does-not-have-to-be-our-only-forge/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2026/05/01/github-does-not-have-to-be-our-only-forge/</guid><description>I had moved off GitHub back before it was cool, but recently more and more Free
and Open Source projects have been migrating off GitHub as well, and with how
much of a shitshow the entire service has become I cannot see why anyone would
trust the platform at all anymore.  Actually no, I do know one reason: its user
base. Pretty much everyone is on GitHub.  For all its flaws, GitHub is still
solving this one major social problem.  I am here to give you the good news
that you can get the best of both worlds: move off GitHub and still benefit
from its social inertia.</description><pubDate>Fri, 01 May 2026 00:00:00 GMT</pubDate><category>open-source</category><category>git</category></item><item><title>Separation of content and presentation in Tailwind</title><link>https://hiphish.github.io/blog/2026/04/30/separation-of-content-and-presentation-in-tailwind/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2026/04/30/separation-of-content-and-presentation-in-tailwind/</guid><description>Every Tailwind example I have ever seen uses inline styling by applying
Tailwind utility classes directly to the element.  Even the Tailwind website
advertises this feature.  It was what kept me from trying out Tailwind for
years.  Eventually I decided to at least give it a try, and I found out that
you can indeed separate your presentation from the content with Tailwind.</description><pubDate>Thu, 30 Apr 2026 00:00:00 GMT</pubDate><category>misc</category><category>web</category><category>css</category></item><item><title>Switching to Astro</title><link>https://hiphish.github.io/blog/2026/04/29/switching-to-astro/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2026/04/29/switching-to-astro/</guid><description>I really, really did not want to do this, but I have rewritten this website
again from scratch.  This time I’m going all in on the JavaScript ecosystem:
TypeScript, Tailwind and Astro.  And no, I’m not kidding.</description><pubDate>Wed, 29 Apr 2026 00:00:00 GMT</pubDate><category>organisation</category><category>html</category><category>web</category><category>javascript</category></item><item><title>Stop Killing Games needs more support</title><link>https://hiphish.github.io/blog/2025/07/22/stop-killing-games/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2025/07/22/stop-killing-games/</guid><description>TL;DR: If you are an EU citizen (not merely a resident) you can sign the Stop
Killing Games EU initiative.  This is not your typical open letter, this is a
government-level initiative that will need to be discussed if it passes.  At
the moment we have way more than the required million signatures, but we do not
know how many of these are fraudulent and might get tossed out.  Keep on
signing!  There are less than ten days left, so don’t put if off.  Now for
those who don’t know what any of this means, I’ll do my best to elaborate.</description><pubDate>Tue, 22 Jul 2025 00:00:00 GMT</pubDate><category>misc</category><category>games</category><category>rant</category></item><item><title>Beware of &apos;require&apos; at startup in Neovim plugins</title><link>https://hiphish.github.io/blog/2025/03/24/beware-of-implicit-require-in-neovim-plugins/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2025/03/24/beware-of-implicit-require-in-neovim-plugins/</guid><description>Recently I tagged version 0.9.1 of rainbow-delimiters.nvim.  This update got
rid of one really nasty mistake I had been dragging along from the very
beginning until just recently: every time you started up Neovim a number of
require calls would run even if you never called require a single time
yourself.  In this post I would like to go over how this happened, why it is
bad and how I got rid of it.  Even though I am using rainbow-delimiters as an
example here, everything I am about to say applies to other plugins as well.</description><pubDate>Mon, 24 Mar 2025 00:00:00 GMT</pubDate><category>vim</category><category>neovim</category><category>lua</category></item><item><title>Introducing nvim-busted-shims</title><link>https://hiphish.github.io/blog/2024/09/22/introducing-nvim-busted-shims/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2024/09/22/introducing-nvim-busted-shims/</guid><description>I have written in the past about testing Neovim plugins with busted.  In that
post I outlined how to use a thin command-line wrapper shell script around
Neovim to use Neovim as a Lua interpreter and how to configure busted to use it
as the Lua interpreter to run tests in.  In order to avoid having to copy-paste
that snippet over and over again I have created a standalone repository for the
shim: nvim-busted-shims (GitHub mirror).</description><pubDate>Sun, 22 Sep 2024 00:00:00 GMT</pubDate><category>vim</category><category>testing</category><category>vim</category><category>lua</category></item><item><title>Let&apos;s write FizzBuzz in a functional style for no good reason</title><link>https://hiphish.github.io/blog/2024/08/25/lets-write-fizzbuzz-in-functional-style/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2024/08/25/lets-write-fizzbuzz-in-functional-style/</guid><description>Let’s write yet another FizzBuzz because that’s what the world needs. Here’s
the twist though: ours won’t be like those other fuddy-duddy lame and bloated
enterprise-grade FizzBuzzes.  Oh no, we are ahead of the curve this time,
it’s functional time, baby!  We will be using Python though, because Python and
Javascript is the closest most of us will ever get to using a functional
programming language in production.</description><pubDate>Sun, 25 Aug 2024 00:00:00 GMT</pubDate><category>python</category><category>functional programming</category></item><item><title>Testing Fennel in busted with Lua</title><link>https://hiphish.github.io/blog/2024/08/15/testing-fennel-with-busted-in-lua/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2024/08/15/testing-fennel-with-busted-in-lua/</guid><description>Fennel is a Lisp-like language which compiles down to Lua, so it should be
possible to test Fennel scripts in busted.  Indeed, we can, but there are a
few points to note about testing Fennel code in Lua.</description><pubDate>Thu, 15 Aug 2024 00:00:00 GMT</pubDate><category>vim</category><category>lua</category><category>lisp</category><category>testing</category></item><item><title>Introducing neotest-busted</title><link>https://hiphish.github.io/blog/2024/02/29/introducing-neotest-busted/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2024/02/29/introducing-neotest-busted/</guid><description>The conclusion of the Neovim &amp; Busted testing sage is coming to a close with
this new plugin: neotest-busted (GitHub mirror).  In my previous post I
mentioned that that I wanted to write a Neotest adapter for the busted test
framework, so here it is.</description><pubDate>Thu, 29 Feb 2024 00:00:00 GMT</pubDate><category>vim</category><category>vim</category><category>testing</category></item><item><title>Debugging Lua scripts running in Neovim</title><link>https://hiphish.github.io/blog/2024/02/20/debugging-lua-scripts-running-in-neovim/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2024/02/20/debugging-lua-scripts-running-in-neovim/</guid><description>In a previous blog post I wrote about testing Lua scripts in Neovim using the
busted test framework.  Today I want to look at how to debug Lua scripts in
Neovim using the Debug Adapter Protocol (DAP).  Just as before with busted,
our problem is that we need to use Neovim as our Lua interpreter because we
want to use Neovim’s Lua API.  At the same time, the debug adapter expects the
Lua interpreter to conform to Lua’s command-line interface.  That’s right: we
need another command-line interface adapter.</description><pubDate>Tue, 20 Feb 2024 00:00:00 GMT</pubDate><category>vim</category><category>vim</category><category>lua</category></item><item><title>Writing a ring buffer TDD style</title><link>https://hiphish.github.io/blog/2024/02/15/writing-a-ring-buffer-tdd-style/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2024/02/15/writing-a-ring-buffer-tdd-style/</guid><description>Let’s write a ring buffer in Python!  OK, that’s not particularly exciting.
Let’s use test-drivent development, that should make things a bit more
interesting.  In this blog post I will go over the individual steps and my
train of thought, because TDD requires a certain discipline and mindset. Why a
ring buffer?  A ring buffer is not quite trivial to implement because it has a
couple of edge cases, but at the same time it is not hard to implement either.
This is a post to follow along at home, so grab your text editor and let’s get
going.</description><pubDate>Thu, 15 Feb 2024 00:00:00 GMT</pubDate><category>misc</category><category>python</category></item><item><title>Introducing Yo-Dawg.nvim</title><link>https://hiphish.github.io/blog/2024/02/01/introducing-yo-dawg-nvim/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2024/02/01/introducing-yo-dawg-nvim/</guid><description>Yo dawg, I heard you like Neovim, so I put a Neovim inside your Neovim, so you
can edit while you edit!  Ahem… anyway, in my previous post I proposed a
plugin which would make it easier to control an embedded Neovim from within
Neovim.  So I went ahead and wrote yo-dawg.nvim (GitHub mirror), named
after the “Yo dawg” internet meme.</description><pubDate>Thu, 01 Feb 2024 00:00:00 GMT</pubDate><category>vim</category><category>neovim</category><category>lua</category></item><item><title>Testing Neovim plugins with Busted</title><link>https://hiphish.github.io/blog/2024/01/29/testing-neovim-plugins-with-busted/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2024/01/29/testing-neovim-plugins-with-busted/</guid><description>The most annoying part about writing plugins for Neovim has been the lack of a
good test framework.  There are a couple of frameworks, and Vader has been my
favourite so far, but they all have their downsides.  This made me wonder: why
limit myself to Vim/Neovim test frameworks?  We have a full Lua runtime, and
other people already have solved the testing problem for Lua.  Busted does
90% of what we need, so let’s fill in the remaining 10%.  The following is
based on my experience with adding tests to rainbow-delimiters.nvim.</description><pubDate>Mon, 29 Jan 2024 00:00:00 GMT</pubDate><category>vim</category><category>neovim</category><category>lua</category></item><item><title>Rainbow-delimiters.nvim version 0.3.0 released</title><link>https://hiphish.github.io/blog/2023/12/24/rainbow-delimiters-030-released/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/12/24/rainbow-delimiters-030-released/</guid><description>I have just published version 0.3.0 of rainbow-delimiters.nvim (GitHub
mirror).  This update brings in a number of the usual improvements to to
queries and strategies, but more importantly it also makes configuration at
runtime more flexible, but most importantly in light of the current date it
also includes a fun little Christmas-themed strategy.</description><pubDate>Sun, 24 Dec 2023 00:00:00 GMT</pubDate><category>vim</category><category>vim</category></item><item><title>Big change to rainbow-delimiters.nvim</title><link>https://hiphish.github.io/blog/2023/11/12/big-change-to-rainbow-delimiters-nvim/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/11/12/big-change-to-rainbow-delimiters-nvim/</guid><description>No, not another rewrite.  Much better than that: the long-standing ugliness of
highlighting being limited to only one node at a time has been fixed.
Previously only one opening node and one closing node could be highlighted.
This was perfectly adequate for most languages where you have one opening
parenthesis and one closing parenthesis.  However, consider HTML: we want to
highlight the opening and closing tag, but if we highlight the entire top-level
node we also highlight the attributes of the tag, which looks too vibrant.  The
alternative was highlighting the tag name, but this left the angle brackets
without highlighting, which looked jarring as well.</description><pubDate>Sun, 12 Nov 2023 00:00:00 GMT</pubDate><category>vim</category><category>vim</category></item><item><title>Grayjay is not Open Source</title><link>https://hiphish.github.io/blog/2023/10/18/grayjay-is-not-open-source/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/10/18/grayjay-is-not-open-source/</guid><description>Today FUTO released an application called Grayjay for Android-based mobile
phones.  Louis Rossmann introduced the application in a video (YouTube
link).  Grayjay as an application
is very promising, but there is one point I take issue with: Grayjay is not an
Open Source application.  In the video Louis explains FUTO’s reason behind the
custom license, and while I do agree with their reason, I strong disagree with
their method.  In this post I will explain what Open Source means, how Grayjay
does not meet the criteria, why this is an issue, and how it can be solved.</description><pubDate>Wed, 18 Oct 2023 00:00:00 GMT</pubDate><category>open-source</category><category>rant</category></item><item><title>Free Software is necessary but not sufficient</title><link>https://hiphish.github.io/blog/2023/09/29/free-software-is-necessary-but-not-sufficient/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/09/29/free-software-is-necessary-but-not-sufficient/</guid><description>Recently Unity announced changes to their pricing model (archive) which
have been very poorly received by their users, to put it gently.  They have
since backtracked (archive2) somewhat, but at this point it would not
matter even if they completely scrapped their plans and went back to how things
used to be.  The trust has been broken and many game developers are waking up
to the fact that Unity is effectively holding their project hostage.  Switching
from one engine to another is akin to a full rewrite, and depending on the size
and progress of the project porting might not be a feasible thing to do.</description><pubDate>Fri, 29 Sep 2023 00:00:00 GMT</pubDate><category>open-source</category><category>rant</category><category>unity3d</category></item><item><title>Introducing rainbow-delimiters.nvim</title><link>https://hiphish.github.io/blog/2023/07/13/introducing-rainbow-delimiters-nvim/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/07/13/introducing-rainbow-delimiters-nvim/</guid><description>Wait what, again? Yes, another rainbow delimiter plugin, a fork of a fork. The
previous one nvim-ts-rainbow2 was built as a module for nvim-treesitter
because that is what the original plugin did and what everyone else was doing.
However, nvim-treesitter is deprecating the module system.  This means
nvim-ts-rainbow2 will eventually stop working, so we will need a new rainbow
plugin sooner or later anyway.</description><pubDate>Thu, 13 Jul 2023 00:00:00 GMT</pubDate><category>vim</category><category>vim</category></item><item><title>Free Software is important for non-programmers as well</title><link>https://hiphish.github.io/blog/2023/06/10/free-software-is-important-for-non-progammers-as-well/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/06/10/free-software-is-important-for-non-progammers-as-well/</guid><description>Free Software is software which respects the user’s freedom.  The Four
Freedoms ensure that users can run the program for any purpose, study the
source code, modify the source, share the software and share modifications of
the software.  However, what if you are not a programmer? Does this mean Free
Software only adds value to people who know how to program, and if you are a
non-programmer you might as well use proprietary software?  Is it all just the
same then?  No.  In this post I will try to illustrate why Free Software
matters even to non-programmers.</description><pubDate>Sat, 10 Jun 2023 00:00:00 GMT</pubDate><category>open-source</category><category>rant</category></item><item><title>The game modding scene has a source code problem</title><link>https://hiphish.github.io/blog/2023/05/21/the-game-modding-scene-has-a-source-code-problem/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/05/21/the-game-modding-scene-has-a-source-code-problem/</guid><description>Sometimes I like to play video games.  Sometimes these games have issues, or
they can be improved upon.  Sometimes these issues are so severe that the game
is virtually (or even literally) unplayable.  Fortunately some really smart
people have done a fantastic job reverse-engineering parts of these games,
their file formats, or found workarounds for engine limitations.  Unfortunately
too often that knowledge never gets written down and just keeps rotting in
someone’s head.</description><pubDate>Sun, 21 May 2023 00:00:00 GMT</pubDate><category>misc</category><category>games</category><category>rant</category></item><item><title>I have a GitHub sponsor page now</title><link>https://hiphish.github.io/blog/2023/04/28/i-have-a-github-sponsor-page-now/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/04/28/i-have-a-github-sponsor-page-now/</guid><description>I have decided to open up a GitHub sponsor page.  Recently I released the
Neovim plugin nvim-ts-rainbow2, which has garnered a lot of stars, so I
figured I might as well try this sponsor thing.  There is also a Monero wallet
for those who prefer to forgo the middle-man.</description><pubDate>Fri, 28 Apr 2023 00:00:00 GMT</pubDate><category>organisation</category></item><item><title>Resolution patcher for Anno 1503</title><link>https://hiphish.github.io/blog/2023/04/05/resolution-patcher-for-anno-1503/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/04/05/resolution-patcher-for-anno-1503/</guid><description>I have written a small Python script which patches the game files of Anno 1503
to run at higher resolutions.  There is already a widescreen patch out
there ready to use, so why create a patcher?  Download links die, knowledge
gets forgotten and people lose interest and move on.  Without preservation of
knowledge the patch will be lost and impossible to reproduce without trial and
error all over again.  My patcher exists both to be useful, and as executable
documentation for posterity.  There is also the possibility that if you patch
the DLL file that came with your own game instead of using someone else’s it
might run more stable (not all builds of the game are identical), but that’s
just a blind guess.</description><pubDate>Wed, 05 Apr 2023 00:00:00 GMT</pubDate><category>games</category></item><item><title>Introducing nvim-ts-rainbow2</title><link>https://hiphish.github.io/blog/2023/03/02/introducing-nvim-ts-rainbow2/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/03/02/introducing-nvim-ts-rainbow2/</guid><description>Two months in the making, it is time to finally release my new Neovim plugin
officially: nvim-ts-rainbow2 (GitHub
mirror).  This plugin uses
Neovim’s built-in Tree-sitter support to add alternating highlighting to
delimiters.  This is usually known as “rainbow parentheses”, but thanks to
Tree-sitter we are not limited to parentheses, we can match any kind of
delimiter, such as tags in HTML or begin/end blocks in some programming
languages.</description><pubDate>Thu, 02 Mar 2023 00:00:00 GMT</pubDate><category>vim</category><category>vim</category></item><item><title>How I switch colours in Alacritty</title><link>https://hiphish.github.io/blog/2023/02/26/how-i-switch-colours-in-alacritty/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2023/02/26/how-i-switch-colours-in-alacritty/</guid><description>My current terminal emulator is Alacritty.  One thing I would like is a way
to change the colours while the terminal is running.  The only way to do so is
the edit the configuration file, but doing so by hand can be annoying.  There
are some scripts out there that let you do it automatically, but all that I
have found rely on bloated stuff like having Node.js installed.  We can do
better by using just what we already have on Unix out of the box.</description><pubDate>Sun, 26 Feb 2023 00:00:00 GMT</pubDate><category>open-source</category><category>linux</category><category>terminal</category></item><item><title>Using GitHub without workflow lock-in</title><link>https://hiphish.github.io/blog/2022/12/31/using-github-without-workflow-lockin/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/12/31/using-github-without-workflow-lockin/</guid><description>Git is a decentralized version control system, meaning that there is no one
superior repository.  Every single copy of a Git repository is just as complete
as any other.  Of course we can pick one particular repository and declare it
to be the one source of truth, the “upstream” repository.  Usually this
upstream repository is then hosted on some server, and if we are interested in
openness and collaboration this server is part of a larger web service, called
a “forge”.  Out of these forges GitHub is perhaps the most popular one.
Unfortunately this means if we are interested in contributions we have to make
the GitHub repo our upstream and use its web services and web UI for our
workflow.  At least that is the common wisdom, but it does not have to be that
way.</description><pubDate>Sat, 31 Dec 2022 00:00:00 GMT</pubDate><category>organisation</category><category>rant</category><category>git</category></item><item><title>A file system abstraction for HSSG</title><link>https://hiphish.github.io/blog/2022/12/30/a-filesystem-abstraction-for-hssg/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/12/30/a-filesystem-abstraction-for-hssg/</guid><description>A while ago I announced my new pet project HSSG, the hackable static site
generator.  The final step of generating a web site is writing the actual files
to the file system of the operating system.  So far this has been a messy
affair where information about file paths had to be dragged through the entire
chain from start to finish.  This was ugly, hard to maintain and it muddied the
layers of abstraction.  In this post I will explain how I brought order to HSSG
through a file system abstraction.</description><pubDate>Fri, 30 Dec 2022 00:00:00 GMT</pubDate><category>open-source</category><category>lisp</category><category>html</category><category>web</category></item><item><title>What even is user-friendly?</title><link>https://hiphish.github.io/blog/2022/11/29/what-even-is-user-friendly/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/11/29/what-even-is-user-friendly/</guid><description>The term “user-friendly” gets thrown around often, but what does it even mean
to be “user-friendly”? Clearly we can say that something is more user-friendly
the fewer defects it has. But beyond that? Is a GUI application more
user-friendly than a text-based application? Is a lower learning curve more
user-friendly than a steep learning curve? Is a product which has many features
built-in more user friendly than a barebones product or an extensible product?</description><pubDate>Tue, 29 Nov 2022 00:00:00 GMT</pubDate><category>misc</category><category>rant</category></item><item><title>Introducing nvim-cmp-vlime</title><link>https://hiphish.github.io/blog/2022/11/22/introducing-nvim-cmp-vlime/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/11/22/introducing-nvim-cmp-vlime/</guid><description>I am glad to announce a new Neovim plugin: nvim-cmp-vlime (GitHub mirror).
It is a completion source for nvim-cmp which uses the Vlime plugin to fetch
completion candidates from a running Common Lisp process. Vlime is a plugin
similar to Slime for Emacs, it lets the editor communicate with a running
Lisp process so we can evaluate code at runtime, debug, inspect values, and of
course get auto-completion. In fact, Vlime uses the same Backend, Swank, as
Slime, so the results should be equally good.</description><pubDate>Tue, 22 Nov 2022 00:00:00 GMT</pubDate><category>open-source</category><category>lisp</category><category>vim</category></item><item><title>cl-cmark approaching stable release</title><link>https://hiphish.github.io/blog/2022/10/16/cl-cmark-approaching-stable/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/10/16/cl-cmark-approaching-stable/</guid><description>In June of this year I introduced my Common Lisp library cl-cmark (GitHub
mirror), which implements parsing [CommonMark] documents and manipulating the
resulting document tree. I have been hammering out the last kinks over the past
weeks and I am now ready to call it done. Before I officially put the 1.0 stamp
on it though I would like if a few more people could take a look at the library
and give it a try.</description><pubDate>Sun, 16 Oct 2022 00:00:00 GMT</pubDate><category>open-source</category><category>lisp</category><category>markdown</category></item><item><title>A new static site generator</title><link>https://hiphish.github.io/blog/2022/10/02/a-new-static-site-generator/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/10/02/a-new-static-site-generator/</guid><description>In January 2019 I switched the static site generator for this website from
Pelican to a custom one written in GNU Guile. Most (or all?) static site
generators out there have an opinion on what a website should be made of. You
might have full control over the layout and content of individual pages, but
not so much over how the web site itself is composed. Writing my own static
site generator freed me from these constraints. Now if I want to have sub-sites
and multiple blogs I can do so. However, the custom generator was suffering
from the same problem: it had one specific web site composition in mind, it
just happened that this time it fit my needs. That is why I have created
HSSG: the Hackable Static Site Generator.</description><pubDate>Sun, 02 Oct 2022 00:00:00 GMT</pubDate><category>organisation</category><category>lisp</category><category>html</category><category>web</category></item><item><title>Playing Sid Meier&apos;s Civilization III in Wine in 2022</title><link>https://hiphish.github.io/blog/2022/06/25/playing-civ3-in-wine-in-2022/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/06/25/playing-civ3-in-wine-in-2022/</guid><description>A few days ago I wanted to re-install Sid Meier’s Civilization III on my
machine and play it again. This blog post is a summary of the tricks I had to
use to make it work it work well; I am writing it down for posterity, maybe
someone else will find it useful. That someone might even be future me.</description><pubDate>Sat, 25 Jun 2022 00:00:00 GMT</pubDate><category>misc</category><category>wine</category><category>games</category></item><item><title>Introducing cl-cmark</title><link>https://hiphish.github.io/blog/2022/06/15/introducing-cl-cmark/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/06/15/introducing-cl-cmark/</guid><description>For the past few weeks I have been working on a little side project, a library
of Common Lisp bindings to cmark, the CommonMark reference implementation:
cl-cmark (GitHub mirror).
CommonMark is a dialect of Markdown which aims to remove any ambiguity, clean
up the language specification and provide a common dialect of Markdown for
other projects to use. The cmark library is the reference implementation for
parsing CommonMark. It is written in C, so creating bindings for other language
is fairly simple.</description><pubDate>Wed, 15 Jun 2022 00:00:00 GMT</pubDate><category>open-source</category><category>lisp</category><category>markdown</category></item><item><title>Fake web backend with mitmproxy</title><link>https://hiphish.github.io/blog/2022/06/12/fake-web-backend-with-mitmproxy/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/06/12/fake-web-backend-with-mitmproxy/</guid><description>A web application typically consists of three layers: the frontend, the
backend, and some sort of database system for persistence. While developing the
frontend we often need to send messages to the backend, receive some response
and process that response. Faking backends in automated tests is a solved
problem, but sometime we don’t want to write tests, we want to wildly
experiment with various inputs as we are trying out the frontend by hand. We
want to intercept messages and look into what is being transmitted. In this
post I will demonstrate a simple fake backend using the mitmproxy
application.</description><pubDate>Sun, 12 Jun 2022 00:00:00 GMT</pubDate><category>open-source</category><category>web</category><category>network</category></item><item><title>The problem with contributing to Open Source</title><link>https://hiphish.github.io/blog/2022/04/07/the-problem-with-contributing-to-open-source/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/04/07/the-problem-with-contributing-to-open-source/</guid><description>I love Free (Libre) and Open Source Software (FLOSS); not only does the
software respect your personal freedom, you can also contribute back to make it
better. It becomes a communal cooperative effort. But just because you can
contribute, that doesn’t mean that you necessarily should.</description><pubDate>Thu, 07 Apr 2022 00:00:00 GMT</pubDate><category>open-source</category><category>rant</category></item><item><title>Securing Quicklisp through mitmproxy</title><link>https://hiphish.github.io/blog/2022/03/19/securing-quicklisp-through-mitmproxy/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/03/19/securing-quicklisp-through-mitmproxy/</guid><description>Quicklisp is a popular systems manager for Common Lisp, it allows users to
download, install, update and uninstall Common Lisp systems (what other
language call packages, but that term already means something else in Common
Lisp). However, Quicklisp has one glaring security issue: it downloads
everything through HTTP. This means every time you use Quicklisp to download a
system you open yourself up for a man-in-the-middle (MITM) attack. We can use a
local proxy server to route all traffic to Quicklisp through HTTPS, and in this
blog post I will illustrate how to achieve this using mitmproxy.</description><pubDate>Sat, 19 Mar 2022 00:00:00 GMT</pubDate><category>open-source</category><category>lisp</category><category>web</category><category>network</category></item><item><title>Neovim plugin settings with Lua metatables</title><link>https://hiphish.github.io/blog/2022/03/15/lua-metatables-for-neovim-plugin-settings/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/03/15/lua-metatables-for-neovim-plugin-settings/</guid><description>A lot of new Neovim plugins come with a setup function which lets you specify
the settings of the plugin. Users are expected to call that function with a
table as arguments which contains the user’s personal settings to override the
defaults. This works, but Lua is all about tables, so let’s look at an
alternative.</description><pubDate>Tue, 15 Mar 2022 00:00:00 GMT</pubDate><category>vim</category><category>neovim</category></item><item><title>Subservience to the algorithm</title><link>https://hiphish.github.io/blog/2022/01/08/subservience-to-the-algorithm/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2022/01/08/subservience-to-the-algorithm/</guid><description>Over the last couple of years I have been noticing two trends among internet
videos, especially on YouTube: videos that could easily be three to four
minutes long are stretched to over ten minutes in length, and thumbnails where
people are making stupid faces. This comes from YouTube’s recommendation
algorithm favouring thumbnails with people’s faces, and videos needing to be at
least ten minutes long to be eligible for advertising revenue. At least those
used to be the rules back then, they might have changed since, but the videos
still follow the same pattern.</description><pubDate>Sat, 08 Jan 2022 00:00:00 GMT</pubDate><category>rant</category></item><item><title>Managing Vim plugins without a plugin manager</title><link>https://hiphish.github.io/blog/2021/12/05/managing-vim-plugins-without-plugin-manager/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2021/12/05/managing-vim-plugins-without-plugin-manager/</guid><description>Recently I have switched my Neovim setup to using the new native Vim package
system directly instead of relying on a plugin manager. I had to use Git
submodules for another project anyway, so I figured I could combine them with
Vim packages and see how that might work out. It is actually working pretty
well, to the point where I don’t think that I will be returning to plugin
managers for the foreseeable future.</description><pubDate>Sun, 05 Dec 2021 00:00:00 GMT</pubDate><category>vim</category><category>vim</category></item><item><title>Getting Unity Hub 3 working on GNU/Linux</title><link>https://hiphish.github.io/blog/2021/10/11/getting-unity-hub-3-working-on-gnu-linux/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2021/10/11/getting-unity-hub-3-working-on-gnu-linux/</guid><description>Recently I had the misfortune of a data loss, so I had to re-instally my OS
again. But even worse: I also had to re-install Unity on GNU/Linux, which has
been an exercise in frustration and trial &amp; error. In this post I will outline
what I had to do, in the hope that it will be of use to other people.</description><pubDate>Mon, 11 Oct 2021 00:00:00 GMT</pubDate><category>misc</category><category>linux</category><category>rant</category></item><item><title>Generating Unity3D project files on GNU/Linux</title><link>https://hiphish.github.io/blog/2021/07/11/generating-unity3d-project-files-on-linux/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2021/07/11/generating-unity3d-project-files-on-linux/</guid><description>When I develop Grid Framework I need Unity3D to generate project files for
Omnisharp to pick up in order to provide me with tooling like
auto-completion, linting and refactoring support. Normally doing so requires me
to have VSCode installed, but there is a simple way to trick Unity into
generating those files anyway.</description><pubDate>Sun, 11 Jul 2021 00:00:00 GMT</pubDate><category>misc</category><category>linux</category><category>rant</category></item><item><title>Running MongoDB from Guix</title><link>https://hiphish.github.io/blog/2021/02/28/running-mongodb-from-guix/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2021/02/28/running-mongodb-from-guix/</guid><description>I have been watching a tutorial on GraphQL recently (YouTube link) where
the lecturer uses MongoDB for persistent storage. He instructs viewers to
sign up for a service that hosts a database, but I wanted to run a local
instance on my machine instead. MongoDB is not available in the Void repos,
but fortunately it is available in the Guix repos. However, running the Mongo
deamon requires a little tweak first.</description><pubDate>Sun, 28 Feb 2021 00:00:00 GMT</pubDate><category>misc</category><category>linux</category><category>guix</category></item><item><title>A pipe operator for Lua</title><link>https://hiphish.github.io/blog/2021/02/15/pipe-operator-for-lua/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2021/02/15/pipe-operator-for-lua/</guid><description>I have recently been getting into Elixir, and one
nice feature it has is the pipe operator. It allows us to express a pipeline
of function through which an object will be dragged. This got me thinking: with
how flexible Lua is, would it be possible to add something similar to Lua as
well?</description><pubDate>Mon, 15 Feb 2021 00:00:00 GMT</pubDate><category>open-source</category><category>lua</category><category>elixir</category></item><item><title>Spreading tables in Lua</title><link>https://hiphish.github.io/blog/2020/12/31/spreading-tables-in-lua/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/12/31/spreading-tables-in-lua/</guid><description>Javascript has a spreading operator which lets us splice the contents of an
object or array into another object or array. This makes it very easy to create
an object based on another object and override or add entries. Since Lua and
Javascript are quite similar, wouldn’t it be nice to have this operator in Lua
as well? Lua is a minimal language, so adding a new operator seems unlikely,
but Lua is also very flexible, and we can add a spreading function instead.</description><pubDate>Thu, 31 Dec 2020 00:00:00 GMT</pubDate><category>open-source</category><category>lua</category></item><item><title>Making LuaRocks (partially) compliant with the XDG Base Directory specification</title><link>https://hiphish.github.io/blog/2020/12/29/making-luarocks-xdg-compliant/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/12/29/making-luarocks-xdg-compliant/</guid><description>LuaRocks is a community-driven package manager for the Lua programming
language. LuaRocks packages can be installed globally or in the user’s home
directory, but sadly LuaRocks does not follow the XDG Base Directory
specification. However, with a few lines of Lua code we can fix this
shortcoming partially at least.</description><pubDate>Tue, 29 Dec 2020 00:00:00 GMT</pubDate><category>open-source</category><category>unix</category><category>lua</category></item><item><title>Making SBCL compliant with the XDG Base Directory specification</title><link>https://hiphish.github.io/blog/2020/12/28/making-sbcl-xdg-compliant/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/12/28/making-sbcl-xdg-compliant/</guid><description>The war on dotfiles continues, this time with SBCL. Let’s see how we can make
it comply with the XDG Base Directory specification.</description><pubDate>Mon, 28 Dec 2020 00:00:00 GMT</pubDate><category>open-source</category><category>unix</category><category>lisp</category></item><item><title>Making Bash compliant with the XDG Base Directory specification</title><link>https://hiphish.github.io/blog/2020/12/27/making-bash-xdg-compliant/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/12/27/making-bash-xdg-compliant/</guid><description>GNU Bash does not comply with the XDG Base Directory specification, it uses
the classical dotfiles approach where it just dumps all its files into the home
directory. It does not even have the courtesy of putting all its files in one
common ~/.bash directory. Fortunately we can coerce Bash into compliance with
a bit of effort.</description><pubDate>Sun, 27 Dec 2020 00:00:00 GMT</pubDate><category>open-source</category><category>unix</category></item><item><title>A Guix daemon for runit</title><link>https://hiphish.github.io/blog/2020/11/20/guix-daemon-for-runit/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/11/20/guix-daemon-for-runit/</guid><description>I use GNU Guix as a secondary package manager on my system. Previously I have
been running Kubuntu, which uses systemd as its init system, but I have
since switched to Void, which uses runit. Guix comes with services for
systemd and Upstart included, but not for runit. Let’s find out how to create
a runit service from scratch.</description><pubDate>Fri, 20 Nov 2020 00:00:00 GMT</pubDate><category>open-source</category><category>guix</category><category>linux</category></item><item><title>My computer broke down</title><link>https://hiphish.github.io/blog/2020/11/15/my-computer-broke-down/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/11/15/my-computer-broke-down/</guid><description>There are two types of people: those who make backups and those who will
experience a system breakdown. Fortunately I was in the former category, but it
was still a very tedious and stressful experience. Every problem is also an
opportunity to grow and throw off dead weight, so I used the opportunity to
upgrade the hardware and switch my operating system.</description><pubDate>Sun, 15 Nov 2020 00:00:00 GMT</pubDate><category>organisation</category><category>rant</category><category>unix</category></item><item><title>A web page template DSL for my website</title><link>https://hiphish.github.io/blog/2020/10/02/page-template-dsl-for-my-website/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/10/02/page-template-dsl-for-my-website/</guid><description>In my previous blog post I presented how I had come up with an embedded
domain-specific language for creating web pages in my custom static site
generator. I also mentioned the concept of “templates” in passing. Of course it
was only logical to follow the page DSL up with a custom template DSL to smooth
over the code duplication and pattern repetition.</description><pubDate>Fri, 02 Oct 2020 00:00:00 GMT</pubDate><category>organisation</category><category>lisp</category><category>html</category></item><item><title>A page DSL for my website</title><link>https://hiphish.github.io/blog/2020/09/28/page-dsl-for-my-website/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/09/28/page-dsl-for-my-website/</guid><description>I got bitten by the Lisp bug recently again, and so I decided to clean up an
ugly wart in my static site generator which I use for generating the Workshop.
The goal was to create an embedded domain-specific language (DSL) for defining
web pages.</description><pubDate>Mon, 28 Sep 2020 00:00:00 GMT</pubDate><category>organisation</category><category>lisp</category><category>html</category></item><item><title>Dotfiles were a mistake</title><link>https://hiphish.github.io/blog/2020/08/30/dotfiles-were-a-mistake/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/08/30/dotfiles-were-a-mistake/</guid><description>Unix has a clever trick for hiding a file from being displayed by the ls
command or other file browsers: just prefix the file name with a period
character. Many applications use this fact in order to place hidden files or
directories in the user’s home directory, usually containing settings, cached
files, persistent data and whatever else developers might come up with. This
practice has always struck me as just plain wrong, and I am glad that my
sentiment was confirmed by Rob Pike years ago.</description><pubDate>Sun, 30 Aug 2020 00:00:00 GMT</pubDate><category>unix</category></item><item><title>The best language to learn programming</title><link>https://hiphish.github.io/blog/2020/08/02/the-best-language-to-learn-programming/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/08/02/the-best-language-to-learn-programming/</guid><description>What is the best first language when learning how to program? There have been
many opinions over the years, each with their own selling point: BASIC was
created for beginners, Python is executable pseudocode, JavaScript runs
everywhere on the web, and so on. However, I would argue that the truly best
language has been right under our nose the whole time: the Unix shell.</description><pubDate>Sun, 02 Aug 2020 00:00:00 GMT</pubDate><category>unix</category></item><item><title>Macho, the man command on steroids</title><link>https://hiphish.github.io/blog/2020/05/31/macho-man-command-on-steroids/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/05/31/macho-man-command-on-steroids/</guid><description>The Unix man command can open a manual page if you know its name, and the
apropos command can search through the manuals if you are looking for a
specific word. Let’s put the two to work together into a command I like to call
macho: the man command on steroids.</description><pubDate>Sun, 31 May 2020 00:00:00 GMT</pubDate><category>open-source</category><category>unix</category></item><item><title>How I manage SSH connections</title><link>https://hiphish.github.io/blog/2020/05/23/how-i-manage-ssh-connections/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/05/23/how-i-manage-ssh-connections/</guid><description>I have a number of machines I need to connect to via the secure shell (SSH),
and typing in the IP address or host name by hand every time get tedious very
quickly. I could use an application for that, but that’s bloat. Let’s instead
see how we can leverage small universal tools to build an elegant solution of
our own instead.</description><pubDate>Sat, 23 May 2020 00:00:00 GMT</pubDate><category>open-source</category><category>unix</category></item><item><title>De-Bootsrapping the workshop, part 2</title><link>https://hiphish.github.io/blog/2020/02/29/de-bootsrapping-the-workshop-part-2/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/02/29/de-bootsrapping-the-workshop-part-2/</guid><description>About a year ago I wrote about the first step in
de-Bootstrapping my website, where
I made my site layout independent of the Bootstrap
CSS framework. I have now finally removed Bootstrap entirely from the website.</description><pubDate>Sat, 29 Feb 2020 00:00:00 GMT</pubDate><category>organisation</category><category>html</category><category>rant</category></item><item><title>Project-local Vim settings the right way</title><link>https://hiphish.github.io/blog/2020/02/08/project-local-vim-settings-the-right-way/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/02/08/project-local-vim-settings-the-right-way/</guid><description>Sometimes you want to have a set of Vim settings specific only to a certain
project. There are many tips out there how to achieve such a setup, but most of
them expose the user to serious security risks. I am going to describe the
fundamental problem and how to solve it. TL;DR: use the vim-addon-local-vimrc
plugin.</description><pubDate>Sat, 08 Feb 2020 00:00:00 GMT</pubDate><category>vim</category><category>vim</category><category>rant</category></item><item><title>Learn Vim Script in Y minutes</title><link>https://hiphish.github.io/blog/2020/02/01/learn-vimscript-in-y-minutes/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2020/02/01/learn-vimscript-in-y-minutes/</guid><description>My article for the website Learn X in Y minutes about Vim scripting has
been accepted; the article teaches you how to get started with Vim’s built-in
custom scripting language in a very concise manner. It has been quite an
enjoyable topic to write about and I even ended up learning a few new tricks
myself.</description><pubDate>Sat, 01 Feb 2020 00:00:00 GMT</pubDate><category>vim</category><category>vim</category></item><item><title>Switching themes automatically in lightline.vim</title><link>https://hiphish.github.io/blog/2019/09/21/switching-automatically-themes-in-lightline/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/09/21/switching-automatically-themes-in-lightline/</guid><description>I have recently switched my Neovim setup to use lightline.vim and at the
same time I was experimenting with colour schemes. Getting lightline to switch
colours along with the rest of the editor is non-trivial, but I think I have
figured it out, so I am going to share my setup.</description><pubDate>Sat, 21 Sep 2019 00:00:00 GMT</pubDate><category>vim</category><category>vim</category></item><item><title>What is a programmable programming language?</title><link>https://hiphish.github.io/blog/2019/06/22/what-is-a-programmable-programming-language/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/06/22/what-is-a-programmable-programming-language/</guid><description>When I was still researching this fabled obscure language called Lisp one thing
people kept saying about it is that “Lisp is a programmable programming
language”, but I could never figure out what they meant by that. It sounds like
a smug buzzword or like a gimmick from an academic toy language. Lisp
programmers have gotten so used to metaprogramming in Lisp that they seem to
forget that it is either an entirely alien concept to people, or something
people have been burned by too often (like every C programmer).</description><pubDate>Sat, 22 Jun 2019 00:00:00 GMT</pubDate><category>misc</category><category>lisp</category></item><item><title>Understanding 2D rotation matrices</title><link>https://hiphish.github.io/blog/2019/06/20/understanding-rotation-matrices/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/06/20/understanding-rotation-matrices/</guid><description>When I first a^2 + b^2 learned about rotation matrices they appeared quite “magic”; if
you squinted your eyes a bit it sort of made sense, and if you did the math you
could prove that the matrix does indeed perform the rotation and that all the
group properties are met, but none of that explains where that form comes
from, why it works. In this blog post I will explore a way to derive the
formula for rotation matrices step by step.  If you wish to follow along you
need only basic knowledge of linear algebra and trigonometry.</description><pubDate>Thu, 20 Jun 2019 00:00:00 GMT</pubDate><category>math</category></item><item><title>Introducing Guile.vim</title><link>https://hiphish.github.io/blog/2019/06/17/introducing-guile-vim/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/06/17/introducing-guile-vim/</guid><description>Vim has good support for Scheme, but the problem with Scheme is that every
implementation adds its own features to the language. My guile.vim plugin
aims to improve support for GNU Guile by augmenting these settings. It can
attempt to detect when a Scheme file is Guile-specific and it adds syntax
highlighting for Guile-specific forms.</description><pubDate>Mon, 17 Jun 2019 00:00:00 GMT</pubDate><category>vim</category><category>lisp</category><category>vim</category></item><item><title>Mirroring a GitLab repository</title><link>https://hiphish.github.io/blog/2019/06/11/mirroring-a-gitlab-repository/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/06/11/mirroring-a-gitlab-repository/</guid><description>I use GitLab to host my various projects, but it is always a good idea to be
able to have an automatic mirror set up. It adds redundancy in case something
goes wrong with GitLab, and having a mirror on a popular site like GitHub
allows people to file issues without signing up for a less popular service. I
am writing this down for myself so I don’t have to figure out how to set up a
mirror every time anew. This was written for GitLab version 12.0.0.</description><pubDate>Tue, 11 Jun 2019 00:00:00 GMT</pubDate></item><item><title>Introducing Awk-ward.nvim</title><link>https://hiphish.github.io/blog/2019/06/07/introducing-awk-ward-nvim/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/06/07/introducing-awk-ward-nvim/</guid><description>In order to make writing Awk scripts easier I have written a new Neovim plugin:
Awk-ward.nvim (GitHub mirror). This plugins allows you to edit an Awk
script or its input, and see the output live as you are making changes.</description><pubDate>Fri, 07 Jun 2019 00:00:00 GMT</pubDate><category>vim</category><category>awk</category></item><item><title>Singleton objects in Guile Scheme</title><link>https://hiphish.github.io/blog/2019/05/24/singleton-objects-in-guile-scheme/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/05/24/singleton-objects-in-guile-scheme/</guid><description>When I wrote guile-messagepack I needed an object to represent the nil
value, which embodies the concept of “nothingness” or “no value” in
MessagePack. None of the existing objects like #f or &apos;() were adequate,
so I decided to make a new one: nothing. It does not make sense for there to
be multiple instance of nothing, so it had to be a singleton. In this blog
post I will describe a way of creating such a singleton.</description><pubDate>Fri, 24 May 2019 00:00:00 GMT</pubDate><category>lisp</category></item><item><title>Writing NCM2 sources</title><link>https://hiphish.github.io/blog/2019/05/10/writing-ncm2-sources/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/05/10/writing-ncm2-sources/</guid><description>NCM2 is a plugin for Neovim and Vim which provides users with a unified
completion menu. By default it displays nothing, users need to add sources
for completion. These plugins instruct NCM2 on how to get completion candidates
for a particular use-case, such as words in the current buffer, or function
names in a programming language. The NCM2 documentation explains how to write
the individual pieces of a source, and in this blog post I am going to dive
into how to connect those pieces into a working source.</description><pubDate>Fri, 10 May 2019 00:00:00 GMT</pubDate><category>vim</category><category>vim</category></item><item><title>Introducing ncm2-vlime</title><link>https://hiphish.github.io/blog/2019/03/24/introducing-ncm2-vlime/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/03/24/introducing-ncm2-vlime/</guid><description>I have written a Common Lisp completion
source for
NCM2, built upon
Vlime. It provides asynchronous Common Lisp
completion and should work in both Vim and Neovim, depending on how well NCM2
and Vlime themselves work.</description><pubDate>Sun, 24 Mar 2019 00:00:00 GMT</pubDate><category>vim</category><category>vim</category><category>lisp</category></item><item><title>Implementing MsgPack.rkt, part 3</title><link>https://hiphish.github.io/blog/2019/02/15/implementing-msgpackrkt-pt3/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/02/15/implementing-msgpackrkt-pt3/</guid><description>In the previous article we have seen how to pack an object, this time we will
see how to unpack it again on the receiving end.</description><pubDate>Fri, 15 Feb 2019 00:00:00 GMT</pubDate><category>open-source</category><category>msgpack</category><category>lisp</category></item><item><title>Implementing MsgPack.rkt, part 2</title><link>https://hiphish.github.io/blog/2019/02/13/implementing-msgpackrkt-pt2/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/02/13/implementing-msgpackrkt-pt2/</guid><description>In this part of the series I want to go into how to pack data to bytes in
MessagePack. We will see how to dynamically dispatch on type and how to pack a
selection of particular types.</description><pubDate>Wed, 13 Feb 2019 00:00:00 GMT</pubDate><category>open-source</category><category>msgpack</category><category>lisp</category></item><item><title>Implementing MsgPack.rkt, part 1</title><link>https://hiphish.github.io/blog/2019/02/11/implementing-msgpackrkt-pt1/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/02/11/implementing-msgpackrkt-pt1/</guid><description>When I originally set out to write MsgPack.rkt, a Racket implementation of
the MessagePack protocol, I had a hard time wrapping my mind around where to
begin. I had no experience in writing a serialisation library, and reading the
source code of existing implementations only revealed the what, but not the
why. This is why I’m starting this short mini-series of blog posts to provide
a commentary on my implementation. I hope that it will serve other people who
are looking for a starting point to their own implementations.</description><pubDate>Mon, 11 Feb 2019 00:00:00 GMT</pubDate><category>open-source</category><category>msgpack</category><category>lisp</category></item><item><title>De-Bootsrapping the workshop, part 1</title><link>https://hiphish.github.io/blog/2019/02/04/de-bootstrapping-part-1/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/02/04/de-bootstrapping-part-1/</guid><description>The first major step in phasing out the bloat that is Bootstrap from my
website is done. None of the layout depends on any Bootstrap classes and
markup. Instead, the layout is built from scratch using the new Flexbox and
Grid features.</description><pubDate>Mon, 04 Feb 2019 00:00:00 GMT</pubDate><category>organisation</category><category>html</category></item><item><title>A pure HTML &amp; CSS menubar</title><link>https://hiphish.github.io/blog/2019/01/28/pure-html-css-menubar/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/01/28/pure-html-css-menubar/</guid><description>In the process of de-Bootstrapping the workshop I have to replace whole
components provided by Bootstrap with my own constructs. The menu bar is one
of the larger components I use, it’s fairly complex and requires a lot of
non-semantic markup to get working. In this blog post I will describe step by
step how I built mine, which requires less markup and does not rely on
Javascript. You can try the demo to see what we are going for (please resize
your window to see the responsiveness).</description><pubDate>Mon, 28 Jan 2019 00:00:00 GMT</pubDate><category>organisation</category><category>html</category></item><item><title>Neovim channel for GNU Guix</title><link>https://hiphish.github.io/blog/2019/01/21/neovim-guix-channel/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/01/21/neovim-guix-channel/</guid><description>I have set up a channel for GNU Guix to build Neovim. This channel serves
as an experimental staging ground for porting Neovim (and perhaps other related
projects in the future) to the Guix functional package manager. When the
packages are deemed stable and correct enough they will be submitted to Guix
proper.</description><pubDate>Mon, 21 Jan 2019 00:00:00 GMT</pubDate><category>vim</category><category>lisp</category><category>vim</category></item><item><title>Introducing Quicklisp.nvim</title><link>https://hiphish.github.io/blog/2019/01/17/quicklispnvim/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/01/17/quicklispnvim/</guid><description>One of the new features of Neovim is its ability to write plugins in any
programming language, provided that there is a plugin host available. I have
wanted to play around with the Common Lisp host for a while, and I like for
something useful to come out of it in the end, so I created Quicklisp.nvim, a
plugin which allows users to manage Common Lisp libraries from inside Neovim.</description><pubDate>Thu, 17 Jan 2019 00:00:00 GMT</pubDate><category>vim</category><category>lisp</category><category>vim</category></item><item><title>A new static site generator</title><link>https://hiphish.github.io/blog/2019/01/15/a-new-ssg/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2019/01/15/a-new-ssg/</guid><description>Over two years already without rewriting the workshop? I have to rectify this,
with the greatest rewrite yet! I have abandoned Pelican because I constantly
had to adjust things manually after the build process, and even then there were
parts of the website that weren’t working. This put me off from blogging, since
after each post I would have to stitch everything back together by hand. Seeing
that no static site generator would be able to meet my needs I decided to
instead write my own in Scheme.</description><pubDate>Tue, 15 Jan 2019 00:00:00 GMT</pubDate><category>organisation</category><category>lisp</category></item><item><title>Goodbye macOS, hello GNU/Linux</title><link>https://hiphish.github.io/blog/2018/12/01/gnu-linux/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2018/12/01/gnu-linux/</guid><description>I knew this day would come eventually, so here we are: I moved from macOS to
GNU/Linux as my operating system. It has been a couple of months since then and
I have settled in pretty comfortably; some things are better some things are
worse, and some things are just plain different.</description><pubDate>Sat, 01 Dec 2018 00:00:00 GMT</pubDate><category>organisation</category></item><item><title>A purely functional fixed timestep loop</title><link>https://hiphish.github.io/blog/2017/07/16/functional-fixed-timestep-loop/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2017/07/16/functional-fixed-timestep-loop/</guid><description>There is a great article by Glenn Fiedler titled “Fix Your Timestep!” in
which the author explains various approaches to writing a game loop and
concludes with a loop that provides a fixed time step for simulation. If you
are not familiar with this topic go read the article first and come back later.
The author has written the implementation in C or C++ using a lot of mutation
and looping, so I wanted to give a purely functional approach a shot.</description><pubDate>Sun, 16 Jul 2017 00:00:00 GMT</pubDate><category>lisp</category></item><item><title>Creating a mock REPL on Unix</title><link>https://hiphish.github.io/blog/2017/05/13/mock-repl-unix/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2017/05/13/mock-repl-unix/</guid><description>During the development of REPL.nvim I had to be able to test the plugin
without relying on any particular REPL present on the development system. The
solution was to create a mock REPL, a shell script which acts like a really
dumb REPL. Here is the code:</description><pubDate>Sat, 13 May 2017 00:00:00 GMT</pubDate><category>misc</category></item><item><title>Introducing REPL.nvim</title><link>https://hiphish.github.io/blog/2017/05/06/introducing-repl-nvim/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2017/05/06/introducing-repl-nvim/</guid><description>Integrating a REPL in Vim has been a difficult issue in the past, but with
Nvim’s built-in terminal emulator it is just a few commands away. My new
REPL.nvim plugin now puts the REPL only one command away, for any
programming language you wish. The end goal is to have a complete generic and
configurable REPL framework which can be customised to the needs of any
language and which forms a solid foundation for other plugins as well.</description><pubDate>Sat, 06 May 2017 00:00:00 GMT</pubDate><category>vim</category><category>vim</category></item><item><title>Outlining of HTML pages is fundamentally broken</title><link>https://hiphish.github.io/blog/2017/04/25/html-outline-fundamentally-broken/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2017/04/25/html-outline-fundamentally-broken/</guid><description>If you were to run the Workshop through an HTML validator you would notice a
lot of warnings about the document outline. What is going on here? HTML 5
defines an outline algorithm which allows browsers and assistive
technologies to create an outline of the page. In theory a blind person could
ask their reader for the outline of the page and get a sort of table of
contents which they could use to quickly jump to a specific part of the page.</description><pubDate>Tue, 25 Apr 2017 00:00:00 GMT</pubDate><category>html</category><category>rant</category></item><item><title>Introducing info.vim</title><link>https://hiphish.github.io/blog/2016/11/20/introducing-infovim/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2016/11/20/introducing-infovim/</guid><description>There is a new project up at the Workshop: info.vim, a Vim plugin which
implements a complete reader and browser for info documents from within Vim.
This is similar to the standalone info program or the Emacs info mode.</description><pubDate>Sun, 20 Nov 2016 00:00:00 GMT</pubDate><category>vim</category><category>vim</category><category>info</category></item><item><title>Rewriting the Workshop</title><link>https://hiphish.github.io/blog/2016/09/27/rewriting-the-workshop/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2016/09/27/rewriting-the-workshop/</guid><description>At this point I  could start to make rewriting  my website an annual tradition.
There have been a number of little  details that have been rubbing me the wrong
way for almost a year now;  the biggest one was the navigation bar on sub-sites
like the  Grid Framework  product site.  There were  also accessibility  issues
relating  to  the lack  of a  proper  HTML  document  outline  and  the  use of
JavaScript.</description><pubDate>Tue, 27 Sep 2016 00:00:00 GMT</pubDate><category>organisation</category><category>html</category></item><item><title>Introducing IPS-Tools</title><link>https://hiphish.github.io/blog/2016/07/06/intro-ips-tools/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2016/07/06/intro-ips-tools/</guid><description>I found myself needing a program to apply binary patches in the IPS file format
and I was really disappointed  that there are no proper  Unix programs for that
purpose available.  So I set out to make my own,  but instead of just  applying
patches it would be a complete suite of tools to handle all IPS-related tasks.</description><pubDate>Wed, 06 Jul 2016 00:00:00 GMT</pubDate><category>open-source</category></item><item><title>Highlighting `NSImageView` the right way</title><link>https://hiphish.github.io/blog/2016/06/25/highlighting-nsimageview/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2016/06/25/highlighting-nsimageview/</guid><description>Recently  I have  been working on  a small Cocoa  app and one  of the  things I
needed to do was highlight an  NSImageView when the user is hovering above it
while dragging a file.  You would think  that it’s a very simple task,  and you
would be right, but judging by some of the things on the internet it looks like
an unsolved problem.</description><pubDate>Sat, 25 Jun 2016 00:00:00 GMT</pubDate><category>misc</category><category>cocoa</category></item><item><title>Introducing NTFS-Clone</title><link>https://hiphish.github.io/blog/2016/05/31/intro-ntfs-clone/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2016/05/31/intro-ntfs-clone/</guid><description>This is  a very  useful project  I had  written quite  a while  ago at work and
recently found collecting dust on my hard drive. It lets you create perfect 1:1
copies of NTFS hard drives on Unix.  The problem with every software I had come
across was  that it would copy the data,  but that wasn’t enough,  so we had to
run Windows repair on every single drive.</description><pubDate>Tue, 31 May 2016 00:00:00 GMT</pubDate><category>open-source</category></item><item><title>Neovim has tab-local working directories now</title><link>https://hiphish.github.io/blog/2016/04/22/neovim-tcd/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2016/04/22/neovim-tcd/</guid><description>My Neovim PR to add tab-local working directories has recently been merged.  In
this post I will explain what it does and why you will love it.</description><pubDate>Fri, 22 Apr 2016 00:00:00 GMT</pubDate><category>vim</category><category>vim</category></item><item><title>Feeds are live now</title><link>https://hiphish.github.io/blog/2015/11/14/feeds-live-now/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2015/11/14/feeds-live-now/</guid><description>RSS- and Atom feeds are live now. You can subscribe to an entire blog using the
links in the navigator or you can subscribe to a particular category in a blog.
For that navigate to the category using either the navigator or by clicking the
category button of an article.</description><pubDate>Sat, 14 Nov 2015 00:00:00 GMT</pubDate><category>organisation</category></item><item><title>We are live!</title><link>https://hiphish.github.io/blog/2015/11/11/we-are-live/</link><guid isPermaLink="true">https://hiphish.github.io/blog/2015/11/11/we-are-live/</guid><description>The Workshop blog is finally up and running, in all its static glory. This
makes the site practically complete, at least as complete as a website can ever
be anyway. It also works great with my
Multiblog
plugin.</description><pubDate>Wed, 11 Nov 2015 00:00:00 GMT</pubDate><category>organisation</category><category>html</category></item></channel></rss>