$ ls ./notes --sort=tended
Ideas I keep returning to. Each one is tended over time, from seedling to evergreen.
104 notes · 🌱 18 seed · 🌿 72 growing · 🌳 14 evergreen
104 notes
Case study — raising coverage with network-level mocks instead of brittle ones, shipping features test-first, speeding up quality checks, and getting Playwright adopted across several teams.
The simplest form of "real-time" — ask the server every N seconds. Wasteful at scale, perfectly fine more often than people admit, and the baseline every other technique is compared against.
Put a layer between external APIs and your UI that parses raw responses into your own domain models, so a backend change touches one adapter instead of forty components.
A one-page, version-controlled record of a significant decision. Context, decision, consequences. Never edited after acceptance, only superseded, so the history of "why" survives.
The friendliest of the big statics — tuck to full back lever, with the shoulder extension prep that makes it safe. Full back lever unlocked in 2026; pullouts are next.
A handstand is a feedback loop with a sensor, a delay and an actuator. So are autoscalers, rate limiters and a real-time UI under load — and they fail the same way.
Case study — designing and shipping a React network-graph library for several teams, and why rendering tech, API shape and Storybook mattered most.
Case study — leading the UI of a low-code network automation platform where workflows are drawn as BPMN diagrams. Model-driven editing, server-side permissions and a catalogue of reusable building blocks.
Not a boilerplate but a showcase of architecture patterns — organise a React app by feature, keep data access out of components, and wire in testing, mocking and error tracking from day one.
Once the beginner routine stops working, alternate blocks that build capacity with blocks that turn it into skill, with a deload between. You can't push both at once.
When the network partitions, a distributed data store must choose between consistency and availability. PACELC adds the other half, that even without partitions you trade latency for consistency.
Case study — UI engineers were scattered across backend-shaped scrum teams, under-used and unaware of each other. Making the case for a UI community, then chairing it across departments.
Keep meetings on agenda, translate engineering work into delivery language, and present roadmaps as value, not cost. Most of a lead's influence happens in these conversations.
If you can't explain an idea in your own words, you haven't understood it yet. You've only followed along. Writing it down is how you find out.
A reactive TypeScript backend where your server functions are the API, so front end and back end stay in sync. A natural fit for building with coding agents.
Ab wheel, dragon flag, hanging leg raises and the human flag — anti-extension and compression work that every lever and handstand borrows from.
Deadlock is everyone waiting on each other forever; starvation is one thread never getting a turn. Both are liveness failures, and the fixes are surprisingly mechanical.
Neural networks with many layers, trained end to end by backpropagation — CNNs for images, transformers for sequences, and the bridge from university neural nets to today's LLMs.
Muscles adapt in days, tendons in weeks. Planned deloads and short, spaced bouts of loading keep the slow tissue in step — and the same is true of teams and their tech debt.
Tendons adapt slower than muscles, and organisations adapt slower than code. Schedule the recovery week before an injury schedules it for you.
A design is ready for review when a UI developer, an API developer and a tech lead new to the project could each start building, or challenge it, without asking you anything.
Digital transformation isn't buying tools; it's changing what people do every day. Culture is the sum of small habits, and platforms are how you make the good ones easy.
Parallel-bar dips to rings-turned-out dips. Stability, depth and turn-out are what the ring ladder adds, and why ring dips carried over to my muscle-ups.
Four measures of software delivery, two for throughput and two for stability. In high-performing teams they improve together, so speed and safety aren't a trade-off.
Case study — taking a large React codebase from a long backlog of TypeScript errors to zero with months of small, non-functional merge requests, so the build could finally enforce types.
Sort work by urgent and important. Do, schedule, delegate, delete. Most real progress lives in "important but not urgent", which is exactly the quadrant that gets squeezed out.
NVIDIA's Eureka puts an LLM in a loop around reinforcement learning — it reads the environment code, writes reward functions, trains, reflects on the results and rewrites. A blueprint for closed-loop agents.
Eight assumptions everyone makes about networks, and every one of them is false. A checklist for any design that crosses a process boundary, including the browser.
In a fully asynchronous system, no deterministic algorithm can guarantee consensus if even one node may crash. Real systems get around it with timeouts and randomness, giving up guaranteed termination rather than safety.
The front lever is a torque problem. A back-of-the-envelope segment model shows why each progression is a step in moment arm, why tall people suffer, and why the straddle is less of a shortcut than it feels.
One working directory per branch means no stashing, no reinstalling and no committing to the wrong branch — and it turns out to be exactly what parallel coding agents need too.
The opinionated, fully supported route from nothing to a running service. Optional, but so much easier than the alternatives that teams choose it.
The best developer platforms feel like a good beginner programme — opinionated, safe, explained, and easy to leave once you know why.
For large network graphs, the rendering technology matters more than the API — DOM and SVG struggle past a few thousand nodes, canvas goes further, and WebGL stays interactive at 10k+.
Game hacking and modding forums are, first of all, places where people learn — sharing tools, tutorials and status. The same dynamics that make them great teachers raise the question of where the learning leads.
From pike push-ups to the freestanding handstand push-up — the ladder I'm climbing in 2026, the prerequisites that matter, and why balance becomes the limiter at the top.
The cues that took me from wall holds to a 30-second freestanding handstand — build the base, stack the line, and balance with your hands, not your feet.
A library shared across products never fits any one of them perfectly — ship structure and behaviour, and let each app own the styling.
A periodic "I'm alive" message that lets a system notice when a node has failed. Simple to build, subtle to tune, because a slow node and a dead one look the same.
From a university Zettelkasten to a second brain with an AI librarian — I only capture now, and the system distils, links and brings old ideas back on a schedule.
The "hanging GET" — the server holds a request open until there's news, then the client asks again. Near-real-time over plain HTTP, and still the universal fallback.
You can't push volume and skill at the same time without something giving. Platform roadmaps work better when they alternate building capability with hardening it.
The self-service layer a platform team offers product teams, run as a product with developers as customers. If you have to raise a ticket, it's a service desk, not a platform.
Case study — handing over a platform I'd led the UI of, through structured sessions backed by written docs, a reuse strategy and a clean backlog, so the team could own it without me.
Compression is the quiet prerequisite behind presses, levers and muscle-ups. My L-sit to V-sit ladder, the flexibility it needs, and the drills that move it.
Information is everywhere and almost none of it sticks. Learn less, one thing at a time, then write, build and share — and design your environment so focus is the default.
Log, Review, Discover. Capture with as little friction as possible, review regularly to spot patterns, and make sure every note can be rediscovered later. The loop that runs my second brain.
Learning patterns from data instead of hand-coding rules — supervised, unsupervised and reinforcement learning, and the habit of testing on data the model has never seen.
At-most-once, at-least-once and "exactly-once". Why the network forces you to choose between losing messages and duplicating them, and how idempotency makes duplicates harmless.
"Don't communicate by sharing memory; share memory by communicating." Independent processes exchanging messages over channels, from Go and actors to queues and WebSockets.
Reddit's topic-focused communities make it a rich research source. How to collect posts with PRAW and an archive, how to clean them, and the ethics that keep individuals out of your results.
Intercept HTTP at the network layer so tests, Storybook and local development all hit realistic mocked APIs while your real fetching and parsing code runs.
Turning human language into something machines can work with — tokens, vectors, embeddings — so they can classify, extract, summarise or generate it. From bag-of-words and sentiment lexicons to transformers.
Being able to ask new questions of a running system from its outputs — logs, metrics and traces, tied to the SLOs that turn them into decisions.
What actually makes an online community — shared purpose, interaction, norms, a platform — and why "member" and "participant" aren't the same thing. The literature behind how I framed forum research.
Pairing trades a little throughput for quality, shared ownership and faster onboarding. Pick the style for the goal. Ping-pong for TDD, driver/navigator for design, strong-style for teaching.
My final-year dissertation at Kent. Can topic modelling and network analysis of online communities show whether game hacking and cheating forums lead people towards more serious hacking? The question, the approach, the ethics, and what I'd do differently with today's LLMs.
Single-leg strength for a calisthenics athlete who also runs. Pistols to weighted pistols, shrimp squats to two-hand shrimps, and why single-leg work keeps the knees and ankles honest.
Tuck planche and tuck planche push-ups are in; the advanced tuck is the goal. Lean, protraction and patience — and why planche keeps getting parked behind handstand work.
End-to-end tests in real browsers with accessible locators, auth handled once via saved storage state, network control for deterministic runs, and traces that make CI failures debuggable.
Bent-arm and straight-arm presses to handstand are compression and shoulder problems more than strength problems. What's worked for me so far, and what's still missing.
React escapes what you put in JSX, so most XSS comes through the escape hatches — dangerouslySetInnerHTML, direct DOM writes, javascript URLs and third-party scripts. Defend in layers.
Procrastination is emotion management, not laziness. Reduce the friction with a clear, small next step and a protected block of time to start it.
You don't add 40kg to the bar overnight, and you don't rewrite a system in one go — small, steady, measured increases win both times.
From the first strict pull-up to ring archers and one-arm chin negatives. The vertical pulling ladder, the cues that made it click, and how I'm approaching the one-arm chin-up.
A consensus algorithm designed to be understandable. Elect a leader with randomised timeouts, replicate a log, and commit entries once a majority has them.
Put logic in plain functions and unit-test them; test hooks and pages as integration tests against a mocked network; assert only on what users can observe.
On a bad training day you drop to an easier progression rather than grinding ugly reps. Systems under stress should do the same — shed the expensive work, keep the core going.
An agent takes actions in an environment to maximise reward. The vocabulary — policy, reward, rollout — and why reward design is the hard part.
Scan for leaks, rotate first, rewrite history with regex patterns rather than literal lists, and add a pre-commit scanner so it never happens again.
Case study — putting a declarative API gateway in front of a platform's microservices with little dedicated ops support. Versioned routes, stable names, one place for CORS, and validating locally before asking for anything.
Specific Adaptation to Imposed Demands — you get good at exactly what you train. Systems and test suites do too, so make the training look like production.
Specific Adaptation to Imposed Demands — you get good at exactly what you practise. Tests and staging only prepare a system for the conditions they simulate.
One-way server-to-client streaming over plain HTTP, with automatic reconnection built into the browser. The simplest right answer for feeds, progress updates and streaming AI responses.
Find defects where they're cheapest to fix, in refinement, the editor and the pull request. But shift-left means early feedback, not running every expensive test at the earliest stage.
Draw a platform roadmap like a calisthenics skill tree — prerequisites, tiers and mastery levels — so it's obvious what's locked until the foundations are in.
The SLI is what you measure, the SLO is your target for it, the SLA is the promise with consequences — and the error budget turns all three into release decisions.
Case study — building a broadcaster's streaming app for many TV platforms at Accedo. Memory and performance work for slow devices, a back-navigation model that finally made sense, a full rebrand, and a knowledge-sharing culture.
Modelling people and their interactions as a graph to find who's influential, which communities form and how behaviour spreads. Centrality, clustering, Louvain community detection, and why graph thinking travels so well.
SOLID translated into React habits — separate data from rendering, extend through composition, keep props minimal and depend on abstractions you pass in.
Spaced repetition is testing plus time. Recall something just as you're about to forget it, at growing intervals, and it sticks for months with far less effort than cramming.
Mocking fetch or your own API modules couples tests to implementation and quietly re-implements your backend in every test file. Mock the network boundary instead.
Components rendered in isolation, one story per state — living documentation, a test bench and a stakeholder demo in one. Most valuable when every requirement gets a story.
Coordinating access to shared resources (critical sections, mutexes, semaphores, monitors) so concurrent code only ever does safe things.
Red, green, refactor is less about tests than about tight feedback — and in the age of coding agents, a failing test is the clearest instruction you can give.
Getting several nodes to agree on one value despite failures, defined by agreement, validity and termination. It's the problem underneath leader election, replicated logs and distributed locks, with Paxos as the classic answer.
The muscle-up isn't a pull-up plus a dip; it's the awkward bit in between. False grip, pulling height and a fast lean-over are what got me from zero to eight ring muscle-ups.
Your brain is good at having ideas and bad at storing them. A trusted external system for what you learn means you never start from scratch, and ideas get recycled instead of lost.
Program vs process vs thread, and the three "multis" (multiprogramming, multiprocessing, multithreading): the units every concurrency discussion is built from.
Latent Dirichlet Allocation treats each document as a mix of topics and each topic as a mix of words. It's unsupervised, fast to try, and still a useful explainable baseline next to embeddings and LLMs.
When time comes in smaller blocks and sleep is broken, the minimum effective dose, short explosive sessions and a flexible schedule keep progress going — or at least keep the skills.
A coordinator asks every participant to prepare, then tells them all to commit or abort. It gives atomic distributed transactions, but blocks if the coordinator fails at the wrong moment.
Crash, omission, timing and Byzantine failures, from "it stopped" to "it lies". Knowing which ones you're designing for decides how much machinery you need.
From 60 wpm hunt-and-peck to 100+ touch typing, a detour through Colemak and back, and the split-keyboard, mouse-free setup I use now.
A persistent, two-way channel between browser and server. Brilliant when both sides talk often; the price is stateful connections you now have to scale, heartbeat and reconnect.
The two strength lifts that underpin most of my skills, logged relative to bodyweight. How I programme them, when to test, and where their carry-over runs out.
A chatbot answers; an agent perceives a change, reasons about a goal, plans, and takes several actions with tools to get there.
Buy what's generic, build platforms for supporting capabilities, and leave the core to product teams — Domain-Driven Design as a map for platform investment.
People are more willing to see hacking as legitimate when they feel a system or authority won't listen to them, and they're angry about it. A psychology finding with uncomfortable lessons for organisations.
Your wrists are the actuator, the sensor and the weak link of a handstand. What a pressure-mapping study says about where the load goes, and the prep and cues that kept mine happy.
Specialise for a block. Two or three goals at a time beat ten — in training, where goals compete for recovery, and in teams, where they compete for attention.
A slip box of small, linked, permanent notes written in your own words. The value isn't storage; it's the connections you're forced to make, and the surprises they produce later.
Run slowly enough to stay in zone 2 for the whole session. It builds the aerobic base that makes everything else recover faster, and progress shows up as a faster pace at the same heart rate.
For high-frequency socket data, write messages into a store and let only the leaf components subscribe — or skip React rendering entirely for the hottest values.
No notes match those filters — .