Zak Knill on /dev/knill

You are the bottleneck

Sat, 28 Feb 2026 21:33:24 +0000

The agent can produce code faster than you can review it. That’s the bottleneck now, not the keyboard, not the compiler. You.

Before agents, the constraint was how fast you could write code. Now it’s how fast you can review it. The agent ships. You approve. And the agent is faster than you. You’re not the producer anymore. You’re the reviewer. And that changes everything about how you should spend your time.

If code is cheap, intent is the currency

Tue, 24 Feb 2026 09:15:57 +0000

Apparently writing code is cheap now. So since the barrier to producing code is gone, the intent behind the code is the most important bit. Intent is the new scarce resource, and commit messages are where that intent lives.

Agents work in human processes

Agents are still, for now, working inside human processes. The software development lifecycle (I’m getting flashbacks to every agile coach ever!) is still the same: we still have commits, pull requests, code review. We still have humans responsible for the agent’s output. But generating the code is cheaper, so the code review carries more of the weight and responsibility for good code.

A chatbot's worst enemy is page refresh

Wed, 11 Feb 2026 15:23:34 +0000

How is is possible that we’ve made incredible gains in the performance of models, but virtually no gains in the infrastructure that supports them?.

.. or what I like to call: the worst enemy of chatbots is page refresh.

There are some large GIFs in this article, let them load :)

Claude vs. Page refresh

If a picture speaks a thousand words, here is a GIF of the Claude UI taken on 11th Feb 2026.

Only use agents for tasks you already know how to do

Mon, 09 Feb 2026 10:57:48 +0000

We’ve all seen the complaints. The burden of reviewing AI ‘output’ is shifting onto project maintainers and team members. Folks can easily generate lots of code using AI, that code might even be functional (in that it passes the tests also written by the AI).

But that doesn’t necessarily make the code good or correct.

So if you want to be a good team member, here’s my rule for coding with AI agents:

SSE sucks for transporting LLM tokens

Thu, 27 Nov 2025 16:12:48 +0000

SSE sucks

I’m just going to cut to the chase here. SSE as a transport mechanism for LLM tokens is naff. It’s not that it can’t work, obviously it can, because people are using it and SDKs are built around it. But it’s not a great fit for the problem space.

The basic SSE flow goes something like this:

Client makes an HTTP POST request to the server with a prompt
Server responds with a 200 OK and keeps the connection open
Server streams tokens back to the client as they are generated, using the SSE format
Client processes the tokens as they arrive on the long-lived HTTP connection

Sure the approach has some benefits, like simplicity and compatibility with existing HTTP infrastructure. But it still sucks.

So you want to build AI agent group chat?

Sat, 15 Nov 2025 13:50:14 +0000

Disclaimer, I work for Ably; so I’m intimately familiar with the tech I mention here. Opinions are my own, etc.

Open AI group chats

On Nov 13th Open AI announced the pilot of group chats in ChatGPT. This post looks at the existing patterns for interacting with models, and how they make it hard to build similar features.

The Open AI group chat feature allows multiple users to join a chat with an AI model, and have a conversation together. Responses from each user are visible to all participants, and the model responds to the entire group. Building this with existing model and sdk transports patterns is hard.

Patterns for building realtime features

Thu, 06 Feb 2025 16:33:33 +0000

Realtime features make apps feel modern, collaborative, and up-to-date. The features predominantly require sharing changes triggered by one user to other users, as the changes are happening.

This typically means your server needs to send data to some set of clients, where those clients don’t know they are missing the data.

These patterns rely on a connection between the client and the server, where the server can notify the client of some data. This connection could be websockets, sse, event-streams, or polling (long or short). The connection just needs to allow the server to send data to the client without the client knowing that there is new data.

Phone call asymmetry

Fri, 03 May 2024 12:08:15 +0100

You get a phone call, but you’re away from your phone or you can’t answer it right at that moment. You call the number back and hear an automated voice say:

Thank you for calling [some business], for accounts press 1, to place a new order press 2….

Perhaps, by sheer luck (or skill) you manage to navigate the labyrinth of options and talk to a real human (sidebar: there’s a circle of hell reserved for the flow-chart designer that creates a branch that ends up in them hanging up on you).

Every programmer should know

Tue, 30 Apr 2024 11:41:27 +0100

Programmers should know a lot.. apparently.

How to adopt Realtime updates in your app

Thu, 23 Nov 2023 15:27:10 +0000

…and why you really should!

What do I mean by "Realtime"

Realtime is where clients of your app can find out about something the moment it happens, rather than having to poll/nag/ask for updates. It’s generally where the server pushes the updates to the clients the moment the updates happens, rather than the clients needing to ask for them.

Realtime updates rely on two main technologies:

Websockets: A stateful, persistent, bi-directional ‘channel’ of communication.
Server sent events (SSE): Built on top of HTTP, opens a long-running HTTP connection where multiple independent messages are written to the response over time.

Please don't use polling

You might also think of polling or long polling as a mechanism for fetching ‘Realtime’ data from your backend. Polling is not Realtime.

You don't need CRDTs for collaborative experiences

Thu, 16 Nov 2023 12:00:06 +0000

You don’t need CRDTs

You don’t need CRDTs for collaborative experiences.

First lets get the ‘what-about-ery’ out the way…

Things you do need CRDTs for

Offline first – this is wayy harder to get useful behaviour with out CRDTs. If you don’t use them, you’re pretty much destined to have LWW (which is actually a CRDT behaviour), and one user is likely to overwrite the changes of another. This isn’t a great experience for anyone involved.
Text editing – everyone’s gonna say “but hey, google docs uses operational transform not CRDTs”.. OK yes, but you are not google. Martin Kleppmann has a great round-up of the various people who though they implemented OT correctly, but actually didn’t. The reason that you need CRDTs for text editing collaboration is that it’s a really extreme example of collaboration. The nature of text editing is that any tiny errors in the placement of characters by the convergence algorithm is going to create incorrect words, and incorrect words are incredibly obvious. Text editing has a high rate of edits (as you type), and the edits need to interleave perfectly or you get incorrect words, and errors in the interleaving are super obvious (incorrect words)!

Hold, on.. that all sounds great, but..

Giving up my smartphone - Duoqin F22 Pro

Sat, 04 Nov 2023 09:23:10 +0000

Background

I was first attracted to the dumbphones after seeing a series of articles on Hacker News. I like the idea of using - and relying on - my phone less and less.

No plan survives contact with the enemy, and I knew that I wouldn’t manage in life with a stripped down phone that could only do calls, texts, and maybe some music.

Eventually I stumbled across the dumbphones subreddit (/r/dumbphones). On this subreddit I discovered ’transition phones’, that is a phone that can do some smartphone things, but with dumbphone characteristics. I found that you could have a dumbphone form factor but still install all the smartphone apps you might need.

Do developers really want to give over their data?

Fri, 20 Oct 2023 07:28:42 +0100

There’s a rise in hosted database companies like Supabase, Neon, Turso, etc. When I look at those companies, here’s the thing I’ve been struggling with:

Do developers really want to give over their data?

Your making a trade-off by choosing one of these companies, and the tradeoff is this:

They will solve some boring infrastructure and security problems, and in return, they get all your data.

Not in the Cambridge-Analytica/Facebook style of “get all your data”. More like the S3 style; where the cost (in dollars 💲) or the cost (in time/effort 🕔) are high enough to dissuade you from trying to leave. There’s a strong lock-in effect.

So you want to build Miro and Figma style collaboration?

Thu, 05 Oct 2023 19:18:40 +0100

Miro and Figma have a bunch of collaboration features, in this post I’m going to break down two of those features and look at what you’d have to think about when building these into your own apps.

Disclaimer: I work for a company in this product space, which is why I care about these problems.

Lets start with..

Collaborative cursors

Collaborative cursors allow multiple users to interact on the same page of a website, and for each participant to see where the other participants are pointing or moving their cursors.

Streaming data aggregation

Wed, 23 Aug 2023 10:12:37 +0100

Imagine you’re presented with this problem:

Design a system that can show the top 10 most popular songs over the last 10 seconds on the homepage of a music streaming service.

You have access to a queue of events representing song ‘plays’ with a (timestamp, song_id) tuple.

The data should update, and be as fresh as possible.

We are given this to work with, we need to design a system that satisfies the requirements, replacing the “❓”:

The egg test: a model for reversible and irreversible decision making

Thu, 17 Aug 2023 10:34:06 +0100

Some talk of one way and two way doors, but I prefer the ’egg test’.

Do you want to know if it’s an egg?

… Drop it, if it cracks and you see an egg, then it’s an egg.

The egg test is irreversible

Clearly the problem here is that it’s now not possible to use that egg. This is an irreversible decision. That egg is never going to be hole again. And it’s going to be super hard to separate the egg, the shell, and whatever else was on the surface you dropped the egg on.

Standard lib structured logging in Go 1.21

Tue, 08 Aug 2023 17:05:20 +0100

Go 1.21 includes structured logging (with levels) as a standard library package.

In this post we look at the log/slog package, and what it provides.

TL;DR - here’s a package to make using log/slog easier: github.com/zknill/slogmw

Levels

log/slog comes with 4 levels:

1
2
3
4


slog.Debug("hello world")
slog.Info("hello world")
slog.Warn("hello world")
slog.Error("hello world")

The functions providing each level come with the same pair of exported method calls.

Here’s the example for Info:

SQLedge - Postgres on the edge

Tue, 01 Aug 2023 13:01:24 +0000

SQLedge

SQLedge uses Postgres logical replication to stream the changes in a source Postgres database to an SQLite database that can run on the edge. SQLedge serves reads from its local SQLite database, and forwards writes to the upstream Postgres server that it’s replicating from.

This lets you run your apps on the edge, and have local, fast, and eventually consistent access to your data.

Check out the repo on Github

So, you want to deploy on the edge?

Mon, 31 Jul 2023 08:33:58 +0100

Application developers often deploy their apps into a single area, generally represented by a handful of AZs in a single region. No matter where their users make requests from, those requests get served by the region where the developers’ apps run.

If a user makes a request from Europe, and the apps run in US East, that adds an extra 100-150ms of latency just by round-tripping across the Atlantic.

Edge computing tries to solve this problem, by letting app developers deploy their applications across the globe, so that apps serve the user requests closer to the user. This removes a lot of the round-trip latency because the request has to travel less far before getting to a data center that hosts the app.

Theory of a program

Mon, 10 Jul 2023 10:21:34 +0100

The building of the program is the same as the building of the theory of it by and in the team of programmers. During the program life a programmer team possessing its theory remains in active control of the program, and in particular retains control over all modifications. The death of a program happens when the programmer team possessing its theory is dissolved. A dead program may continue to be used for execution in a computer and to produce useful results.The actual state of death becomes visible when demands for modifications of the program cannot be intelligently answered. Revival of a program is the rebuilding of its theory by a new programmer team. – Peter Naur, 1985

Push stick drop - dog training

Fri, 30 Jun 2023 17:01:24 +0000

Push stick drop

I built https://pushstickdrop.dog to help train my dog potato.

Dogs learn new behaviours incrementally. The Push stick drop tool helps you build the behaviour incrementally.

When building on new behaviours with your dog, you should do it incrementally. The app takes care of setting the next duration, and tracking the success and failures. The timer page lets you record a success or a failure against the duration, and tracks your dogs progress over time.

Radical and incremental change

Mon, 03 Apr 2023 13:25:14 +0100

The allure of radical change

Radical changes are exciting. They are big, bold, and transformative. Most recently we’ve seen this with large language models – or LLMs – mostly of the GPT variety. Radical changes cause ripples and waves. We’ve seen academics and techies calling for a pause in giant AI experiments in an open letter.

We can easily see the transformative impact of radical change. This makes it exciting to get behind, and sometimes scary when it arrives, but either way radical change is alluring because it’s easy to see the impact. Radical changes are capable of mobilising people. Either for, or against, the change.

Writing confidently with ChatGPT

Fri, 17 Feb 2023 15:25:50 +0000

An AI language model

As an AI language model designed to mimic human conversation, ChatGPT has encountered its fair share of criticisms. One of the most common criticisms is that ChatGPT can be overly confident in its responses. This perception arises from the fact that people often expect ChatGPT to be an all-knowing oracle that has an answer to every question. As a result, ChatGPT is sometimes judged harshly when it provides a confidently incorrect response.

PackageMap - a tool to build a map of your code

Fri, 02 Dec 2022 17:01:24 +0000

PackageMap

I built https://packagemap.co to see how cohesive or coupled code was.

PackageMap is the next iteration of java-graphviz.

It builds on the same principles as java-graphviz. Namely that:

Coupling is bad
Cohesion is good
The existing code review tools show you file content, but not how the files interact with each other.

Code review is hard

I do a bunch of code review, particularly in github. The code review UI is great, but I found that I was only reviewing the content of the files.

Backend for the Frontend, and incentives

Tue, 22 Nov 2022 08:36:46 +0000

I work for Attest, we split our engineers largely down the seam of Backend and Frontend. We have java and go apps that run server-side, developed by our Backend engineers. We have typescript and vue apps that run in browser/on the client, developed by our Frontend engineers.

By splitting down this seam, we are also splitting on the goals and incentives of the two disciplines.

“Clean and reusable”, they said..

Our Backend engineers are motivated to provide ‘clean’ and ‘reusable’ (in quotes, because we can argue over the definition of those words) APIs. APIs that – are supposed to – expose the core concepts of our system. APIs that don’t make too many judgements on how the data will be consumed and displayed.

Aggregates: one piece of code design

Mon, 10 Oct 2022 08:59:43 +0100

Most tips for code design exist to keep a lid on the exploding complexity of our systems.

Aggregates

I won’t explain all the details of an Aggregate here, but I will say this…

An Aggregate is:

a concept from Domain Driven Design (DDD).
a cluster of associated objects that we treat as a unit for the purposes of data changes.
a mechanism for simplifying the inter-object relationships and complexity.
a container that enforces the invariants on the data it holds.
globally identified only by its root.
opaque, all actions must go through the root of the Aggregate.

Aggregates are hierarchical

Aggregates are an important mechanism to tame the complexity inside a system by simplifying and limiting the traversal and number of relationships between objects.

Please don't write "point of view"

Tue, 02 Aug 2022 13:21:34 +0100

There are some hills I am prepared to die on, this is probably not one of them, but it is irritating as hell.

Note

If you find yourself writing “point of view” in a slack message, blog post, notion document, or anywhere else.. you’re almost certainly doing it wrong.

An offending phrase

Example 1:

This is a post about why I hate the phrase “point of view”.

“Point of view” is used in sentences like this:

Debugging Linkerd for mislabelled route metrics

Fri, 29 Jul 2022 09:54:25 +0100

This post is cross-posted from the Attest Product & Technology medium publication.

At Attest we use Linkerd. Linkerd is a service mesh, it has features that help add observability and reliability to your Kubernetes clusters.

This is a story about debugging Linkerd, to find out why our metrics were being misrecorded.

One part of Linkerd (linkerd-proxy) runs as a sidecar, this sidecar is attached to your deployment’s pods and the traffic going in and out of the pod passes through linkerd-proxy. Linkerd can now see the URL paths (endpoints) that your service is being called on, and can record Prometheus metrics on those endpoints.

Addicted to on-call

Sat, 25 Jun 2022 10:39:42 +0100

Abstract

This is an explanation of the systems that lead an organisation to become addicted to on-call.

Most people recognise addiction in drugs, alcohol, nicotine, sugar, etc. A system can also have addiction in it. In a system it’s often called dependence rather than addiction. But ultimately it’s the same thing.

System dependence

System dependence or addiction stems from a short-term stimulus – that wears off – which does nothing to change the underlying reality.

Tragedy of the codebase commons

Mon, 20 Jun 2022 10:52:00 +0100

Tragedy of the commons is a situation in which individuals have access to some shared resource. The individuals act independently to their own self-interest, and contrary to the common good of all, ultimately destroying or depleting the resource.

Classic tragedy of the commons example

The classic example follows cow farmers feeding cows on a shared (common) pasture.

Each farmer wants to make the maximum amount of money, to make more money the farmer needs more cows. There are two rates involved;

visualise java class imports using graphviz

Mon, 13 Jun 2022 11:43:00 +0000

java-graphviz

https://github.com/zknill/java-graphviz

I wrote this tool to visualise the imports and dependencies between java classes.

Wikipedia has a great article on cohesion and couple of code:

https://en.wikipedia.org/wiki/Cohesion_(computer_science)

In this article there’s this image:

The image show good and bad cohesion and coupling. It’s easy to understand these two in this image, but it’s much harder to understand them in code. I wrote the java-graphviz tool to help visualise the cohesion and coupling of our codebases.

Consistently executable interviews

Thu, 09 Jun 2022 07:13:23 +0100

Hiring is important for a business, it’s a high leverage activity that makes other activities easier or faster. More of the right people (read: qualified and capable) can do more. More of the wrong people (read: underskilled) can tank the whole team.

Selecting who joins your company or team is important. A great emphasis is put on the interviews, by both the company and the candidate. Less emphasis is put on training the interviewers.

usable java setup vim

Thu, 19 May 2022 17:19:20 +0100

Vim + Java

This post covers a usable vim setup for writing java.

I assume that you are familiar enough with vim to be able to configure it, and install packages.

Code completion

The main part of writing java in vim is having decent code completion. We are going to use coc.nvim as the engine, and coc-java as the language server. Both are borrowed and forked from VSCode plugins.

Install https://github.com/neoclide/coc.nvim
In vim, run :CocInstall coc-java to install coc-java.

We can also install deoplete, which is a completion framework that can help with words and symbols that are already in the open document.

docker login error on m1

Thu, 12 May 2022 11:51:25 +0100

After updating my m1 mac, and docker, the docker login to private repo commands started to fail.

1

Error saving credentials: error storing credentials - err: exit status 1, out: Post "http://ipc/registry/credstore-updated": dial unix /Users/user/Library/Containers/com.docker.docker/Data/backend.sock: connect: connection refused

If you are using lima-vm, remove this line from ~/.docker/config.json

1

"credStore": "desktop"

power distance in comms

Tue, 03 May 2022 09:03:01 +0100

Penduluming feedback

In my career I’ve received feedback on my comms. This is partly because I actively seek it out, comms are important. It is also partly because my default state – which I work hard to moderate – is to be direct, or blunt.

Until recently, all the feedback I received was to moderate my comms to be less blunt. To share more of the background and context.

As I started to work more closely with the most senior members of our org, the I started receiving feedback to be more direct.

penduluming

Wed, 27 Apr 2022 19:32:01 +0100

One of the mental models I repeatedly use is the idea of a pendulum.

The pendulum swings between two extremes; the two most outer points. Each position of the pendulum can be mapped to a position we could take on some decision. The extreme positions of the pendulum are the extremes positions in the decision.

When this mental model is applied to decisions, I call it penduluming.

santander cycles app

Mon, 25 Apr 2022 12:59:39 +0100

My TfL Santander cycles app stopped accepting my credit card details.

symtoms

When trying to pay for 24hr cycle access the app navigated to a ‘register card details’ page.
The app didn’t accept any of the card details I tried on the page.

fix

Log into the same account on https://tfl.gov.uk/santandercycles
(Re-)register the same card details as in the app
Open the app, take out a 24hr cycle access.
The app will prompt you to enter card details, enter the same ones that you put into the website.
The purchase will succeed

email workflow

Fri, 18 Mar 2022 16:59:06 +0000

10 years of gmail

For 10+ years I was a gmail user.

Hey.com – and the horror stories of users being locked out of their gmail accounts – convinced me that I wanted a paid email provider. I spent ~2 years with Hey. I have moved off hey because I want to own my email address.

I picked fastmail. This post covers my workflow. I’ve omitted some of the details, as this post covers them much better than I can here:

change the battlefield

Mon, 31 Jan 2022 16:21:28 +0000

If you don’t like the game, change the battlefield.

This post is about the rules of the game, the games that we play, and how to change the battlefield.

know that you are playing a game

We all play games, life is a game. Everyone in life is a player, and we are all playing. If we chose not to play the game of life we would be dead, so while we are still alive we are all still playing. Depending on the game that you play, the rules of the game will be different.

focus on what is, then what to do about it

Tue, 18 Jan 2022 17:59:09 +0100

One of my wonderful (and very self-reflective) colleagues reached out to me to ask;

I tried to explain something in a PR, but I can see from the next question they asked that they hadn’t understood my first explanation. What should I say to explain the problem to them?

most misunderstandings come from not being ‘in-sync’

In “connecting to dots” I explained a little about my definition of ‘in-sync’. To me, in-sync means :

when to share your mental model

Fri, 14 Jan 2022 09:54:08 +0000

A mental model is a like an analogy, it’s a shortcut to understanding. Mental models help you to simplify and understand something complex and difficult.

All models are wrong, but some are useful. – George E. P. Box, statistician

Given your model could be wrong, it’s important to know when you should or should not share it. By “share your mental model” I mean; to explain the way you think about the problem, such that the other person understands the problem in the same way that you do.

zknill/vending-machine: vending machine in go

Fri, 14 Jan 2022 09:43:00 +0000

A vending machine implementation in go. The machine vends products, and calculates change:

zknill/vending repo

who wrote this shit?

Mon, 10 Jan 2022 14:13:26 +0000

This post is a response to Philip Heltweg’s “who wrote this shit” post.

I like the post linked above, it describes a junior developer who internalises the behaviour of ;

see some bad code
git blame to find out who wrote it
expect to see a name that you don’t recognise
mutter with discontent

The author of the original post goes on to describe the case when he was pairing with a developer he respected, and found the bad code’s author was this very same developer.

connecting the dots requires listening

Wed, 05 Jan 2022 09:53:04 +0000

The ~~best~~ most useful feedback follows a simple formula. Something like:

When you [action or behaviour]

It has [effect on me or others]

Next time please [request]

This is easy to deal with and easy to connect the dots because they are laid out for you. It’s easy to digest. It’s clear in this feedback formula what the behaviour, the effect and the change request. It’s hard not to connect those dots; it’s hard not to understand what’s being asked of you.

product ideation is dysfunctional

Tue, 21 Dec 2021 14:39:36 +0000

Ideation in product management is a broken tool that does not “create ideas”, as it professes to do. In this post I describe what’s wrong with garbage-ideation and how we can better achieve what “ideation” claims to provide.

characteristics of typical ideation

One or more 1hr meetings
Meetings consisting of a whiteboard, post-it notes, and some structured exercise.
A large number of stakeholders across a range of disciplines.

definition

When talking about a term, lets start with the definition:

bridge the gap in differences, with the right language

Tue, 23 Nov 2021 21:36:49 +0000

If you can find the right language to explain a concept, you can quickly bridge the gap in you team members’ different perspectives.

Our brains are wired completely differently. You’ve probably come across some of the archetypes for these differences; for example introverts vs. extroverts.

There are myriad different ways beyond introversion and extroversion that our brains work differently. These differences mean that we experience and approach problems entirely differently. It’s really important to have the right language to talk about, understand, and archetype these differences.

positive and negative freedoms

Fri, 29 Oct 2021 10:24:56 +0100

We want to give our teams freedoms, but taking some things away can also be freedom.

There are two kinds of freedom, positive and negative freedom.

Positive freedom is the traditional freedom, freedom to do something. When your teams have positive freedom they can choose how to build their systems. They can choose what code or tech to use. Positive freedom feels good, it leads to autonomy and mastery (two of the three things that people need from their work, the third is purpose).

failure demand

Thu, 21 Oct 2021 13:27:44 +0100

I’ve been looking for a concise way to describe:

“teams that ship a feature should be responsible for the long-term success of that feature, including the customer ops caused by stuff missing from the feature”.

I believe our teams should have an area of ownership, and being responsible (and capable, and allowed) to change anything within their area — to make the team go faster.

failure demand vs. debt

What I now know, is that we are talking about “failure demand”. Failure demand is demand caused by a failure to do something or do something right for the customer.

don't design a system to avoid a component you don't understand

Mon, 18 Oct 2021 15:38:11 +0100

Too often your fear of a component that you don’t know influences how you design your system. Whether you call it ‘curiosity’ or ‘being comfortable with ambiguity’, you need to be able to identify when you are seeking out, or shying away from, information.

Here are some rules of thumb that might show when you are avoiding the complexity, rather than seeking to understand it:

You cannot concisely describe why you’ve designed the system in a certain way.
Your description of your design focuses more on what you don’t want to do, rather than what you do. (We don’t want to touch X,Y,Z because of A,B,C.)
Were you to design from scratch, your design would be significantly different.

Instead of these, you should lean into what you don’t know, and make it known. Don’t seek solutions that avoid the unknown component, because it will come back to bite you.

vuepress search h4

Thu, 07 Oct 2021 10:30:38 +0100

Vuepress’ default theme only searches h1 to h3.

The default vuepress theme comes with header based search powered by @vuepress/plugin-search. This search plugin operates on the Vue Page object, which has a $page.headers property (docs).

The headers are extracted and added to the page object at build-time. By default only h1, h2, and h3 headers are extracted.

To change the headers that are included in the $page you can add an markdown.extractHeaders option to .vuepress/config.js.

know your frogs 🐸

Fri, 24 Sep 2021 08:38:22 +0100

The three rules of frogs

Eat the frog

“The frog” is the task that you need to do the most, but want to do the least. It’s probably your hardest of most ambiguous task. But can also be your most valuable. Avoiding the frogs leads to “busy work”.

Do your most important task first thing in the morning. Get it out the way – and everything else you do that day is an extra “win”.

habit tracker

Mon, 06 Sep 2021 20:04:35 +0100

There are three stages in a habit;

Trigger – something that starts your habit routine.
Routine – the habit behaviour, the action your take.
Reward – the benefit you gain from the behaviour.

When trying to adopt a new habit, I find the hardest stage is the trigger. Remembering to do the routine and reward. To solve this problem, I created a habit tracker in Google Sheets. This post describes that habit tracker, and the formula within it.

explain using analogies

Tue, 25 May 2021 13:11:43 +0100

analogies are an effective way of explaining complex topics to non-technical stakeholders.

Analogies are like building blocks for our thoughts. When you use analogies to explain topics you allow your reader to draw on what they already know. By drawing on their existing knowledge, your reader can understand new information faster. They need to learn less new information and can fill-in the gaps in their own understanding using your analogy.

prefer regular adhoc meetings

Mon, 15 Mar 2021 14:25:30 +0000

your meeting shouldn’t be recurring, when it can be adhoc.

Here are some thoughts to consider when making a recurring meeting. You can use these thoughts to consider if your meeting should actually be a ‘regular adhoc’ meeting instead.

average value

The value of the meeting is averaged across all the recurring-instances of the meeting.

In this problem we see that the entire set of recurring meetings is seen as a single entity. The sum of all value across all instances of the recurring meeting are averaged over all the instances of that recurring meeting. This means that every time there’s an instance of a recurring meeting that has no agenda, no value, or is cancelled.. your overall value is impacted, as this zero-value instance of the meeting drags the average value down.

notion: set full width off 🙏

Tue, 02 Mar 2021 14:17:47 +0000

Please stop toggling notion to ‘Full Width’.

In notion there’s a toggle option that makes the text in the page take up the full width.

This is not friendly to read. This site is formatted into a column because it means that your eyes don’t have to travel as far to get to the beginning of the line. This is the same reason that;

books are printed in A5
that newspapers have columns
etc.

When turned on, it looks like this;

wireguard: private network, roaming

Tue, 02 Mar 2021 09:43:00 +0000

This diagram shows my wireguard setup. Wireguard creates a virtual private network (VPN) that routes just traffic for the 10.1.1.0/24 subnet (IPs 10.1.1.0 to 10.1.1.255).

VPN is a misunderstood word. A VPN is a virtual private network, but it’s commonly used to refer to technologies that provide privacy and security on a public wifi, or allows you to hide your traffic from your ISP.

How it works

A VPN is a virtual private network. Here I use wireguard as a VPN with a new network interface added to each device (wg0). The wg0 network interface provides access to the 10.1.1.0/24 range if IPs. This virtual network is private, because only authorised members can access it.

object storage pricing

Tue, 16 Feb 2021 17:40:30 +0000

Understanding cloud pricing is pretty tricky. This post focuses on the projected costs of storing backup data in an s3 compatible object store.

I will show that scaleway object storage is much better value than aws or backblaze (b2).

prices

Here is a breakdown of the $ USD / month cost of each provider, and their storage tier.

Note; aws and b2 prices are in USD, scaleway use EUR. I converted the EUR to USD on 16th Feb 2021.

time complexity

Fri, 12 Feb 2021 13:27:24 +0000

When solving problems using a computer, we assign “time classes” or time complexities to the problems to describe how long that problem will take to solve.

They look something like this image;

You can see on this graph the difference between the “amount of data” and “the time taken to find the solution” (e.g. process the data).

“good” time complexity

Most problems are linear, that is as the amount of data increase, the time take increases proportionally. Sending a different email to each team member is a linear task. As the number of team members increases, as does the time taken to send all the emails.

raspberry pi 4: nas and home server

Sat, 30 Jan 2021 17:43:51 +0000

Completed build

Component list

Raspberry Pi 4 (4GB)
Raspberry Pi official USB-C power supply
2x Gigabyte 1TB SSD
2x StarTech.com USB 3.0 to SATA HDD/SSD Adapter Cable
TerraPi Alpha case: dual SSD (link)
52Pi Low-Profile ICE Tower Cooling Fan

Build notes

The build is pretty simple, these notes are where I diverged from the instructions that came with each of the components.

Cooler + Alpha case compatibility

As can be seen in this official picture, the alpha pi case comes with a fan attachment for the top.

custom annotation naming

Tue, 05 Jan 2021 13:24:29 +0000

Custom annotations in Java should be named to describe what’s required of the method, and not which functionality we would like applied.

For example;

1

@RequiresRole(role = ADMIN)

Instead of;

1

@CheckRole(role = ADMIN)

If we start naming our annotations after “how” they work, and not “what” we want, we go down a route of also describing the edge and error cases. It’s very easy for a @CheckXYZ annotation to start accepting parameters that control; how the exception is thrown, which type of exception, etc.

estimate, predict, forecast

Mon, 04 Jan 2021 13:18:01 +0000

We are often asked, as engineers, to give estimates for how long a piece of work will take to complete or the complexity of the work.

This is not a post about the philosophical point on if we should estimate. This post proposes a change in the way we think, to help make estimates easier and more useful for everyone.

what are estimates?

An estimate is:

To calculate approximately (the amount, extent, magnitude, position, or value of something).

mfa key recovery

Tue, 08 Dec 2020 15:29:27 +0000

Some SaaS tools mandate multi-factor authentication (MFA), but this is bad for security and bad UX, until someone solves key recovery.

Multi-factor auth revolves around two proofs:

proof	example
Something I know	password
Something I have	multi factor device; e.g. smart phone with rotating code, phone number, hardware key like yubikey

MFA (depending on implementation) creates much stronger account security, particularly from leaked passwords. The problem is with humans.

If we ignore the class of security breaches where a human is deceived (e.g. phishing), we are still left with: humans are prone to mistakes. We will always lose our multi-factor device. Without the second factor, we still need some means of logging into our accounts.

inclusion

Fri, 04 Dec 2020 10:04:00 +0000

As a team grows, inclusion becomes harder.

When we were a very small startup, our engineering team was 3 people. With a small team, it makes sense to include the team in decisions. Not including an individual team member accidentally sends a strong message about their value and contribution.

As we grow as a business, inclusion needs to adapt also. It’s no longer feasible to include every team member in every decision.

naming is hard

Mon, 05 Oct 2020 09:27:26 +0100

Software engineers use convergent thinking

As software engineers, we engage in a type of thinking called “convergent thinking”. According to wikipedia this is:

[A] type of thinking that focuses on coming up with the single, well-established answer to a problem.

In code we have many different names for this, but they all boil down to the same thing: convergent thinking.

But we don’t call it ‘convergent thinking’, instead we call it:

syncthing

Thu, 28 May 2020 06:47:40 +0100

Syncthing is a peer-to-peer file sync app, this means that each of your devices communicates with it’s peers, within your own private syncthing network structure. To enable this, you need to decide how you want your devices to interact with each other.

Syncthing has the concepts of ‘devices’ and ‘folders’. Devices are the participants in your peer-to-peer network. Folders are a grouping of files that have the same sharing properties. A single folder can be configured to be shared with all, or just some, or the devices on your network.

hyperoptic ipv6

Wed, 15 Apr 2020 11:35:17 +0100

Setup third party router to work with hyperoptic IPv6

Hyperoptic, the UK ISP, offer IPv6 support. Here is a link to their FAQ page: https://www.hyperoptic.com/faq/posts/static-ip-addresses/

But I had to configure my router manually to get provisioned with an IPv6 address.

Steps from hyperoptic

Hyperoptic share some steps for setting up a 3rd party router in the FAQ post linked above. Those steps are:

Navigate to WAN interface section of router web GUI
Select dual stack option for WAN interface (IPv4/IPv6)
For address/prefix source select DHCPv6 (not static option)
Enable prefix delegation (PD)
Select SLAAC for IPv6 address creation method

I use a TP-Link Archer A7 1750 router, and many of these steps had a direct equivalent.

video conferencing

Thu, 09 Apr 2020 15:52:35 +0100

Many of us have moved to remote working, due to corona virus. I’ve been working remotely for the last 5 weeks.

The following are some of the improvements that I have adopted:

External webcam

Webcam always on

Having video on is much more engaging for participants, and helps to mitigate some of those visual communication cues that you might miss out on when working remotely.

The gitlab company handbook does a better job of describing these points. Link to the handbook: gitlab.com

what makes a good software engineer?

Thu, 26 Mar 2020 07:58:05 +0000

I came across this question, and it got me thinking. This a result of that thinking.

How would you find out if somebody is a good software engineer?

When answering this question, you must first detail what you are testing for. This leaves you with some questions, the following are some of those questions:

What is the problem domain?
What are the external constraints of the system they are working within?
What are good and bad characteristics / abilities in the context of the problem?
What tests will bring these characteristics to light?

Answering these questions will allow you to start to define “success”. Importantly these “success” criteria take into account the environment that the engineer is working in.

pr checklist

Sun, 22 Mar 2020 19:50:06 +0000

This post contains checklists that intend to increase the value received from, and ease of, the code review process.

checklists reduce complexity

Checklists help to capture the information that we often forget. This post is aimed at software engineers who review code. This code review checklist covers the following areas:

Preparing for code review: preparations sets your reviewers up for success.
Performing a code review: think before you react, share your intentions and goals.
Responding to a code review: what to do when you’ve received the review.

You have a responsibility as the PR author and PR reviewer to make a code review function well. Code reviews are not just an input by the reviewer. There are things that the PR author can do to achieve the most value from a review.

mvp service level objectives

Mon, 02 Mar 2020 14:54:38 +0000

Apply “Service level objectives” to product requirements to get an MVP. SLOs help to decide the level of service that a product will provide to a customer. SLOs are often used to define or describe the error budget of a service in the Site Reliability Engineering world.

Google SRE book “service level” definitions.

We can apply SLOs to product requirements, to build define an MVP.

Let’s follow a concrete example:

beware anecdotal evidence

Mon, 17 Feb 2020 11:51:55 +0000

Anecdotal evidence comes in many forms, and sounds most believable.

Anecdotal evidence is evidence from anecdotes: evidence collected in a casual or informal manner and relying heavily or entirely on personal testimony.

– wikipedia

Anecdotal evidence takes different forms. I’ve encountered many team members who are vivid storytellers, drawing from previous experiences with phrases like:

“this is how I’ve seen it done before”
“at my previous job we did…”
“a former mentor of mine said to me…

The problem with anecdotes is that they cannot be assessed. This opens them up to a range of issues and biases, that it’s not possible as the person listening to the anecdote to correctly evaluate. Memories are not objective representations of the situation, and will suffer from selection and survivorship bias (the belief that because something went well, it was the right thing to do). Anecdotes suffer from availability bias, the more recent the information consumed, the more weight and relevance associated to it.

data modelling in saas apps

Wed, 29 Jan 2020 15:19:49 +0000

Article originally posted on medium.com

–

When building a SaaS application, there are some similarities between apps, regardless of the service that they provide. This article lays out some of the most common cases, and the errors that it’s easy to make. We all have pre-conceived notions of how some flows should work, e.g. “login”. Perhaps those notions do not well translate into a flexible data model that allows for changing requirements. Below are some “rules of thumb” to help avoid some of the most common pitfalls. This is not meant to be an extensive of definitive guide, only food for thought. The examples below use a mixture of relational and document store modelling. The examples are only to support the point being argued and not to serve as a reference implementation.

effectiveness as an engineer

Mon, 20 Jan 2020 08:15:42 +0000

Your effectiveness as an engineer is not defined by the output that you deliver.

Software engineering is what happens to programming
when you add time and other programmers.

Russ Cox

Programming is the pure and simple out out of instructions that tell a computer how to do some task. It’s the purest type of code writing, you and the machine. It’s “getting a program to work”, it’s “solving a problem”. Programming is a solo activity, you and the computer. Your effectiveness as a programmer can be measured in terms of how well the program works.

brooks law, hierarchy, and async comms

Thu, 16 Jan 2020 08:08:35 +0000

brooks law

There’s a thing called “Brooks Law” (from mythical-man-month) which explains some of the reasons that software goes slower when adding more humans to a project.

One of the points that the “law” states is that:

there’s a combinatorial explosion of communication channels as the number of people in the team rise

When we consider what this looks like visually

… it’s clear that as the number of people in a team rises, the number of communication pathways explodes.

experienced engineers pattern match

Wed, 11 Dec 2019 12:25:17 +0000

Software engineering is complex not complicated.

Developing software is often more complex than it is complicated. That’s to say; the number of components involved in the development of a non-trivial system is large enough to increase the complexity. Complexity is not difficulty.

Complicated refers to the difficulty level, there might be few components but it will take a lot of hard work to solve.

Given many of the jobs of software engineering can be distilled down to…

short vs. long lifetime structs

Tue, 26 Nov 2019 16:51:49 +0000

Short vs. Long lifetime structs

Much of the go code that we write the structure of; do some operation that might fail, return value and error, handle error if present, continue with value. Here’s an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


func (s Service) Login(userID int64) error {
 user, err := s.repo.User(userID)
 if err != nil {
 return User{}, fmt.Errorf("fetch user: %w", err)
 }
 
 // trimmed

 return nil
}

This is a relatively simple example, but I will show how with multiple method calls which return errors, the intent of the original function can easily be confused or lost in the noise of error handling.

go 1.13: errors.As(...)

Sun, 27 Oct 2019 09:32:51 +0000

Use return values on errors behaviours when testing with errors.As(...)

For an overview of go1.13 errors package, read the go blog post. It describes two new functions errors.Is(...) which operates like an equality check and errors.As(...) which operates like a type assertion.

The example in the blog lists:

1
2
3
4
5
6
7


var e *QueryError
if errors.As(err, &e) {
 // err is a *QueryError, and e is set to the error's value
}

// Similar to:
// if e, ok := err.(*QueryError); ok { … }

Dave Cheney describes error handling patterns in this blog post and recommends omitting constants and sentinel errors in favour of errors with behaviours.

cube2222/octosql: query tool

Fri, 19 Jul 2019 06:41:26 +0100

Octosql is a query tool that allows you to join, analyse and transform data from multiple databases and file formats using SQL.

https://github.com/cube2222/octosql/commit/22f13777ef0182a0e1bcd6a2dbbc64c6197c2d3d

the power and danger of consistency

Thu, 20 Jun 2019 08:02:49 +0100

Humans crave to be, or appear to be, consistent.

This craving, when combined with commitment (notably public commitments) and you have a powerful and dangerous combination.

Consistency in software engineering is often thought of in code formatting, or data retention contexts, but the most interesting consistency is in interactions between engineers and decision making.

Consistency presents in different ways

On the underground in London, I often notice an curious interaction between passengers: there will be an empty seat, and neither of the commuters will want to sit in it. Even if this means standing in a more cramped and busy environment. (Lets put health / physical well-being reasons aside for a moment).

high performing teams burnout together

Thu, 02 May 2019 08:07:51 +0100

High performing teams have a number of characteristics that contribute to their success. They have high context culture and each of the individuals are highly aware of their contribution and impact on the team. They have a high level of group EQ and consider the emotions and needs of each of the team members.

These desirable characteristics of teams also make all the team members highly susceptible to the same set of external factors that could cause burnout for an individual team member. That is to say…

metrics for team contributions

Mon, 29 Apr 2019 06:41:09 +0100

SMART goals

The best goals have metrics associated to them, one method of setting goals is to make them SMART.

1
2
3
4
5


S - Specific
M - Measurable
A - Achievable
R - Realistic
T - Timebound

The M, and T of smart can be hard to quantify without overly intrusive metrics recording. Often time-recording is very poorly implemented and in SRE terms this “overhead”…

Administrative work not tied directly to running a service. Examples include hiring, HR paperwork, team/company meetings, bug queue hygiene, snippets, peer reviews and self-assessments, and training courses.

kubernetes generated names

Fri, 26 Apr 2019 09:26:38 +0100

Naming is hard

Naming is hard, especially for kubernetes resources that are some of the lowest possible deployable units, like pods, replication controllers and jobs.

Some of these resources cannot be changed once they are created. e.g. re-running a job with a different image version is not possible without changing it’s name.

But there’s a generateName field on the yaml manifests that we can use instead:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


apiVersion: batch/v1
kind: Job
metadata:
 generateName: rerunnablejob-
 labels:
 app: rerunnablejob
spec:
 template:
 spec:
 containers:
 - name: myjob
 image: my/image:v0.0.1
 args: ["container", "arguments"]
 restartPolicy: Never

Now when the job is started it will get a unique generated name like: rerunnablejob-zgj92.

docs requirements

Thu, 11 Apr 2019 09:29:38 +0100

All organisations need the ability to share knowledge and written communication is one of the most scalable forms. But in many orgs, docs don’t get the love they need to succeed.

Writing is hard and I’ve seen many engineers that don’t think that being able to write well is a skill that’s useful. I think that written communication is the most important for if your org wants to scale without huge meeting overhead. I don’t want to touch on what makes good writing, or even what makes good documentations. Instead, lets look at what environment your documentation needs to succeed and get the love it deserves.

Evolution of application monitoring: Linkerd2

Thu, 11 Apr 2019 08:18:34 +0100

London Microservices User Group - April 2019. Hosted at FarFetch.

This talk focuses on the how we have evolved our approach to application monitoring at Attest over the last 3 years that I’ve been working there.

Overview

Link to slides.

Starting with the history of attest, we walk through the very basic approach we had to monitoring and alerting back in April 2016. Touching on each of the changes that we made taking the architecture and platform through:

git: co-authored by

Fri, 29 Mar 2019 08:19:47 +0000

1

Co-authored-by: <zknill@users.noreply.github.com>

You can attribute a commit to more than one author by adding one or more Co-authored-by trailers to the commit’s message. Co-authored commits are visible on GitHub and can be included in the profile contributions graph and the repository’s statistics.

Source: github

Co-author feature on github allows more than one author to be attributed to a commit. But for what purpose? If we consider the purpose of the origial Author: field of a git commit it has a number of purposes:

linkerd: a conversation with real platform owners

Thu, 28 Mar 2019 22:14:04 +0000

Best practices for monitoring application health on Kubernetes

This webinar digs into observability, and how linkerd and other tools can help with the observability and alert response landscape.

As a panelist I contributed to the discussion and added unique insight into vetting linkerd2 and it’s impact in production and it’s differences from linkerd1.

We touched on how linkerd helps and some tips to take back to your own orgs.

Link to the video.

linkerd/linkerd2: support for daemonsets

Mon, 25 Mar 2019 21:53:56 +0000

Support for DaemonSets

Linkerd2 is a service mesh and network proxy.

Add daemonsets to all observability commands and add dashboard support.

https://github.com/linkerd/linkerd2

micromanagement

Mon, 25 Mar 2019 17:04:14 +0000

The creeping and insidious nature of micromanagement

Micromanagement:

In business management, micromanagement is a management style whereby a manager closely observes and/or controls the work of his/her subordinates or employees.

Insidious:

proceeding in a gradual, subtle way, but with very harmful effects.

Micromanagement is insidious, it’s creeping. We never know we have it or it’s affecting us until we are deep in it’s grasps. At this point the organisational change required to undo it is possible too large for anything meaningful to happen.

go get private repo

Mon, 25 Mar 2019 16:43:38 +0000

Go Modules

Go modules is becomming the standard go dependency tooling. It reuses teh go get command that’s been around for a long time.

go get doesn’t automatically handle private repos well.

If you usually clone repos using ssh, then you need to run the following git config command:

1

git config --global url.'git@github.com:'.insteadOf 'https://github.com/'

It updates $HOME/.gitconfig with:

1
2


[url "git@github.com:"]
	insteadOf = https://github.com/

Then you can:

Keeping a logbook with vim

Wed, 20 Mar 2019 17:43:44 +0000

There’s a lot to be said for embracing basic tools for getting stuff done. Keeping track of notes is a great example of where some basic tooling can achieve the same result as paid services.

My setup

Vim, some aliases and templates
Dropbox, for sync
Grep, for search

File Structure

I keep a single file for each day of the year, using the date format: YYYY-MM-DD. This makes search easy. Terminal completions in zsh shell work well with this format.

2018: reading list

Sun, 16 Dec 2018 14:17:57 +0000

The computing book’s I’ve read…

The Go Progamming Langauge - Alan A. A. Donovan and Brian Kernighan

This is a golang language bible. It contains great material for both beginners and pros. Including some strong documentation on more advanced topics like reflection.
Design Patterns: Elements of Reusable Object-Oriented Software - Erich Gamma, John Vlissides, Ralph Johnson, and Richard Helm

Sometimes called the “gang of four” book, this is a classic.

the cost of extrinsic motivators

Sun, 25 Nov 2018 13:19:48 +0000

The best output comes from engineers who are intrinsically motivated, according to Dan Pink in his book “Drive”. He details strong arguments around how complex, creative, right brain work is hindered by extrinsic motivations (e.g. pay for performance schemes) and is bolstered by intrinsic motivations (e.g. the internal desire to achieve, the feeling of accomplishment).

As an industry we’ve already identified that many of the pay for performance style schemes and metrics are detrimental to the creation of stable software. Measuring software engineers on lines of code or tickets delivered is commonly accepted as flawed when the desired outcome is a correct and bug free product. Measuring performance on lines of code, both max and min, creates an environment where engineers start optimising for the metric, which is detrimental to the quality of the codebase.

options make decisions

Sat, 27 Oct 2018 17:01:30 +0100

We are makers and solution creators, and as makers optimising for solving problems it’s easy to focus on a working solution. The problem is solved.

But as in refactoring, where a working solution is not “done” (there’s a whole bunch of reorganising and rework that makes the solution beautiful, not just functional), a solved solution should not be the goal of problem solving.

The best solutions come from options, the best solutions come from multiple solutions. Sure you may come up with the best choice immediately. You may think of other alternatives, dismiss them and conclude that your original idea is the best. Now your original idea is validated by the dismissal of the competing alternatives.

Limitations of EKS

Thu, 20 Sep 2018 13:38:08 +0100

On Sep 5, 2018 AWS announced EKS availbility in eu-west-1 (Ireland). So I checked it out; this post covers some of the limitations.

Pod limits per instance type

The EKS networking CNI plugin used github exploits elastic network interfaces (ENIs) and attaches them to the EKS worker node instances. This allows the instance to have more than one IP, and each pod on the node gets one of those IPs.

There are limits to the number of ENIs you can attach to each instance type, and how many IPs that ENI can have. Each pod gets an IP, including those running in the kube-system namespace, such as kube-dns, kube-proxy, aws-node etc.

go concurrency correctness

Tue, 04 Sep 2018 06:51:47 +0100

Go has great concurrency support and as with all concurrent code, it’s very easy to write code that’s doesn’t perform as expected or intended. This is a look at correctness in concurrent go, and some of the considerations.

correctness

How do we define correctness, the dictionary definition is:

“the quality or state of being free from error; accuracy.”

But as a whole, correctness is a deep and well read computer science topic. It includes a basis for formally verifying a program; the act of proving or disproving an algorithm, with respect to a formal specification.

proverb driven development

Wed, 29 Aug 2018 06:18:48 +0100

Learning to drive at 17, my instructor had a bunch of proverbs or phrases that he used to describe different situations that you’d be in as a driver, and what your reaction to them should be.

Keep it simple, keep it safe
Only a fool breaks the 2 second rule
When in doubt, don’t go out
Less space less speed
Gears to go, brakes to slow

All of them are applicable to software engineering. Lets break them down, one-by-one.

go's anonymous functions in loops

Sun, 13 May 2018 18:05:41 +0100

In May 2017 I wrote a post about some gotchas in golang from my first few years with the language.

In that post I included this example code:

1
2
3
4
5
6
7
8
9


var printers []func()
strings := []string{"a", "b", "c"}
for _, str := range strings {
	printers = append(printers, func() { print(str) })
}

for _, print := range printers {
	print()
}

When run this will always give the output:

1
2
3


c
c
c

This example is an interesting one, because it’s a serial example of a deeper, often concurrent problem. The following is a breakdown of the serial and concurrent versions of this problem and an explantion of why they happen:

programming mental models

Fri, 20 Apr 2018 15:48:01 +0100

mental models

As complexity grows in projects, decision making, planning, modelling, reasoning, programming! I’ve found that it’s far easier to make correct decisions using a more structured way of thinking. For this I use mental models;

So… What is a mental model?

definition

“A mental model is an explanation of someone’s thought process about how something works in the real world. It is a representation of the surrounding world, the relationships between its various parts and a person’s intuitive perception about his or her own acts and their consequences.” wikipedia

working with me

Wed, 14 Mar 2018 19:52:11 +0000

What it’s like to work with me

The easiest way to understand someone you work with, or might work with in the future, is to understand a little about them and how they work.

I expect the best from those I work with. I expect people to deliver a task to the best of their ability. Sometime I set high standards for what I think you can achieve, which might lead to a difficult code review when you don’t reach that standard. I’ve found it always better to expect the best from people. If you think I’ve been unfair, feel free to call me out on it. I can quickly check myself.

go ast got visitor pattern wrong

Sun, 25 Feb 2018 18:21:39 +0000

what’s a visitor?

According to wikipedia:

“The visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existent object structures without modifying the structures. It is one way to follow the open/closed principle.”

The Visitor pattern, as described in wikipedia allows you to “Visit” a structure in a way that doesn’t require the structure to change. This is particularly good in scenarios such as traversal of trees.

libraries considered harmful

Sat, 06 Jan 2018 18:42:10 +0000

libraries considered harmful

Library is shared code that you cannot otherwise name. It is a confused amalgamation of different parts of code, different usages and different business rules. It serves more than a single purpose, and thus; no well defined and clear purpose. It is hard to update, hard to work with, and hard to use.

Many of us get a nasty feeling when some shared code ends up in a package or class called Util. Why is this?

Delivering Language Agnostic Microservices

Fri, 05 Jan 2018 17:59:34 +0000

I work for a company called Attest, and we transitioned from only a very small number of services to many more with the ability to create new ones easily (and monitor and manage them!) This talk (video) focuses on some of the language agnostic changes that we made to enable the delivery of small, well defined services… microservices!

In the beginning

At the start when you only have a very small team, few enough to feed with 2 pizzas, you don’t need a distributed system. You don’t need a microservice architecture. Instead you can have one main app, a monolith, that does everything. Something like this:

slack @here is bad for your team

Tue, 19 Dec 2017 19:33:09 +0000

@here Notify active channel members

The slack help docs say the @here mention;

…lets you notify just the members in a channel who are currently active in Slack.

Alright, that sounds great. It’s for making announcements / contacting the team right? Well no. Slack is best at async but instant communication for teams. @here ruins that.

Cross pollinate teams

Your company is probably made up of a bunch of different teams, sales, marketing, engineering etc. And there are many reasons why the commercial side of your business should be open to input from engineers. Not only because it reduces the number of communication paths, reduces layers of overhead and focuses your engineers on users and commercial goals; but because the cross pollination of ideas helps all the teams involved.

zknill/builder: java builder class code generator

Mon, 20 Nov 2017 08:01:04 +0000

builder generates a class that implements the builder pattern.

The command:

1

builder -s title --class BookTitle

Generates:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public static class Builder {

 private String title;

 public Builder title(final String title) {
 this.title = title;
 return this;
 }

 public BookTitle build() {
 return new BookTitle(this);
 }
}

There are a number of different flags that represent different variable types, use builder --help for info.

Delivering Go Services

Sun, 19 Nov 2017 19:41:34 +0000

Go London User Group - 15th November 2017

Video

This talk focuses on delivery of go services and some of the changes that we made to bring golang into our stack, and optimise our delivery pipeline.

mastering golang taught me java

Mon, 13 Nov 2017 15:07:51 +0000

I spend much of my time writing go, but the rest is occupied predominantly by java. It’s a well known idiom that new languages at least take inspiration from (if not recycle) the best features of previous language. There’s a lot to be taken from the similarities between languages.

This is a comparison of go and java and some of the go features that have made me write better java.

masterminds/semver: work with semantic versions in go

Wed, 04 Oct 2017 15:54:54 +0100

The semver package provides the ability to work with Semantic Versions in Go. Specifically it provides the ability to:

Parse semantic versions
Sort semantic versions
Check if a semantic version fits within a set of constraints

on meetup talks

Sat, 15 Jul 2017 20:49:47 +0100

I recently gave a talk at London Microservices User Group meetup - video here.

These are some rules I tried to live by:

who’s the audience?
what’s your story?
what’s the learning?
get feedback.
don’t be scared to not know.
don’t be scared to share what you know.

who’s the audience?

Know who you are talking to. Whatever the subject of the talk, make sure it’s appropriate for the venue and group that you are talking too. Go along to a few of the meetings, watch some videos from previous events, find out everything you can in advance.

Go Microservices: Proof of Concept to Production

Fri, 07 Jul 2017 22:05:22 +0100

London Microservices Meetup - 5th July 2017

Video

Go is a powerful language, but there are a few gotchas. This talk will cover transitioning a proof of concept to a production ready go service, the decisions to be made, the benefits and the pitfalls, and what we liked and disliked about it doing it ourselves.

building blocks of go services

Sun, 28 May 2017 16:23:43 +0100

Go has many web frameworks, but none that come with the standard library. There are many to choose from but this is a difficult problem. There are advantages to choosing a very well established framework, but also disadvantages like lock-in, support and flexibility. When you do not know what you will required from a framework in 3 / 6 / 9 months, how can you make that choice?

Instead of a built in framework, go provides a number of well thought out building blocks from which you can roll your own! These building blocks mean that frameworks are unnecessary to get you off the ground and are unnecessary when you find you need to add additional pieces to your apps.

golang/dep: dependency management tool

Sun, 28 May 2017 16:06:02 +0100

There are many blog posts, like the one, that do a great job of explaining the history behind golang package management and the need for golang/dep.

Breifly: dep is a package management tool to unite them all, and be merged into the standard go toolchain.

https://github.com/golang/dep

function as an interface

Thu, 18 May 2017 21:03:24 +0100

“An interface type is defined as a set of method signatures.”

Taking a simple example:

1
2
3


type Fooer interface {
 Foo(input string) string
}

golang nameing convention is interfaces that end in er, Reader, Writer, Closer etc..

In this example, the interface Fooer defines a single method Foo, any struct with a method Foo will implement this interface, (implementation is done implicitly).

1
2
3
4
5


type aFoo struct {}

func (aFoo) Foo(input string) string {
 return "foo: " + input
}

But it’s not just structs that can implement interfaces, if an interface has a single method, then you can implement it with a function type.

golang gotchas

Wed, 10 May 2017 18:33:31 +0100

Go is a small language…

1
2
3
4
5
6
7
8


+----------+---------------+
| LANGUAGE | NUM KEYWORDS |
+----------+---------------+
| golang | 25 |
| C | 32 |
| python | 33 |
| java | 50 |
+----------+---------------+

… it has only a handful of keywords, and a small set of language features. This makes it incredibly easy to learn, but it’s not without hiccups. The following is a list of gotchas to be aware of…

structs and named types

Mon, 24 Apr 2017 21:30:48 +0100

I recently blogged about patterns in go and in that we saw how methods on structs can be used to implement interfaces. Specifically the Stringer interface.

Structs, are not the only way to achieve this; all named types offer similar functionality. First - some definitions from the golang spec…

struct types

“A struct is a sequence of named elements, called fields, each of which has a name and a type. Field names may be specified explicitly (IdentifierList) or implicitly (AnonymousField). Within a struct, non-blank field names must be unique.” - golang spec

deepend

Fri, 14 Apr 2017 17:49:51 +0100

getting started

Imagine a world in which you’re a graduate, you’ve just completed your final year. Fresh in your mind is the difference between NP-Hard and NP-Complete problems. You can sort a btree with your eyes closed. You’re ready to become a contributing member of society. Or are you? I have a few tough truths for you…

You don’t know anything useful, yet!
You’re not going to have a clue what you’re doing on the first day…
You’ll always have much to learn.
You’re soon going to find carbs are a bad lunchtime friend.

… but these shouldn’t put you off jumping in at the deepend, it will be the best thing that you do!

patterns in go

Wed, 05 Apr 2017 18:56:00 +0100

In go there are some patterns that make code idomatic, these are some of my favourite…

strategy pattern

“Enables an algorithm’s behavior to be selected at runtime.” Wikipedia

This pattern allows you to pass structs, or objects around that have slightly different runtime behavior without having to worry about the difference. There’s a great talk by Dave Cheney about functions as first class citizens. This talk does a great job of explaning why and how to use functions in some places instead of interfaces, and this is closely linked to the strategy pattern.

developer abc

Sun, 26 Mar 2017 20:24:02 +0000

We all know the acronym ABC…

“Always be coding”

…the idea that the more you code, the better you get. The idea that deliberate practice makes you better. The experience of many more problems makes you better. You grow that gut feel, for when code smells bad, for a problem that you’ve solved before. It’s a natural assumption. But “Always be coding” isn’t enough, there are other C’s that you need to consider. “Consider” being one of them!

downtime

Mon, 20 Mar 2017 21:54:34 +0000

Downtime.

noun

time during which a machine, especially a computer, is out of action or unavailable for use.

Your site is not serving:

There’s been a catastrophic failure and you’ve deleted the directory that your database engine stores data in.
You’re performing database maintenance and downtime is necessary.
You’re executing complex database migrations that result in downtime.

For any developer this is an anxious time. A time when we are all on edge. If the downtime is planned; it’s chosen because it’s the best outcome from your sum cost comparisons. Yet it still doesn’t sit well, you wonder about the affected users. You wonder about the impact. It’s not a place we want to be on a regular basis. If it’s unplanned downtime it’s a whole other level of concentration. A new kind of focus, all thoughts and energy directed towards the fix and bringing your site back up. Never have you been so productive at 3am.

don't fear the junior engineer

Wed, 15 Mar 2017 20:57:05 +0000

The phrase:

“we were all a learner once”

is normally applied to learner drivers, but it also applies to the junior engineer. Just like learning to drive a car, there’s a gap, a void, that has to be crossed. For new drivers it’s passing a test and you are then deemed worthy or capable of handling a car on your own, for engineers there is no “Driving Test” to say you are now worthy. There are many different routes into the industry and most (if not all) of them suffer from this gap, or void.

hello world

Thu, 09 Mar 2017 22:17:00 +0000

1
2
3
4
5
6
7
8
9


package main


import "fmt"


func main() {
	fmt.Printf("Hello, world.\n")
}

zknill/points: a slack and cli leaderboard!

Wed, 28 Sep 2016 15:54:54 +0100

points was born out of a joke in the office…

“10 points to whoever can tell me the answer to …”

So the natural thing to do next was to build a small go program that could track a leaderboard and display the points in a nice format.

https://github.com/zknill/points

points allows you to add names and scores and keeps a tally of who’s in the lead.

points outputs the leaderboard as an ascii table that can easily be shared in your team’s chat.

about

Sat, 22 Aug 2015 00:00:00 +0000

Zak Knill

staff engineer

I work on:

leading teams 🔝
upskilling engineers 💪
solving scaling problems; org, and tech 📈
delivering customer value 🤑

I am a staff engineer, and an org and tech leader. I spend much of my time sharing my knowledge with other engineers and up-skilling. I’m currently working on Realtime data problems at Ably, previously Unweave and Attest. I am a seasoned reviewer of PRs, I give talks, write blog articles and contribute to opensource.

Mon, 01 Jan 0001 00:00:00 +0000

Zak Knill

Staff Engineer // Technical Leader

📡 personal site: https://zknill.io

Mon, 01 Jan 0001 00:00:00 +0000

Home

Mon, 01 Jan 0001 00:00:00 +0000

developer, blog

Hey I am Zak Knill, a core engineer; these are some of my thoughts and bit about me.

License

Mon, 01 Jan 0001 00:00:00 +0000

The MIT License (MIT)

Copyright (c) 2017 Zak Knill

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: