{"@attributes":{"version":"2.0"},"channel":{"title":"Blog on Francis Sunday","link":"https:\/\/codehakase.com\/blog\/","description":"Recent content in Blog on Francis Sunday","generator":"Hugo","language":"en-us","lastBuildDate":"Tue, 03 Mar 2026 00:00:00 +0000","item":[{"title":"The Database Is a Cache","link":"https:\/\/codehakase.com\/blog\/the-database-is-a-cache\/","pubDate":"Tue, 03 Mar 2026 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/the-database-is-a-cache\/","description":"

The default way to build a data-backed application is database-first. Design a schema, build an application that reads and writes to it, render the results. The database is the source of truth. Everything else is downstream.<\/p>\n

This made sense because applications could only operate on structured data. A billing system needed an invoices<\/strong> table with amounts, due dates, and payment statuses in well-defined columns. It couldn’t look at a signed contract PDF and figure out the payment terms on its own.<\/p>"},{"title":"Bounded Execution for AI Coding Agents","link":"https:\/\/codehakase.com\/blog\/bounded-execution-for-ai-coding-agents\/","pubDate":"Fri, 09 Jan 2026 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/bounded-execution-for-ai-coding-agents\/","description":"

I do a lot of AI-assisted programming across my personal projects, studio work, codebase search at my day job. My preference is CLI-based agents, where Claude Code<\/a> and Amp<\/a> excel. For some tasks, I prefer the Ralp Wiggum<\/a> pattern (fire-and-forget with checkpoints), other times I prefer to be in the loop.<\/p>\n

I mostly utilise smaller threads so I don’t get the agent drunk on context. One pattern kept emerging: I’d ask the agent to “keep fixing until the tests pass” or “deploy and verify the health check succeeds,” and I’d find myself babysitting the process. The agent would make progress, hit an error, try again, and I have to be on standby to send a “Continue” text. This led me to build alpf<\/a> (Agentic Loop with Promise Fulfilment) - a CLI tool that wraps any task executor with bounded execution guarantees. The interesting part isn’t the tool itself, but how it changes the way I work with AI coding agents.<\/p>"},{"title":"Idiomatic Haskell Refactors","link":"https:\/\/codehakase.com\/blog\/idiomatic-haskell-refactors\/","pubDate":"Sun, 19 Oct 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/idiomatic-haskell-refactors\/","description":"

I was reviewing my notes for previous idiomatic Haskell refactoring patterns I’ve recorded, and I can see some entries that are interesting to share. Some were confusing at first, but looking at them from first principles, weighing the gains in terms of brevity and\/or performance, they’ve become clearer and essential to how I write Haskell code.<\/p>\n

Here are some of the patterns that made the biggest difference:<\/p>\n

Bind to Lambda Case:<\/h3>\n

Enabled via the LambdaCase<\/code> language extension, we can rewrite pattern matching blocks to omit identifiers that are only used in the pattern match, like in the example below where we have a userM<\/code> variable only used in the pattern match.<\/p>"},{"title":"Maps Don't Shrink in Go","link":"https:\/\/codehakase.com\/blog\/maps-dont-shrink-in-go\/","pubDate":"Tue, 27 May 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/maps-dont-shrink-in-go\/","description":"

Maps in Go are built-in data structures that provide a way to store key-value pairs. They are similar to dictionaries or hash tables in other programming languages. Maps are unordered collections, meaning that the order of elements is not guaranteed.<\/p>\n

func<\/span> main<\/span>() {\n<\/span><\/span> m<\/span> :=<\/span> make<\/span>(map<\/span>[string<\/span>]string<\/span>)\n<\/span><\/span> m<\/span>["name"<\/span>] = "Didi"<\/span>\n<\/span><\/span> m<\/span>["city"<\/span>] = "Lagos"<\/span>\n<\/span><\/span>\n<\/span><\/span> fmt<\/span>.Println<\/span>(m<\/span>) \n<\/span><\/span> \/\/ Output: map[city:Lagos name:Didi]<\/span>\n<\/span><\/span>}\n<\/span><\/span><\/code><\/pre><\/div>
Go maps are designed to grow<\/strong> as the data they hold increases, but they generally do not shrink<\/strong> back down if elements are removed. When you add key-value pairs, they are stored in structures called buckets<\/strong>. If a map starts to fill up, it will eventually trigger a growth operation<\/strong>. This typically happens under one of two conditions:<\/p>"},{"title":"Notes on building a coding agent","link":"https:\/\/codehakase.com\/blog\/notes-on-building-a-coding-agent\/","pubDate":"Fri, 25 Apr 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/notes-on-building-a-coding-agent\/","description":"
In writing software, we often encounter scenarios where a value resides within a context, a container of sorts. Standard function application, so straightforward with simple values, presents a challenge in these situations. Consider the Maybe<\/code> data type in Haskell, which encapsulates the possibility of a value’s absence. Applying functions to values wrapped in Maybe<\/code> requires a different approach, as direct function application results in a type error.<\/p>\n
For example, applying the function (+4)<\/code> to the integer 2<\/code> is trivial:<\/p>"},{"title":"Largest product in a series","link":"https:\/\/codehakase.com\/blog\/largest-product-in-a-series\/","pubDate":"Fri, 07 Feb 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/largest-product-in-a-series\/","description":"
First post on this blog after a long hiatus – hopefully, this will stick. I was cleaning up my browser tabs, and found a Project Euler window open and decided to attempt some problems in Haskell. I’ve been writing Haskell for a couple of months now, and it was a great way to test myself. I picked one of the problems I attempted, a simple one – Problem 8: Largest product in a series<\/a>.<\/p>"},{"title":"Working with JSON in Go","link":"https:\/\/codehakase.com\/blog\/working-with-json-in-go\/","pubDate":"Mon, 03 May 2021 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/working-with-json-in-go\/","description":"
\n
Summary: I’ve worked with JSON in various programming languages in context to data exchange\/communication between applications. In this article, I’ll give a brief overview of the encoding\/json package in Go, and point some gotchas I’ve encountered.<\/p><\/blockquote>\n
JSON<\/a> (JavaScript Object Notation), is a popular data interchange format commonly used for communication between applications. Working with JSON in Go is stress-free thanks to the encoding\/json<\/a> package from the standard library.<\/p>\n
Encoding and decoding data<\/h2>\n
To encode or decode data we use the Marshal<\/a> and Unmarshal<\/a> functions from the json package. Both methods have the following signatures:<\/p>"},{"title":"Enum Stringer Interface optimisation in Go","link":"https:\/\/codehakase.com\/blog\/enum-stringer-interface-optimisation-in-go\/","pubDate":"Thu, 08 Apr 2021 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/enum-stringer-interface-optimisation-in-go\/","description":"
The most idiomatic way of describing an enum type in Go is to use constants, often in conjunction with iota<\/a>.<\/p>\n
A pattern I’ve used to implement the Stringer<\/code> interface for an enum type is to lookup the string representation in a slice. Consider this snippet from a project I’m working on:<\/p>\n
\/\/ Status ...<\/span>\n<\/span><\/span>type<\/span> Status<\/span> uint32<\/span>\n<\/span><\/span>\n<\/span><\/span>\/\/ List of possible status values<\/span>\n<\/span><\/span>const<\/span> (\n<\/span><\/span> \/\/ The operation is known, but hasn't been decided yet<\/span>\n<\/span><\/span>\tProcessing<\/span> Status<\/span> = iota<\/span>\n<\/span><\/span> \/\/ The operation will never be accepted<\/span>\n<\/span><\/span>\tRejected<\/span>\n<\/span><\/span> \/\/ The operation was accepted<\/span>\n<\/span><\/span>\tAccepted<\/span>\n<\/span><\/span> ...<\/span>\n<\/span><\/span>)\n<\/span><\/span>\n<\/span><\/span>func<\/span> (s<\/span> Status<\/span>) String<\/span>() string<\/span> {\n<\/span><\/span> return<\/span> []string<\/span>{"processing"<\/span>, "rejected"<\/span>, "accepted"<\/span>}[s<\/span>]\n<\/span><\/span>}\n<\/span><\/span><\/code><\/pre><\/div>
The snippet above works correct but has a few glitches – passing Status(-2)<\/code> or Status(300)<\/code> will cause the String()<\/code> method to panic, and when appending to the slice, the order of the enum constants has to be taken into consideration.<\/p>"},{"title":"Line Numbers In Vim","link":"https:\/\/codehakase.com\/blog\/line-numbers-in-vim\/","pubDate":"Fri, 07 Feb 2020 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/line-numbers-in-vim\/","description":"
Vim doesn’t show line numbers by default, they can be turned on in your vim configuration. Vim has an absolute, relative and hybrid line numbering mode.\n\"\"<\/p>\n
Absolute Line Numbers<\/h2>\n
Addding the number<\/code> option to your vim config, Vim sets up absolute line numbers to show the line number for each line in the current buffer.\n\"\"<\/p>\n
" set absolute numbers<\/span>\n<\/span><\/span>set<\/span> number<\/span> " or<\/span>\n<\/span><\/span>set<\/span> nu<\/span>\n<\/span><\/span><\/code><\/pre><\/div>
Hardware<\/h2>\n
Relative Line Numbers<\/h2>\n
With the relativenumber<\/code> option, each line in your file is numbered relative to the cursor\u2019s current position.\n\"\"<\/p>"},{"title":"What I Use","link":"https:\/\/codehakase.com\/blog\/what-i-use\/","pubDate":"Fri, 10 Jan 2020 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/what-i-use\/","description":"
For the few times I have to tell people in detail the software and hardware I use on a day to day basis to do my job, here’s a post to list them. My setup changes from time to time but I’ll try to keep this up to date. My dotfiles can be found on This Repo<\/a> - they work for me, read carefully before installing for yourself.<\/p>\n
I just finished reading Thorsten Ball’s article on Ampcode, How to build an agent<\/a>, and wanted to note my thoughts. Going into it, I kind of expected a deep dive into complex engineering, maybe some heavy AI theory behind coding agents. But the main thrust of the piece was surprisingly different. It argues that building these agents doesn’t necessarily involve arcane secrets. Thorsten makes a strong case that with the right model (like Anthropic’s Claude) and a good SDK, a lot of the work boils down to setting up relatively standard boilerplate code.<\/p>"},{"title":"Functors: Identity, Composition, and fmap","link":"https:\/\/codehakase.com\/blog\/functors-identity-composition-and-fmap\/","pubDate":"Wed, 26 Mar 2025 00:00:00 +0000","guid":"https:\/\/codehakase.com\/blog\/functors-identity-composition-and-fmap\/","description":"