This is the basic Plan Do Study Act loop that is used at multiple levels in an agile project.

At the lowest level it is the Red-Green-Refactor cycle of TDD

At the task level it’s the do we know enough to know what to do, report what is finished and update the next steps.

At the initiative level it’s the breaking down items into discrete tasks and ensuring that each incrementally adds value.

At the team level it’s the retro and the resulting actions to drive improvements.

ets is the bare bones no persistence storage mechanism that has lived inside Erlang for decades.
It’s not pretty but does its job well.

Today I found etso a bare-bones Ecto wrapper for ets.
This does allow possibilities for rapid prototyping of systems.
You can see if the database structure makes sense without actually having to create the database.

Possibilities here get interesting. For example you could point a generator at openapi and have a system that implements the spec without ever touching a disk.

vimtutor -c 2

This was news to me. I had done most of the the first chapter many times.

I have been working in a company that has a large monolith. The developers have been split into domains and largely been focussed on their own area.

Over time each of the domains has atrophied their understanding of the other domains.

We recentlty had some larger cross domain projects started. These also cross into some of the systems that surround the monolith.

The pure DDD ideal of having a service belonging only to one team is now causing new bottlenecks. If a service needs to be used by all the surrounding systems this will happen.

The easiest solution would be to start accepting PRs from outside of the supporting team. The downside is that the bottleneck now becomes reviewing the changes.

We really need to have a big picture view of the system somewhere. Currently we have many competing (and contradictory) views.

Designers would benefit from this. We recently we given a piece of UI work that requires a new API from the constrained team.

We would have benefited from a user needs mapping session to make it clear which team owns the various capabilities.

I have found tmux to be very useful in my development work.
I typically have one session with multiple windows, some of which are split into many tabs.
Most of the time I am zoomed into the console but the other useful panes are just a PREFIX z away.

The thing that makes it so powerful is that I can have the same terminals in both a window inside my IDE and in ghosttty outside the ide. This means that I can go full screen when I need to or simple have the results where I want them.

The next step is working out how to quickly set up the windows in the format that I want them.

The following creates a new named window

tmux new-window -n foo

The following splits a window as follows

tmux new-window \; split-window -v \; last-pane \; split-window -h

|----------------|
|   1    |  3    |
|        |       |
------------------
|   2            |
|                |
------------------

The original idea for a microservice was something small and independent that could be replaced in a couple of days.

These days we end up with distributed monoliths that are called a set of microservices.

Independent means that it could be deployed in multiple places.

Lets use a practical example. We have some images that we need thumbnails for. Images are stored in an S3 bucket. An ideal microservice would watch for images being created then create the thumbnails.

This could be configured via a pulumi script. By giving a base prefix all the parts could be configured as a set of serverless functions.

For a sufficiently large company could probably mine a number of these utilities from systems that already exist.

This varies depending upon what type of project you are working on.

If you have a website this can be reduced to: how do I know this is working in production.

If you are shipping products for other people to deploy then a test deploy should be enough.

I have started experimenting with using tmux in my development flow.

There are plenty of other articles on how to install and use Tmux. I have been working through the Tmux 2 book

It starts out as a tool that allows you to perform terminal development from a keyboard. After a while you end up turning a terminal into a multi-tab IDE.

Why did I start looking at this? For about a year I had been using Warp as an improved terminal. It’s a multi tab terminal that has slowly grown AI features (which I can’t use at work due to regulation, and now has bring-your-own credits) and an internal IDE (which I dislike due to my practice of using autosave). I have moved to ghostty as the main terminal.

Here is my personal-config setup

Tmux has the concept of sessions, windows and panes.
Sessions and windows (PREFIX c to create, PREFIX , to rename, PREFIX w to list) have names.
Windows can be split into panes.(PREFIX | or PREFIX -)
Panes can be zoomed into (PREFIX x).

This means that when working on a new task I can create a window and name it after the task that I am attempting to solve. This is very powerful especially if you get as many distractions as I do!

What problem are you trying to solve?

This is the key question that should be asked every time that someone is asking you for help with something. Frequently requests for help are to do with the details of a problem. Without knowing the context of the problem you may be working on the wrong thing.

On October 31, 2011 MF Global filed for bankruptcy.

On July 27, 2026 I received the latest update listing the 3rd and final distribution to the unsecured creditors. This is strange as the letter states the balance due is zero.

MF Global was only spun off as a distinct business in 2007. Thats 4 years of trading and now 14 years of bankruptcy.

KPMG arrived en-mass to take over the company. Anyone without a support role was instantly dismissed. I heard horror stories of the way the accounts were settled. KPMG would give instructions to the remaining mangers who then told the staff to act. No information ever flowed up. MF Global was the first big case after some new legislation had come in so KPMG wanted to  build the process. It helped that their offices were only 4 buildings away.

In the 3 month extension I had 3 days when any work was required. We started off using our Pluralsight accounts to train at x2 speed. We then started taking phone interviews at our desks. This even allowed is to pass around details of failed interviews to other candidates.

The day after the bankruptcy I got a rather odd call passed through to my desk by reception. Aparently ‘America’s Next Top Model’ wanted to talk to me. This was obviously a recruiter who had paniced when asked who was calling.

We managed to arrange some group meetings with recruiters (one of which set up a session in a nearby pub and bought us all lunch).