{"@attributes":{"version":"2.0"},"channel":{"title":"Jiby's toolbox","link":"https:\/\/jiby.tech\/","description":"Recent content on Jiby's toolbox","generator":"Hugo","language":"en-us","lastBuildDate":"Thu, 30 Jul 2026 00:00:00 +0100","item":[{"title":"Solving Wordle with information theory and SQLite","link":"https:\/\/jiby.tech\/post\/solving-wordle-sqlite-entropy\/","pubDate":"Thu, 30 Jul 2026 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/solving-wordle-sqlite-entropy\/","description":"

I’ve previously spent some time implementing wordle<\/a>, and since then enjoyed watching others discuss how to solve the game using programming, especially the solutions based on information theory.<\/p>\n

Naturally, I was interested in trying them out, given my own implementation of the game. Let me show you how I used SQL to solve Wordle, using maths from information theory.<\/p>\n

Wordle?<\/h2>\n

Briefly, Wordle<\/a> is a daily word game run by the New York Times, where we need to find a secret 5-letter word within 6 attempts.\nYou may know this game from the American\/Dutch TV game Lingo, or the French TV game Motus.\nTo guide us, each character of each attempt is scored as either perfect (right letter, right position) = “\ud83d\udfe9”, or wrong position (letter is used but elsewhere) = “\ud83d\udfe8”, or a miss (character not used at all in the word) = “\u2b1c” (or “\u2b1b” depending on OS).<\/p>"},{"title":"Full-text search using DuckDB","link":"https:\/\/jiby.tech\/post\/duckdb-full-text-search-songs\/","pubDate":"Fri, 17 Apr 2026 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/duckdb-full-text-search-songs\/","description":"

I like to explore data, as can be seen in previous posts.\nI also love to learn new tools on the way.\nIn this case, a friend’s request for help turned into a challenge around fuzzy matching of text strings.\nSo I took the opportunity to go and learn a new tool, and to present it here.<\/p>\n

Let me tell you about DuckDB, which acts like sqlite on steroids, perfect for data analysis of all kinds, but viewed through the lens of full-text similarity search.<\/p>"},{"title":"Mobile-based development with Termux on Android","link":"https:\/\/jiby.tech\/post\/nomad-dev-termux-android\/","pubDate":"Tue, 17 Mar 2026 00:00:00 +0000","guid":"https:\/\/jiby.tech\/post\/nomad-dev-termux-android\/","description":"

I’ve written a lot about Termux in the past<\/a>, and since then, have continued to refine workflows around Android terminals, trying to push it to extremes. With extra software, or accessories, how light can you go without a real computer, while retaining a good development environment?<\/p>\n

In this post, I want to show how far a tiny bit of hardware and software together have pushed my “travel mindset”, while preserving a good amount of comfort.<\/p>"},{"title":"Keyboard navigation Vimium in Firefox","link":"https:\/\/jiby.tech\/post\/firefox-keyboard-extensions-vimium\/","pubDate":"Thu, 09 Oct 2025 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/firefox-keyboard-extensions-vimium\/","description":"

Today I want to celebrate niche tooling that makes life more comfortable on the computer.\nFor context, I like to work with computers from the keyboard, minimizing use of the mouse.\nBut this is often difficult to do consistently, especially when everything is a web app, a world known to be mouse-focused.\nLet me tell you about the fantastic Firefox extensions Vimium, and Edit With Emacs, both of which make the keyboard life more pleasant.<\/p>"},{"title":"You need a risk register","link":"https:\/\/jiby.tech\/post\/you-need-a-risk-register\/","pubDate":"Sun, 16 Feb 2025 00:00:00 +0000","guid":"https:\/\/jiby.tech\/post\/you-need-a-risk-register\/","description":"

I’ve been thinking a lot about risk registers recently. I feel like people don’t\nknow enough about them, or reject them on principle for being “more process”.<\/p>\n

I’ve worked in projects where the process was heavy, and like many, I very much\ndidn’t like it then. But since moving to more “agile” environments, I’ve\nrepeatedly been missing the structured aspects of writing things down, and\nwished for more rigour, more … process?<\/p>"},{"title":"Documenting Makefiles via a help message","link":"https:\/\/jiby.tech\/post\/make-help-documenting-makefile\/","pubDate":"Sun, 21 Jul 2024 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/make-help-documenting-makefile\/","description":"

I’ve written in the past about using Makefiles for build automation and documentation<\/a>.\nBut sometimes I wish to provide help to users, that doesn’t<\/em> require\nbeing a Makefiles expert to read!<\/p>\n

Let’s explore how we can teach users our build system by turning\nthe project’s Makefile (and awk<\/code>) into a cheap documentation-as-code tool.<\/p>\n

What it looks like<\/h2>\n
make help<\/span>\n<\/span><\/span><\/code><\/pre><\/div>
\n  Code Snippet 1:<\/span>\n  How to ask for help\n<\/div>\n
\n\t\t\t
Figure 1: <\/span>Result of asking for help<\/p>"},{"title":"My python toolbox","link":"https:\/\/jiby.tech\/post\/my-python-toolbox\/","pubDate":"Mon, 01 Apr 2024 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/my-python-toolbox\/","description":"
The packaging workflow of Python has historically been a bit messy, starting\nwith pip<\/code> being just<\/em> good enough, and virtualenvs being a great idea but a\nbit unwieldy. Installation was difficult, and tools like anaconda filled the\ngaps.<\/p>\n
Lately, there’s been renaissance of package tooling in Python thanks to other\nlanguages innovating in the area, inspiring and pollinating the ecosystem,\nimproving the comfort of development.<\/p>\n
I want to present here the tools that I use to work with Python, usually latest\niterations on well known concepts, to show that Python can be both fun to play\nwith, and<\/em> safe enough if we use modern tools.<\/p>"},{"title":"Reframing tickets as engineering records","link":"https:\/\/jiby.tech\/post\/tickets-as-engineering-records\/","pubDate":"Thu, 28 Mar 2024 00:00:00 +0000","guid":"https:\/\/jiby.tech\/post\/tickets-as-engineering-records\/","description":"
In the software world, tickets (as implemented in Jira, etc) often have a bad\nreputation, and I think it’s undeserved, once we reframe what, or who tickets\nare for<\/em>.<\/p>\n
In this article I want to revisit the purpose of tickets, usually “tickets for\nproject management”, explore an alternative viewpoint of “tickets as engineering\nrecords”, and highlight how tickets should be useable as asynchronous\nalternative to (synchronous) communication.<\/p>\n
Tickets as project management<\/h2>\n
Under this fairly common viewpoint, tickets are a project manager’s tool, almost\ninflicted upon devs, likely in an attempt to punish them for their arcane powers\nover machine, who knows (I’m of course exaggerating on purpose).<\/p>"},{"title":"Embrace the Early Exit","link":"https:\/\/jiby.tech\/post\/embrace-early-exit\/","pubDate":"Thu, 01 Feb 2024 00:00:00 +0000","guid":"https:\/\/jiby.tech\/post\/embrace-early-exit\/","description":"
In programming, there are patterns everywhere: patterns of building code,\npatterns for organising components, even patterns for how to test things. A\nwhole industry is looking for\npatterns to solve all their problems.<\/p>\n
But amongst them all, there’s one pattern I whole-heartedly love, it’s the Early Exit. In this\nshort and sweet post, I want to declare my undying love to the Early Exit,\nsharing my excitement.<\/p>\n
From If+else to ladders and conditionals hell<\/h2>\n
Functions routinely need to check some edge case isn’t hit, usually with more\nedge cases than actual routine happy-path code lines.<\/p>"},{"title":"Offline developer docs: Dash docsets via Zeal","link":"https:\/\/jiby.tech\/post\/offline-dev-docs-zeal-dash-docsets\/","pubDate":"Fri, 15 Dec 2023 00:00:00 +0000","guid":"https:\/\/jiby.tech\/post\/offline-dev-docs-zeal-dash-docsets\/","description":"
Since my earliest university days, I’ve spent a lot of time trying to get better\nat computers, immersing myself in the world of Linux, and generally\nimproving my software development skills.<\/p>\n
One of the aspects that was the most helpful to help me grow was attempting to\nreplicate my normal dev workflow, but with less: Learn to operate on Linux not\nWindows, then learn to do dev via on the terminal instead of GUIs, and\neventually learn to do the same but offline, without any network calls.<\/p>"},{"title":"My git worfklow","link":"https:\/\/jiby.tech\/post\/my-git-worfklow\/","pubDate":"Fri, 30 Jun 2023 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/my-git-worfklow\/","description":"
Every now and then, at work, I find myself discussing git worfklows, commit\nmessages, branching, releasing, versioning, changelogs etc. Since my opinion has\nremained fairly consistent for the past few years, I found myself repeating the\nsame points a lot, so I wrote it down. This page is the resulting compilation of\nmy opinions on the software development lifecycle (SDLC), without workplace-specific tangeants.<\/p>\n
The article is broken down into ideas + recommendations, with recommendations in\nbold. Obviously, this workflow isn’t applicable to everyone (sorry, Google! This\nisn’t a free consultation!) as different teams have needs that should get dealt\nwith differently.<\/p>"},{"title":"Quick-start project templates via cookiecutter","link":"https:\/\/jiby.tech\/post\/quick-start-project-templates-via-cookiecutter\/","pubDate":"Wed, 05 Apr 2023 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/quick-start-project-templates-via-cookiecutter\/","description":"
The most boring part of setting up a new code project is typing the boilerplate:\nit’s easy to forget bits, so we just copy the last project’s folder and “file the serial numbers off” on the project name.<\/p>\n
Copy-pasta-driven project setup is not great though, as it’s too easy to forget\nreplacing values in obscure files, or misunderstand why project is set up that\nway in the first place, leading to nasty surprises down the line.<\/p>"},{"title":"Presentation: Makefiles for build automation and documentation","link":"https:\/\/jiby.tech\/post\/makefiles-presentation\/","pubDate":"Sun, 23 Oct 2022 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/makefiles-presentation\/","description":"
Last Friday, I performed a presentation to my colleagues about Makefiles, and I\nwant to share it to the public.<\/p>\n
Of note, this presentation is setting aside what people usually know of\nMakefiles (autoconf-generated blobs, opaque to any inspection because\nmachine-created), and instead I introduce the concept of file transformation as\na graph, then teach Makefiles basics (using SQL commands as an example). We then\nmove on to my plea for simple Makefiles, and their potential for both\ndocumentation (explain what your codebase commands are, to the juniors), and as\nlightweight automation (avoid typing long boring commands).<\/p>"},{"title":"Literate wordle","link":"https:\/\/jiby.tech\/post\/literate-wordle\/","pubDate":"Sat, 07 May 2022 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/literate-wordle\/","description":"
I’ve recently written a series of articles about Gherkin: its usage for\nrequirements gathering<\/a>, about its uses in BDD<\/a>, and a lower-tech alternative to Cucumber<\/a>, which I’m still experimenting with.<\/p>\n
I wanted to showcase all of these ideas brought together, as well as show how\ncomfy modern Python tooling can be. But more than writing code, I would need to\nexplain my reasoning as we draft the program. So I picked up again a tool I always\nwanted to play with: Literate Programming.<\/p>"},{"title":"Reinventing IP Fragmentation","link":"https:\/\/jiby.tech\/post\/reading-rfc-reinventing-ip-fragmentation\/","pubDate":"Sat, 07 May 2022 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/reading-rfc-reinventing-ip-fragmentation\/","description":"
Let’s explore how a file-format design exercise turned into\nreinventing the wheel, and let’s all appreciate how lucky we are that\nthe protocols that the internet are built on have fantastic public\ndocuments called RFC<\/a>s.<\/p>\n
Designing a file format<\/h2>\n
I was idly thinking about designing a good binary file format for a side project\nof mine called qrxfil<\/a>. The project aims at QR-code-based file export: split a\nfile in many pieces (based on content limit of QR codes) before reassembling it\non the other side.<\/p>"},{"title":"Low-tech Cucumber replacement","link":"https:\/\/jiby.tech\/post\/low-tech-cucumber-replacement\/","pubDate":"Mon, 04 Apr 2022 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/low-tech-cucumber-replacement\/","description":"
In the previous post, I showed how Gherkin Scenarios provide a great framework\nfor acceptance test definition. I also showed how the dreams of the BDD movement\nextend to automating Gherkin, using a tool called Cucumber, enforcing\ntraceability of acceptance tests.<\/p>\n
In this article, I want to explain my disilusionment towards Cucumber, and show\nhow a low-tech alternative emerged that I believe covers most of the value\nfor none of the effort.<\/p>"},{"title":"BDD Dreams, Cucumber And Gherkin","link":"https:\/\/jiby.tech\/post\/bdd-dreams-cucumber-and-gherkin\/","pubDate":"Sun, 20 Mar 2022 00:00:00 +0000","guid":"https:\/\/jiby.tech\/post\/bdd-dreams-cucumber-and-gherkin\/","description":"
In the previous post in this series on Gherkin<\/a>, I showed the tools that Gherkin\nFeatures provide for requirements tracking, and mentioned ambitious goals for\nthe Behaviour-driven Development (BDD) movement. In this article, I want to\nexpand on these BDD ideals, show Gherkin Scenarios, and explain how the dream of\ntraceability led to Cucumber, a tool for automating acceptance test execution,\ntracing them back to Gherkin Scenarios. We’ll set aside my personal feelings on\nthese tools for a future post.<\/p>"},{"title":"Gherkin Features for user requirements","link":"https:\/\/jiby.tech\/post\/gherkin-features-user-requirements\/","pubDate":"Mon, 21 Feb 2022 00:00:00 +0000","guid":"https:\/\/jiby.tech\/post\/gherkin-features-user-requirements\/","description":"
The most common mistake I see developers make is building the wrong thing<\/strong>: Not\ntracking exactly what is required from the start, and instead getting excited\nabout the cool technical problems ahead. Fast forward a few days, weeks, months,\nshowcasing the product near completion, suddenly the rift between what’s needed\nand what was built becomes obvious, in a frenzy of last minute changes to reach\nthe original goal under pressure from deadlines.<\/p>"},{"title":"Separating Spam from Ham with the shell","link":"https:\/\/jiby.tech\/post\/image-list-separate-spam-ham-with-shell\/","pubDate":"Mon, 22 Jun 2020 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/image-list-separate-spam-ham-with-shell\/","description":"
Here’s how attempting to export images off a Word Document\nled to a quest for data deduplication and classification using the\nshell.<\/p>\n
The images I wanted to export were MS Word diagrams drawn in Word,\nrather than PNG files1<\/a><\/sup>.\nBecause those doodle-shapes do not export to PNG well, I first\ncopy-pasted them into Powerpoint to get the familiar “save as picture”\ncontext menu. But a couple of images were still deformed beyond\nrecognition.<\/p>"},{"title":"Reproducible workspace deployment with Ansible and Vagrant","link":"https:\/\/jiby.tech\/post\/reproducible-workspace-ansible-vagrant\/","pubDate":"Thu, 11 Jun 2020 00:32:00 +0100","guid":"https:\/\/jiby.tech\/post\/reproducible-workspace-ansible-vagrant\/","description":"
Like many developers, I keep track of my configuration files in\nversion control, to make moving to new machines is simpler and share\ncode with others. This process started out for my Emacs config files\nat first, but grew to consume other aspects: bash functions, git\naliases… Since 2016, I have accumulated over 500 git commits<\/a>.<\/p>\n
Now the dotfiles<\/a> are tracked, the next biggest pain is to install\npackages and folder structures and obscure commands required to set up\nsome subsystems needs which config files. Wouldn’t it be nice to have\nan all-in-one setup?<\/p>"},{"title":"Using Awk to replace only some lines","link":"https:\/\/jiby.tech\/post\/awk-replace-some-lines\/","pubDate":"Sat, 16 Nov 2019 00:00:00 +0000","guid":"https:\/\/jiby.tech\/post\/awk-replace-some-lines\/","description":"
I was trying to convert bank-issued CSV files that have a weird data\nlayout, for automatic processing by the excellent ledger<\/a>. This made me\nlearn a new thing about awk<\/code>. Follow me down the UNIXy goodness!<\/p>\n
The data I was getting looks like this:<\/p>\n
Transaction Date,Transaction Description,Debit Amount,Credit Amount,Balance\n<\/span><\/span>29\/02\/2018,Restaurant,14.5,,1234.2\n<\/span><\/span>12\/03\/2018,ATM withdrawal,50,,1184.2\n<\/span><\/span>23\/04\/2018,Deposited check,,100,1284.2\n<\/span><\/span><\/code><\/pre><\/div>
Note the last line having 100 in a different column: The problem is\nthat, when receiving money, the transaction is logged in a separate\nentry (“Credit Amount”) than the (more common) case of debit, which\ngoes to “Debit Amount” column. My importing tools required a single\ncolumn, so the output must look like this:<\/p>"},{"title":"Git diff from empty commit","link":"https:\/\/jiby.tech\/post\/git-diff-empty-repo\/","pubDate":"Sun, 13 Oct 2019 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/git-diff-empty-repo\/","description":"
I’m writing code to back up my user data off a website that lets me\nsee<\/span> all of my info (including querying by time, account etc) but\ndoesn’t have export features (officially). I am certain there’s an API\nbehind the site that I just have to make sense of.<\/p>\n
Since the webapp is requesting data from the API when I click, we\nshould be able to record the web traffic to explore the API. My first\nthought was to use tcpdump(8)<\/code>, a powerful network sniffer. But for\nHTTPS traffic, the TLS encryption makes the network-level capture\nuseless. We can of course look into MITM HTTPS proxies<\/a>. But it turns\nout it can be even easier than that, as we can tell Firefox to record\nthis for us during normal website use. Let’s see how Firefox can help\nin reverse-engineering APIs!<\/p>"},{"title":"Git diff for prose","link":"https:\/\/jiby.tech\/post\/git-diff-lines-prose\/","pubDate":"Sun, 06 Oct 2019 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/git-diff-lines-prose\/","description":"
When writing long sentences in documentation repositories, git<\/code> tends to show\nreally unhelpful diffs. They are unreadable because long lines aren’t broken,\nwhich hides edits happening towards end of line. A colleague of mine asked me if git\ncouldn’t be configured to make this sort of thing more obvious. Challenge accepted!<\/p>\n
\n\t\t\t
Figure 1: Can you spot the edit made in a long line of text?<\/p>"},{"title":"Git pretty graph","link":"https:\/\/jiby.tech\/post\/git-graph\/","pubDate":"Sun, 06 Oct 2019 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/git-graph\/","description":"
Get a cool graph of commits from the command line! For newbies and experts\nalike, git is a bit hard to visualize. Here’s a handy git command to make\nunderstanding git easier.<\/p>\n
git log --decorate --oneline --graph\n<\/span><\/span><\/code><\/pre><\/div>
\n\t\t\t
Figure 1: Git graph of this repository<\/p>\n\t\t<\/figcaption>\n<\/figure>\n\n
This can be made into a git command via an entry your ~\/.gitconfig<\/code>:<\/p>\n
[alias]\n<\/span><\/span>\tgraph = log --decorate --oneline --graph\n<\/span><\/span><\/code><\/pre><\/div>
\n  Code Snippet 1<\/span>:\n  Alias \"graph\" defined in ~\/.gitconfig file\n<\/div>\n
Invoke with<\/p>"},{"title":"Presenting Android terminal with Termux (EdLug)","link":"https:\/\/jiby.tech\/post\/android-terminal-with-termux\/","pubDate":"Tue, 01 Oct 2019 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/android-terminal-with-termux\/","description":"
Last night, I presented about Termux<\/a> to EdLug, the Edinburgh Linux User group\n(see the event page on meetup.com<\/a>) in a talk titled “The freedom of shelling\nout on Android”. It was tons of fun showing off how your Android phone\/tablet\ngetting a terminal unlocks a powerful tool!<\/p>\n
\n\"tmux-framed.png\"\nI've made the slides available on this website, click on the slide below.\nRemember that there are speaker notes for people following at home, press `S` to\nuse them. These were built with [Reveal.js](https:\/\/revealjs.com).\n<\/div>\n
<\/a>
\n\t\t\t
Figure 1: <\/span>Click to view the slides<\/p>"},{"title":"About me","link":"https:\/\/jiby.tech\/about\/","pubDate":"Thu, 19 Sep 2019 00:00:00 +0100","guid":"https:\/\/jiby.tech\/about\/","description":"
Who am I?<\/em><\/p>\n
I’m Jean-Baptiste Doyon, but everyone calls me Jb (sounds like “G-Bay” in\nFrench). Across many misinterpretations, it evolved into the online handle Jiby\n(my French friends make it sound like the English initialism for Great\nBritain<\/a>), giving the domain name of this website.<\/p>\n
While I’m natively French, originally from a town near Nice, I moved across\nEurope a few times for my studies before settling in Edinburgh, Scotland.<\/p>"},{"title":"First post","link":"https:\/\/jiby.tech\/post\/hello-world\/","pubDate":"Wed, 18 Sep 2019 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/hello-world\/","description":"
Welcome to my website!<\/p>\n
This blog is meant to record some of the thoughts I keep coming back to, or\ndiscussions I’ve had over and over again with different people. My\nrule of thumb for inclusion here is “if you’ve had to say it more than\ntwice, it’s time to write it down”.<\/p>\n
See the About page<\/a> for my background and motivations.<\/p>\n
Look forward more posts as I try to condense my thoughts in written\nform.<\/p>"}]}}
In order to troubleshoot a bug in the very early history of a project\nusing git, I needed a way to show the git diff from “nothing” to the\nfirst commit. Since git keeps a linked graph of commits, what I wanted\nwas a diff from the commit before the first one. Searching the onlines\ndug up this answer on StackOverflow<\/a>, showing that there’s a specific\ncommit hash we can use to diff from “nothing” to the first commit:<\/p>"},{"title":"Reverse-engineering webapp APIs with Firefox","link":"https:\/\/jiby.tech\/post\/reverse-engineer-api-with-firefox\/","pubDate":"Wed, 09 Oct 2019 00:00:00 +0100","guid":"https:\/\/jiby.tech\/post\/reverse-engineer-api-with-firefox\/","description":"