Pauls Blog

Sample data

Sun, 03 May 2026 00:00:00 +0000

The Strategic Case for Programmable Sample Data

I. The Core Thesis

Manual database entry is a bottleneck that introduces inconsistency. The most effective way to ensure environmental parity and development velocity is to treat sample data as code. By leveraging business services to seed the database with deterministic, UUID-based records, teams create a stable foundation for testing, UI development, and collaborative debugging.

II. Supporting Arguments

1. Enforcement of Business Logic via Service Seeding

A common mistake is seeding a database via direct SQL scripts. This bypasses the application’s validation rules and side effects.

Completing your GitHub Profile

Fri, 01 May 2026 00:00:00 +0000

Completing your GitHub Profile

While I’m looking for a job I thought I’d find out how I could improve my Github profile. This was the advice I found…

1. Fill in your profile — properly

Most developers leave half the sidebar blank. Don’t.

Bio: Don’t just write your job title. “Senior Software Developer” tells nobody anything. “Senior Software Developer — Kotlin, Spring Boot, clean architecture” tells a recruiter immediately whether to keep reading.

Diary 2026-05

Fri, 01 May 2026 00:00:00 +0000

May 2026

Things I’m seeing/reading/watching/listening to in May 2026…

Podcasts

Stepchange - The grid

Stop Serving PNG: Switch to WebP

Thu, 30 Apr 2026 00:00:00 +0000

Stop Serving PNG: Switch to WebP and Cut Your Image Sizes by 80%

WebP is the modern image format your website should already be using. Google’s cwebp tool converts your existing PNG and JPEG files to WebP in seconds — and the results speak for themselves: a 1,434 × 1,522 PNG at 371 KB becomes a 74 KB WebP file. That’s an 80% reduction with no visible quality loss.

The Bottom Line

Use WebP for all web images. Install cwebp, run one command per image, and dramatically reduce page load times without sacrificing quality.

Markdown is for the Web, AsciiDoc is for the Docs (and CVs)

Mon, 27 Apr 2026 00:00:00 +0000

We all love Markdown. It’s the lingua franca of the modern developer—the default choice for READMEs, GitHub comments, and even this blog. But recently, I hit a wall with it while trying to polish my CV.

Markdown is fantastic for structure, but it’s historically weak on presentation, especially when it comes to converting to PDF.

The Problem with Markdown PDFs

When you want to convert a Markdown file to a professional-looking PDF, you usually have two choices:

Eliminate PR Noise with ktfmt

Tue, 21 Apr 2026 00:00:00 +0000

Few things are as frustrating during a code review as seeing a 50-line diff, only to realize that 45 of those lines are just re-ordered imports or adjusted indentation. This is “PR noise”.

In the Kotlin world, ktfmt is one of the best tools to solve this. Developed by Meta, it’s a deterministic formatter that ensures every developer on your team produces the exact same output, regardless of their individual IDE settings.

AI-Assisted Engineering: From Implementation to Specification

Mon, 20 Apr 2026 00:00:00 +0000

The more I use AI to assist with coding, the more I realize that context is the primary currency of effective assistance. The quality of the output is directly proportional to the quality of information available to the assistant.

This realization has fundamentally changed how I work. I’ve started treating ADRs (Architecture Decision Records) and design documents not as “after-the-fact” documentation, but as essential inputs to be versioned in Git alongside the code. Goodbye Confluence; hello documentation-as-code.

Hugo Simple Beauty Theme

Mon, 20 Apr 2026 00:00:00 +0000

Github

https://github.com/prule/hugo-simple-beauty

Hugo Simple Beauty Theme

A minimalist, clean, and highly readable Hugo theme designed for personal blogs, book summaries, and technical writing.

Features

🎨 Design & UI

Minimalist Aesthetic: Focuses on typography and whitespace for an editorial feel.
System-based Dark Mode: Automatically respects OS preferences with a dedicated manual toggle.
Responsive: Fully optimized for mobile, tablet, and desktop.
Typography: Uses the modern Inter font for UI and the elegant Lora serif for long-form reading.
Smooth Interaction: Built-in smooth scrolling and subtle transitions.

🛠 Technical Features

Adaptive Syntax Highlighting: Custom-themed code blocks that adjust colors for light and dark modes.
Related Writing: Built-in engine suggests related posts based on tags and categories.
Reading Time: Automatically calculates and displays the estimated reading time for each post.
SEO Optimized: Pre-configured with Open Graph, Twitter Cards, and Canonical URLs.
Back to Top: A smart floating button that appears as you scroll.

🧩 Shortcodes

Notice/Callouts: Beautiful styled boxes for info or warning messages.

{{< notice type="info" title="Pro Tip" >}}
Your content here...
{{< /notice >}}

renders as

Diary 2026-04

Wed, 01 Apr 2026 00:00:00 +0000

April 2026

Things I’m seeing/reading/watching/listening to in April 2026…

LG Channels

Apparently LG TVs are supposed to come with an LG Channels app which provides 100s of free streaming channels

LG Channels

My TV is just a little too old (2017) and it doesn’t seem to have it. There are other options though:

Plex
Tubi

Podcasts

AI

Lots of AI SDLC tools popping up:

Creating and releasing an application

Sun, 22 Mar 2026 00:00:00 +0000

Creating and releasing an application

I love sim racing, so I thought it would be an interesting exercise to create an application that makes use of Assetto Corsa Competizione (ACC) telemetry.

The basic operation is this:

The client sends a registration message to ACC
ACC replies and starts sending telemetry messages

This is all done over UDP.

ACC messages

The first step was to create a library that could parse the message byte streams. There is a little bit of documentation in the way of some C# code and a ServerAdminHandbook.pdf that can be found in the ACC installation.

Leave planner 1.1.0

Mon, 02 Mar 2026 00:00:00 +0000

Leave Planner helps you track your leave balance and plan future holidays with ease.

Announcing Leave Planner v1.1.0: Work From Home Tracking & More!

This update brings a feature to help you manage your work life better, along with some under-the-hood improvements.

🏠 Work From Home (WFH) Tracking

With the rise of hybrid work, keeping track of the days you work from home is more important than ever, especially for tax purposes. Leave Planner now allows you to easily log your WFH days.

Introduction to F1

Sun, 01 Mar 2026 00:00:00 +0000

Netflix

Drive to Survive is a great introduction to F1, where you can get to know something of the drivers and teams. But you won’t learn much about the sport itself.

Podcasts

One of the best ways to catch up on a lot of information is via the Shift-F1 podcast. Every year at the beginning of the season they publish a Primer in which they’ll “explain how F1 works and who everybody is, all while assuming no prior knowledge of racing”. See the 2026 season primer here .

Leave planner application

Wed, 07 Jan 2026 00:00:00 +0000

Ever wanted to know how much leave you’ll have in the future and easily visualise your balance over time? Sure, some leave systems have some kind of future leave calculator, but none that I’ve seen make it easy or intuitive.

Application available here, on github pages: https://prule.github.io/leave-planner/

The spreadsheet prototype

To scratch my own itch, I started with a google sheet. The principle is simple: Enter your starting balance, and for each month fill in the estimated hours leave accrued. Add in your hours leave taken for the month… and graph the total leave remaining.

YouTube channel aggregator experiment

Thu, 01 Jan 2026 00:00:00 +0000

While trying to keep up with what’s happening in tennis and motorsport, I found myself wondering if the experience could be better. What if I could configure a list of channels, aggregate the videos, tag those videos by looking for keywords in their titles, and then have a convenient way to filter and navigate those.

This provides me with a feed of relevant content which I can view oldest to newest. Watched videos are marked so they disappear from the feed, allowing me to pick up where I left off.

SDKMAN

Mon, 15 Sep 2025 00:00:00 +0000

SDKMAN! lets you install, manage and work with multiple versions of software development kits (SDKs) on most Unix-like systems.

This means for example, you can install multiple versions of Java, Kotlin, Scala, Groovy, Gradle, Maven, Grails, Spring Boot, and many more. See the full list as of mid 2024 here.

Installation

For installation instructions see the SDKMAN! website here.

Usage

For common usage demonstration, using JAVA as an example:

To find all available versions of Java, run:

Introduction to JSON5

Thu, 06 Mar 2025 00:00:00 +0000

Json5 is a superset of JSON that allows for comments and trailing commas. It’s a popular choice for configuration files due to its readability and flexibility.

From the website:

Formally, the JSON5 Data Interchange Format is a superset of JSON (so valid JSON files will always be valid JSON5 files) that expands its syntax to include some productions from ECMAScript 5.1 (ES5). It’s also a subset of ES5, so valid JSON5 files will always be valid ES5.*

Sharing gradle configuration

Sat, 08 Feb 2025 00:00:00 +0000

Source code for this project is available at https://github.com/prule/gradle-sample

When setting up multimodule gradle projects, we often need to share configuration - such as java toolkit version, plugins, junit platform etc…

Previously I would have used the allprojects or subprojects block to do this, but now we have convention plugins. These are locally defined plugins which contain the configuration we want to share. The submodules can then apply those plugins without needing to copy and paste the configuration - this makes it easy to selectively choose which plugins to apply to which module.

Authoring markdown posts in Hugo

Sun, 02 Feb 2025 00:00:00 +0000

Writing Articles using Markdown

The following demonstrates how to create Markdown posts with Hugo.

Dependency upgrades with Renovate

Sun, 02 Feb 2025 00:00:00 +0000

In modern software development, managing dependencies is a critical yet often overlooked aspect of maintaining healthy codebases. Enter Renovate: an open-source tool that automates dependency updates, making your project maintenance both easier and more secure.

What is Renovate?

Renovate is an automated dependency management tool that monitors your repository’s dependencies and automatically creates pull requests when updates become available. Think of it as your personal assistant that constantly checks for new versions of the libraries and packages your project uses.

Week in review 2024-09-22

Sun, 22 Sep 2024 00:00:00 +0000

Week in review - 2024-09-22

https://lucamezzalira.medium.com/how-to-document-software-architecture-techniques-and-best-practices-2556b1915850
- How to document software projects using ADRs, RFCs, and more

A Brief Introduction to AsciiDoc

Sun, 25 Aug 2024 00:00:00 +0000

Note

The source code for this document is available at github . Unfortunately though, GitHub does NOT support includes so you won’t see this document rendered properly. Instead, I’ve used the Intellij plugin to generate a PDF document which you can see here: ReadMe.pdf .

The source code for this document is available at github. Unfortunately though, GitHub does NOT support includes so you won’t see this document rendered properly. Instead, I’ve used the Intellij plugin to generate a PDF document which you can see here: ReadMe.pdf.

Clean architecture - part 1

Sun, 25 Aug 2024 00:00:00 +0000

Clean architecture - part 1

After porting my template app over to Kotlin, I thought it was time to attempt rewriting from a layered architecture to a ports and adapters/hexagonal architecture.

In the layered version, the usual patterns exist:

The domain models ARE the database entities
- The domain model is compromised, cluttered with persistence concerns and far from clean
Services implement the business logic, manipulating the domain (database entities) and persisting them via the repositories
- Unfortunately the services usually end up being classes with a bunch of methods

Week in review 2024-08-25

Sun, 25 Aug 2024 00:00:00 +0000

Roadmap.sh

https://roadmap.sh

roadmap.sh is a community effort to create roadmaps, guides and other educational content to help guide developers in picking up a path and guide their learnings.
Roadmaps based on Role or Skill, plus best practice and questions to test your knowledge

StartDataEngineering.com

https://www.startdataengineering.com

An interesting blog with lots of data engineering information
For example:
- What are the types of data quality checks?
- How to implement data quality checks with greatexpectations
- Why use Apache Airflow (or any orchestrator)?

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

Senior Software Developer

Sydney, Australia (open to remote or hybrid)

References

linkedin.com/in/paulrule/details/recommendations

Summary

Senior Software Developer with 20+ years of experience building robust, maintainable systems on the JVM — primarily Java with Spring Boot, and increasingly Kotlin. Brings a strong emphasis on clean architecture, recognisable patterns, and thoughtful code design: writing software that communicates its intent clearly, encourages reuse, and stays easy to maintain as teams and requirements evolve.

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

GitHub

https://github.com/prule

Laptime Insights (WIP)
- Current project in progress to show a dashboard for ACC laptimes. Practice clean architecture, integration with sim racing software, kotlin/ktor/exposed/websockets.
Data processing experiment
- A coding exercise, design challenge, documentation workout - follows the incremental design and implementation of a configurable data processing pipeline. Each part is in its own branch with its own documentation - be sure to look at the branch “latest” for the end result.
Rest/Hateoas example
- A sample project to demonstrate a rest api with resources containing links to drive the frontend.
- Also see https://github.com/prule/spring-boot-react-hateoas-template/tree/material-ui-spike (the main branch is out of date, look at the material-ui-spike branch)
Jsonata-java fork
- Fork of the jsonata-java library to use BigDecimal instead of float in order to solve the binary arithmetic problem (e.g. https://stackoverflow.com/questions/588004/is-floating-point-math-broken) .

Blog

https://prule.github.io/pauls-blog/

A Game Plan for Product and Software Development

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

A Game Plan for Product and Software Development

The Premise

Most software problems are not technical. A team that consistently delivers working software, adapts to changing requirements, and maintains the capacity to keep improving over time is not doing so because they chose the right framework or the right database. They are doing so because they have internalised a coherent set of practices that compound — each one making the others more effective, and all of them together producing a system that remains comprehensible, changeable, and reliable over its lifetime.

A Pyramid Principle Structure - Software Engineering Excellence

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

This attempts to apply the McKinsey Pyramid Principle to these software development thoughts and practices.

Amazon Affiliates Link

Buy on Amazon The Pyramid Principle

Software Engineering Excellence — A Pyramid Principle Structure

The McKinsey Pyramid Principle organises thinking from the top down: a single governing idea, supported by a small number of mutually exclusive and collectively exhaustive arguments, each supported by evidence and reasoning. What follows applies that structure to everything covered in this series.

Atomic Habits

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

Atomic Habits — Summary

By James Clear — Writer, Entrepreneur, and Habits Researcher

Amazon Affiliates Link

Buy on Amazon Atomic Habits: Tiny Changes, Remarkable Results

Core Thesis

You do not rise to the level of your goals. You fall to the level of your systems. Goals are the direction; habits are the vehicle. And habits are not built through motivation, willpower, or dramatic transformation — they are built through tiny, consistent, almost invisible changes that compound over time into remarkable results.

Be Useful

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

Be Useful: Seven Tools for Life — Summary

By Arnold Schwarzenegger — Actor, Bodybuilder, Governor

Amazon Affiliates Link

Buy on Amazon Be Useful

Core Thesis

Arnold’s life philosophy distilled into one word: useful. Not famous. Not rich. Not admired. Useful — to yourself, to the people around you, and to the world. The book is a no-nonsense, deeply personal guide built entirely from Arnold’s own journey from a small Austrian village to the pinnacle of three completely different careers.

Breaking Down Problems

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

Breaking Down Problems — Decomposition as a Core Skill

Why It’s a Skill, Not a Step

Decomposition is often treated as a planning activity — something that happens in a refinement session, produces a list of tickets, and is then considered done. The tickets get handed to developers who implement them. This misses what decomposition actually is.

Decomposition is a continuous cognitive skill exercised throughout development — in planning, yes, but also when sitting down to write a test, when deciding where a class boundary should be, when a piece of code resists being understood. The developer who can break a problem down well works differently at every level: they write smaller functions, cleaner interfaces, more focused tests, and smaller PRs. The skill compounds across every scale of work.

Clean Architecture

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

Clean Architecture

The Core Idea

Clean Architecture, articulated by Robert C. Martin (Uncle Bob), is a way of organising code so that business logic is the centre of the system and everything else — frameworks, databases, UIs, external services — is a detail that can be swapped out or tested independently.

The central rule is the Dependency Rule: source code dependencies can only point inward. Outer layers know about inner layers; inner layers know nothing about outer layers.

Coding Tips — Principles in Practice

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

Coding Tips — Principles in Practice

These tips are the everyday expression of everything covered in this series — the micro-decisions that, made consistently, produce code that is comprehensible, maintainable, and a pleasure to work in.

Control Flow

Return early to reduce nesting. Every level of nesting is a level of context the reader must hold in working memory. Guard clauses that return or throw early eliminate the nesting that builds up around validation and precondition checks.

Cognitive Load

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

Cognitive Load — The Hidden Cost of Complexity

What It Is

Cognitive load is the amount of mental effort required to hold and process information at any given moment. The concept comes from educational psychology — John Sweller’s work in the 1980s on how people learn — but it maps directly onto software development, where the primary activity is understanding complex systems well enough to change them safely.

Working memory is the bottleneck. Humans can hold roughly four to seven distinct pieces of information in working memory simultaneously. When that limit is exceeded, comprehension degrades, mistakes increase, and progress slows. The developer who can’t hold the relevant parts of a system in their head at once starts to make changes based on incomplete understanding — which is where bugs come from and where confidence erodes.

Collaborative Development

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

Collaborative Development — Beyond Strict Pair Programming

(updated to include mentoring and teaching)

The Spectrum of Collaboration

Traditional pair programming has a specific form: two people, one keyboard, one screen, switching between driver and navigator roles. The research behind it is solid — it produces fewer defects, spreads knowledge, and keeps both people focused. But the strict form has real costs: it’s cognitively intense, it doesn’t suit all personality types, and it treats every problem as requiring the same level of collaboration.

Configurable Systems

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

Configurable Systems and the Right Abstraction

The Core Idea

There is a class of problem where the right move is not to write another solution, but to recognise that you’ve already written several solutions to the same underlying problem and extract the pattern. Instead of building bespoke code repeatedly, you build a framework that models the shape of the problem — and then configure it for each specific instance.

The payoff is significant: new instances of the problem become configuration rather than code. The framework is tested once deeply; each configuration gets a shallow test. Developers working with it operate at the level of the domain concept — star schema, workflow, form, pipeline — rather than the level of implementation detail.

Continuous Integration and Delivery

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

Continuous Integration and Delivery

The Problem with Infrequent Integration

Imagine two developers working independently on the same codebase for two weeks. They’ve each made hundreds of changes across dozens of files. On day fourteen they attempt to merge. The merge itself might be mechanical — resolving conflicting edits line by line — but the harder problem is behavioural: their changes made assumptions about the system that are no longer true. Tests fail in ways that are hard to diagnose because the surface area of change is enormous. Nobody is sure whether a failure was introduced yesterday or ten days ago.

Decision Making

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

Decision Making Under Uncertainty

The Problem With Deciding Too Early

Architecture decisions are made at the worst possible time. At the start of a project — when the key decisions feel most urgent — the team has the least information. The domain isn’t fully understood, the usage patterns are hypothetical, the team hasn’t discovered the pain points yet. And yet this is precisely when decisions are made that will shape the system for years.

Domain Modelling

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

Domain Modelling and Rich Domain Models

The Core Idea

Domain modelling is the practice of capturing the concepts, rules, and behaviour of a business problem in code. A rich domain model goes further — it places business logic inside the domain objects themselves, rather than in surrounding service or use case classes.

The opposite of a rich domain model is an anaemic domain model — objects that are little more than bags of getters and setters, with all logic extracted into services. Martin Fowler describes the anaemic model as an anti-pattern: it has the structure of OOP without the substance.

Feature Flags and Trunk-Based Development

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

Feature Flags and Trunk-Based Development

The Problem They Solve Together

Continuous Integration demands frequent integration to mainline. Continuous Delivery demands that mainline is always releasable. These two commitments create an immediate tension: what do you do with a feature that takes two weeks to build? You can’t keep it on a branch for two weeks — that defeats CI. But you can’t have a half-built feature in production — that defeats CD.

Keeping Dependencies Up to Date with Renovate

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

Keeping Dependencies Up to Date with Renovate

The Problem

Every application sits on a foundation of dependencies — libraries, frameworks, build tools, base images. That foundation is not static. Dependencies release updates continuously: new features, performance improvements, bug fixes, and critically, security patches.

The default human response to this is inertia. Updating dependencies takes time, updates occasionally break things, and there is always something more immediately valuable to work on. So updates get deferred. Weeks become months, months become years, and the gap between what you’re running and what’s current grows quietly in the background.

Managing Complexity

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

Managing Complexity — Keeping Systems Comprehensible

The Two Kinds of Complexity

Fred Brooks introduced the distinction in his 1986 paper No Silver Bullet. It remains one of the most useful ideas in software engineering.

Essential complexity is inherent in the problem itself. A tax calculation system is complex because tax law is complex. A trading platform has complex rules because financial markets have complex rules. A healthcare system handles nuanced workflows because healthcare is genuinely nuanced. This complexity cannot be removed — it can only be managed, modelled, and represented as clearly as possible. Fighting essential complexity is fighting the domain.

Mindset: The New Psychology of Success

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

Mindset: The New Psychology of Success

By Carol S. Dweck — Professor of Psychology, Stanford University

Amazon Affiliates Link

Buy on Amazon Mindset

Core Thesis

Every person operates from one of two fundamental beliefs about their own abilities. That belief — which Dweck calls your mindset — quietly governs how you respond to challenges, failure, criticism, and the success of others. It shapes whether you reach your potential or fall short of it, often without you ever realising it’s happening.

Modelling Domains in Kotlin With Value Objects

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

Modelling Domains in Kotlin With Value Objects

The Problem With Primitives

Every domain has concepts that primitives can represent but cannot express. An email address is a String, but not every String is an email address. An order total is a BigDecimal, but not every BigDecimal is a valid order total — it shouldn’t be negative, it should have a defined currency, and it shouldn’t be mixed with a price in a different currency. A user ID is an Int, but it shouldn’t be added to a product ID, compared to a quantity, or passed where an order ID is expected.

Observability

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

Observability — Understanding Your System in Production

Why Observability is a Design Concern

Most teams treat observability as something added after the fact — sprinkle some log statements in, wire up a metrics library, declare the system observable. The result is a production system that generates enormous volumes of data while remaining fundamentally opaque when something goes wrong. The logs exist but don’t answer the question being asked. The metrics show something is wrong but not where or why. The traces are missing for the one request that caused the incident.

Reading and Understanding Unfamiliar Codebases

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

Reading and Understanding Unfamiliar Codebases

Why It’s a Distinct Skill

Most developer education focuses on writing code. Reading code — particularly large, unfamiliar codebases written by people you’ve never met, under constraints you don’t know, solving problems you’re still discovering — is a different activity that receives almost no explicit attention.

Yet it is something every developer does constantly. Joining a new team, picking up an open source library to understand its internals, inheriting a system from a team that no longer exists, returning to your own code after six months. The ability to build an accurate mental model of an unfamiliar system quickly is one of the highest-leverage skills a developer can have, and it is largely learned through trial and error rather than through deliberate practice.

References

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

Communication

The Pyramid Principle
- Start with the answer first.
- Group and summarize your supporting arguments.
- Logically order your supporting ideas.

Books

37 Signals
- Shape Up is for product development teams who struggle to ship.
- It Doesn’t Have to Be Crazy at Work - Chaos shouldn’t be the natural state at work.
- REWORK is the perfect playbook for anyone who’s ever dreamed of doing it on their own.
- REMOTE - Office not required.
- Getting Real - The smarter, faster, easier way to build a successful web application.

REST and HATEOAS

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

REST and HATEOAS

REST (Representational State Transfer)

REST is an architectural style for distributed hypermedia systems, first described by Roy Fielding in his 2000 doctoral dissertation. It’s not a protocol or standard, but a set of constraints that, when applied to a web service, produce desirable properties like scalability, simplicity, and modifiability.

The six constraints of REST:

Client-Server — Concerns are separated between the UI/consumer and the data storage/logic. This allows each to evolve independently.

Rework

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

REWORK by Jason Fried and David Heinemeier Hansson of 37signals:

Amazon Affiliates Link

Buy on Amazon REWORK

What It Is

Rework is a business book that offers unconventional and practical advice for starting and running a successful business. It encourages readers to question traditional workplace practices and focus on simplicity, efficiency, and genuine customer service. The book is broken down into micro-chapters — each between 2–3 pages long and containing a single tip designed to show how the authors have bucked convention.

Shape Up: Stop Running in Circles and Ship Work that Matters

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

Shape Up: Stop Running in Circles and Ship Work that Matters — Summary

By Ryan Singer — Head of Strategy at Basecamp

Online book

Basecamp.com Shape Up: Stop Running in Circles and Ship Work that Matters

Core Thesis

Most software teams are trapped in a cycle that feels productive but isn’t: endless backlogs, two-week sprints that never quite finish, features that balloon beyond their original scope, and a persistent sense that the team is always busy but never done. Shape Up is Basecamp’s answer to this — a fundamentally different way of thinking about how software gets built.

Team Topologies

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

Team Topologies — Summary

By Matthew Skelton & Manuel Pais

Amazon Affiliates Link

Buy on Amazon Team Topologies

Core Thesis

Most organisations design their teams around org charts, project needs, or historical accident — and then wonder why their software architecture is a mess and their delivery is slow. Team Topologies argues that team design is a first-class engineering decision, as important as any technical choice you make.

The book’s central claim: your team structure will become your system architecture whether you intend it or not. So you might as well design both deliberately.

Technical Debt

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

Technical Debt — Thinking About It Honestly

The Metaphor and Its Limits

Ward Cunningham coined the term “technical debt” in 1992 to describe a specific situation: shipping code that isn’t quite right in order to learn something from real users, with the intention of going back to refactor once that learning has happened. The debt metaphor was deliberate — like financial debt, it accrues interest. The longer you leave the suboptimal code in place, the more every subsequent change that touches it costs.

Technical Documentation — What's Worth Writing Down

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

Technical Documentation — What’s Worth Writing Down

The Documentation Paradox

Documentation has a reputation problem in both directions. Teams that write too little leave critical knowledge locked in individuals’ heads, where it fades and eventually disappears when people move on. Teams that write too much produce documents that are immediately out of date, never read, and actively misleading — giving readers false confidence that they understand something they don’t.

The failure mode is treating documentation as a uniform activity — either you document everything or you document nothing. The more useful question is: what specific knowledge needs to exist in written form, for whom, and why? Different answers produce radically different kinds of documentation, each with different value and different maintenance costs.

Test-Driven Development

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

Test-Driven Development (TDD)

The Core Idea

TDD inverts the traditional write-code-then-test workflow. You write a failing test before writing the implementation, then write the minimum code to make it pass, then clean up. The tests don’t just verify correctness after the fact — they drive the design of the code itself.

The Red-Green-Refactor Cycle

This is the heartbeat of TDD. Every small increment of work follows three steps:

Red — Write a test for behaviour that doesn’t exist yet. Run it. It must fail. If it passes, either the behaviour already exists or the test is wrong.

The Defining Decade

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

The Defining Decade by Meg Jay, Clinical Psychologist

Amazon Affiliates Link

Buy on Amazon The Defining Decade

Core Thesis

Your twenties are the most transformative — and most wasted — decade of your life. Society tells young adults to treat their twenties as a free pass, a consequence-free intermission before “real life” begins. Meg Jay argues the opposite: 80% of life’s most defining moments happen by age 35, meaning the twenties are not a waiting room but a launching pad.

The lean startup

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

The Lean Startup by Eric Ries, Entrepreneur & Silicon Valley Pioneer

Amazon Affiliates Link

Buy on Amazon The Lean Startup

Core Thesis

Most startups fail — not because they build something bad, but because they build something nobody wants. Traditional business planning is fiction dressed as strategy. Eric Ries argues that startups need a scientific approach to innovation: test assumptions rapidly, learn from real customers, and adapt before running out of time and money.

The Pyramid Principle

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

The Pyramid Principle — Summary

By Barbara Minto — Former McKinsey Consultant

Amazon Affiliates Link

Buy on Amazon The Pyramid Principle

Core Thesis

Most people communicate by leading with their thinking and arriving at their conclusion. They explain the context, walk through the analysis, describe the options, and finally — after the reader has been waiting — deliver the point. Minto argues this is exactly backwards.

Start with the answer. Then explain it.

The Spirit of the Craft

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

The Spirit of the Craft

These documents represent a living collection of my thoughts on building software. While they cover varied topics—from architectural patterns to testing strategies—they are unified by a single perspective: Software is a human-centric endeavor.

The “spirit” of this collection can be distilled into five core convictions:

1. The Primary Constraint is Human Cognition

We build systems that eventually exceed our ability to understand them. Most of our tools—TDD, Clean Architecture, Decomposition—are not about “correctness” in a vacuum; they are defensive measures against cognitive load. We write code for the reader, not the compiler, because the hardest part of software is keeping the mental model in our heads long enough to change it safely.

Tidy First

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

Tidy First?

By Kent Beck — Creator of Extreme Programming & Pioneer of Test-Driven Development

Amazon Affiliates Link

Buy on Amazon Tidy First

Core Thesis

Before you change the behaviour of code, should you first tidy its structure? That’s the deceptively simple question at the heart of this book. Kent Beck’s answer is nuanced: sometimes yes, sometimes no, and knowing the difference is the mark of a mature engineer.

But the book is really about something deeper — it’s a philosophy of software development that connects code structure, human behaviour, and economic value into a unified theory of when and why tidying matters.

Writing Code for the Reader

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

Writing Code for the Reader

The Compiler Is Not Your Audience

Code is written once. It is read many times — by the next developer to work in the area, by a colleague reviewing the PR, by you returning to it six months later with the context entirely gone. The compiler will accept almost anything that is syntactically correct. The human reader is far more demanding, and far more important.

Pauls Blog

Sample data

The Strategic Case for Programmable Sample Data

I. The Core Thesis

II. Supporting Arguments

1. Enforcement of Business Logic via Service Seeding

Completing your GitHub Profile

Completing your GitHub Profile

1. Fill in your profile — properly

Diary 2026-05

May 2026

Podcasts

Stop Serving PNG: Switch to WebP

Stop Serving PNG: Switch to WebP and Cut Your Image Sizes by 80%

The Bottom Line

Markdown is for the Web, AsciiDoc is for the Docs (and CVs)

The Problem with Markdown PDFs

Eliminate PR Noise with ktfmt

AI-Assisted Engineering: From Implementation to Specification

Hugo Simple Beauty Theme

Hugo Simple Beauty Theme

Features

🎨 Design & UI

🛠 Technical Features

🧩 Shortcodes

Diary 2026-04

April 2026

LG Channels

Podcasts

AI

Creating and releasing an application

Creating and releasing an application

ACC messages

Leave planner 1.1.0

Announcing Leave Planner v1.1.0: Work From Home Tracking & More!

🏠 Work From Home (WFH) Tracking

Introduction to F1

Netflix

Podcasts

Leave planner application

The spreadsheet prototype

YouTube channel aggregator experiment

SDKMAN

Installation

Usage

Introduction to JSON5

Sharing gradle configuration

Sharing gradle configuration between modules

Authoring markdown posts in Hugo

Writing Articles using Markdown

Dependency upgrades with Renovate

What is Renovate?

Week in review 2024-09-22

A Brief Introduction to AsciiDoc

Clean architecture - part 1

Clean architecture - part 1

Week in review 2024-08-25

Roadmap.sh

StartDataEngineering.com

Summary

GitHub

Blog

A Game Plan for Product and Software Development

A Game Plan for Product and Software Development

The Premise

A Pyramid Principle Structure - Software Engineering Excellence

Software Engineering Excellence — A Pyramid Principle Structure

Atomic Habits

Atomic Habits — Summary

Core Thesis

Be Useful

Be Useful: Seven Tools for Life — Summary

Core Thesis

Breaking Down Problems

Breaking Down Problems — Decomposition as a Core Skill

Why It’s a Skill, Not a Step

Clean Architecture

Clean Architecture

The Core Idea

Coding Tips — Principles in Practice