Recent content on Coding Architect
Types made “this value is a string” checkable. Tests made behaviour checkable. Nothing ever made “the API layer must not talk to the data layer” checkable — cheaply, across every language in the repository, in the second before a commit. That gap is where agents do the most damage. 
 I’ve spent the last few weeks building tropism , a dependency and architecture…
I have around 120 repositories under my personal GitHub account. Some are active, most are dormant, and all of them rot at the same rate. Dependencies drift, GitHub Actions pin to versions that get deprecated, CVEs land in transitive packages, issues arrive and sit unlabelled, and the Rust MSRV I set eighteen months ago quietly falls three releases behind. 
 The usual answer is to commit a…

 The reading order problem
 
 
 
 
 
 
 Stock Rust testing is fine, in the sense that a hammer is fine. You get assert! , assert_eq! , assert_ne! , and the #[test] attribute. Everything past that — better diffs, fuzzy float comparisons, collection matchers, mocks, table-driven cases — is a separate crate with its own conventions: pretty_assertions , assert2 , claim…
MCP server configs across the ecosystem default to npx . That quietly forces a Node runtime onto every machine that wants to run a native binary tool. bx is the missing primitive for the other case. 
 I spent the weekend building bx — short for binary execute — a single static binary whose only job is to fetch, cache, and exec other single static binaries from GitHub releases. Think npx / uvx…
The developer inner loop — edit, build, test, debug — is the highest-leverage piece of any engineering team’s workflow. It runs hundreds of times a day per developer. Shaving seconds off it compounds into hours; lengthening it by minutes kills momentum. 
 What we used to optimise was the human’s cycle time. Faster compilers, hot reload, snappier test runners. The human stayed in…
Most code review tools want to be a service. The interesting question is what falls out when you refuse to run one — and use git itself as the sync layer instead. 
 I’ve spent the last few weeks building casual-review — cr on the command line — a single static binary that delivers rustc -quality diagnostics across Rust, Python, TypeScript, TSX, and Java. It’s diff-aware by default,…
The pull request was built for a world where humans wrote most of the code. We don’t live there anymore. 
 The pull request as a unit of review is a recent invention. GitHub shipped it in 2008. Before that, code review meant Fagan inspections, pair programming, or the homegrown pre-commit systems Google and Facebook ran internally. The PR didn’t just give us a UI — it…
The same graph that helps an agent write code can help a reviewer trust it. Almost nobody is using it that way. 
 Every AI coding tool I’ve looked at in the last eighteen months — including codemap now called symgraph— is built around the write side. Index the codebase, expose a semantic surface, hand the agent enough context to make a competent edit. The graph is plumbing for…

 A Rust-Native Architecture Toolchain: forge, puml, and adoc
 
 
 
 
 
 
 
 Replacing the JVM and Ruby pieces of the architecture documentation stack with single static binaries
 
 
 
 
 
 
 Most of the tools I reach for when documenting architecture were built in another era. PlantUML wants a JVM. Asciidoctor wants Ruby. Structurizr…
The more context and tools an AI coding agent has access to, the better it performs. But more power means more risk. How
do we harness the full capability of AI coding assistants while keeping our systems safe? 
 
 The Problem: Power vs. Safety
 
 
 
 
 
 
 AI coding agents like Claude Code, Codex, GitHub Copilot and Gemini CLI are remarkably capable — they…

 Exploring Your Backstage Catalog Without Backstage
 
 
 
 
 
 
 
 How bsv gives you instant visibility into your software catalog from the terminal
 
 
 
 
 
 
 Backstage has become the de facto standard for software catalogs. Thousands of organizations use it to track their services, APIs, teams, and infrastructure through…

 Seeing Your Codebase as a City
 
 
 
 
 
 
 
 Why we need better ways to understand code at scale – and how 3D visualization can help
 
 
 
 
 
 
 Software teams accumulate code the way cities accumulate buildings. One project at a time, one service at a time, one quick prototype that somehow became permanent infrastructure.…

 Visualizing Project Structure with rv
 
 
 
 
 
 
 
 A fast, interactive way to see what’s actually in your project
 
 
 
 
 
 
 Every developer has had the experience of opening an unfamiliar codebase and trying to figure out what’s where. You run tree , get a wall of text, and scroll past hundreds of lines of filenames…

 Building a Code Knowledge Graph for AI Agents
 
 
 
 
 
 
 
 How I rebuilt codegraph in Rust to give AI coding assistants a semantic map of your codebase
 
 
 
 
 
 
 There’s a fundamental tension at the heart of agentic coding today. AI models are remarkably good at writing code, but they’re surprisingly bad at…
Vibe Coding is an innovative approach to software development that emphasizes creativity, flow, and emotional engagement in the coding process. It encourages developers to tap into their intuition and passion for coding, fostering a more enjoyable and productive work environment. 
 
 The Essence of Vibe Coding
 
 
 
 
 
 
 At its core, Vibe Coding is about…
Hello there, fellow tech enthusiasts! Today, we dive into a stimulating topic that has been stirring the world of software development: a comparison between pair programming, mob programming, and working with AI co-pilots. Let’s explore how these methodologies play out in real-world development scenarios and see if we can tease out their advantages, disadvantages, and areas of best fit. 
…
As someone delving into the world of software development, the journey seemed smooth and set. With incremental releases, continuous integration, and agile methodologies, it appeared the path was that of constant and iterative improvement. But just as I started getting comfortable, a seemingly disruptive technology, Generative AI, came into the scene. This turned the world of development upside…
There has been quite a lot of commentary on various social media channels about agile ceremonies and the traps that they often pose to enterprises. if not taken in the context of the value that they provide. 
 This is not a n agile problem. Agile principles are not agile ceremonies. Becoming or being agile is very different from doing agile. 
 Iteration Zero or sprint zero could be…
Interactive web applications are always more appealing than static sites. This blog explores using the klipse plugin to add interactive code snippets to this blog. 
 Very often seeing the output of running code is key. I was really excited when http://lighttable.com became available . It seems to be a very quiet project these days but the output and value of variables while working on the code…
Yesterday I spent some time experimenting with building containerized Go applications. Writing a small restful web service in go is really quite straightforward and there are many better examples out there on the web. 
 What was interesting for me was seeing how Bazel supports a typical workflow building and running containerized web services. In this case using a small Go program. 
 Bazel…
Ward Cunningham is credited with the first use of the team Complexity as Debt or Technical Debt (YouTube video) as a metaphor poor software implementation. For a software application or system technical debt refers to the internal code quality. We have accrued Technical Debt when the implementation does not match current requirements or when implementation shortcuts lead to complex and coupled…
At the start of my career I worked with fairly dumb terminals and mainframes. Programs were natively compiled but resources were limited and shared with the other users of the system. Shared computing power meant that we favored languages that were efficient typically compiling to binaries. 
 As personal computers made their appearance developers and users had much more computing power at…
Orchestration and Choreography are often discussed as design options for event driven systems. Some use the term interchangeably while others feel that the two are very distinct. I am in the later group in thinking that the two are very distinct and lead to very different implementations and outcomes. 
 When thinking about these two patterns I find it helpful to relate their behaviors to the…
Risk is typically expressed as a function of likelihood and severity or impact. Probability is an important factor but this article is about understanding the potential impact of change on a production software environment. 
 All changes carry an element of risk. Key to managing that risk is understanding and quantifying the risks inherent in a change. Not all changes present the same level of…
Over the last month or so I have been writing some data collection and simple analysis routines for the things we (developers) use every day. The ultimate goal is to have a system that can collect, interpret and recommend actions based on data from source code, version control, build and other systems related to software development. The project is kuona . 
 GitHub has 1000s of project…
For the last few years I have been very interested in what we can learn about our software development processes by looking at the data generated by the tools that we use to manage and deploy our work. This work started the Kuona project (Kuona is the shona word “To see..” http://kuona.io . All the code is open source on github https://github.com/kuona 
 Initial work focused on…
Creating useful software models that represent the buisness they serve is hard. Creating a single model for a business at a point in time might be possible but as the business changes models need to be continually updated. Because these models are hard to produce and require a lot of analysis keeping them up to date becomes an impossibility. One model just can’t keep up with business reality.…
As a developer I recognise the importance of generating logs for the systems that I help design and develop. At the outset often everyone recognizes the importance of logging but somehow it’s very difficult to engage stake-holders in requirements. 
 Building an application or system is a learning process that involves feedback. Agile software development practices highlight the importance of…
While developing web applications I have often needed to change the style of one or more elements based on the state of the data model used by the application. I have an inherent aversion to conditionals in views so went looking for other options. I came up with templated styles that works with both server and client side templating systems. 
 The code examples use Angular and can be found…
I don’t usually write reviews but I was so deleted by es-mode for
emacs that I felt compelled to share. If you have worked with REST
APIs and ElasticSearch in particular you probably have had similar
experiences of using something to develop queries. Coding in one of
the client libraries does not provide the interactive experience you
need to develop quickly and it often…
In domain driven design (DDD) we talk a lot about entities; objects that have identity and lifetimes that typically outlive their values. e.g. An account lives longer than the email address, name, postal address etc. Value types might be mentioned in discussion but then quickly fade. This is a shame because they are the fundamental building blocks, after all they hold the application data. One…
Working with small teams is a lot of fun and I find it fairly easy to
keep track of what is happening with version control and build
systems. Errors and failures don’t come up that often and when they do
they can quite often get solved there and then. On larger projects or
working in a large organisation it’s impossible to keep track of
everything. There are too…
In his keynote
 ‘This is water’ Neal Ford
talks about “Yesterday’s best practices become tomorrow’s
anti-patterns”. This seems to be the case for application servers
like WebSphere, WebLogic and JBoss. 
 When these containers started to become popular (typically in large
enterprises) servers took a long time to commission…
How can we get the benefits of IoC containers at a higher level - the
services that we deploy into environments? Typical service tiers are
implemented with a fronting load balancer that allocates servers to
satisfy requests. Applications or services that need these services
are give domain or IP information of the load balancers and the load
balancers are given details of the…
If Conway’s law applies the how we set up and organise teams should
either be aligned to the architecture of the applicaiton or system
being developed or application/system architecture will shift to match
the team structure. 
 
 Conways law
 
 
 
 
 
 
 
 organizations which design systems … are constrained to produce designs which…
The idea for
 lazybuilder came up
during a recent coding dojo doing code kata. We were using Vim and a
separate terminal to run the tests. Switching back and forth between
two windows when trying to move quickly seemed like a waste of time. 
 There are several tools in this space but most of them work by polling
for changes or use linux events that are not available on a…
After a long wait CODE keyboard s are available again and I received mine
last night. I have to confess that I am a bit of a keyboard junkie. I
am reluctant to count them all but I am edging into double digits :(. 
 The keyboard arrived nicely packaged inside a larger box with lots of
packing material to avoid damage in transit. The box containing the
keyboard itself is minimal…
Browsing some blogs recently I came across some interesting C++11
lambda code and thought it would be cool to try it out for myself. The
idea of spinning up a project or even putting a new test in an
existing project did not feel right. Wouldn’t a C++ REPL be useful for
just these occasions? 
 A couple of web searches later turned up Cling which seemed to be
just the…
I have been spending time recently writing command line apps in
C++11. Each time I wanted a way of handling command line arguments
flexibly. I chose to use the boost::program_options library. The
documentation is pretty good but there are some assumptions (aliased
namespace) and the example code is broken up with paragraphs of text
explaining what the code does. 
 When I…
I am about to embark on a new Java project so I thought I would take a
look at the current state of build tools for Java projects. First I
thought I would draw up some assessment criteria to use as a loose
guide. This is what I came up with: 
 Fast 
 I want a build tool that spends as much time as possible building my
application and not setting itself up to perform the…
I like to commit code frequently when working on a project. I also
like to use the command line for building, testing and committing
code. So I thought it would be nice to have a way to check the build
status from the command line. I have been wanting to write something
in C++11 and a small lightweight command line tool seemed like a good
opportunity. 
 My efforts can be…
Continuous Deployment is the act of automatically deploying an
application every time the build is successful. I am currently working
with a development team that is working towards continuous deployment
as part of their continuous delivery adoption plans. The system
involves several internal web services which seemed like a good place
to start working on not only automating…
Following up on the [next_permutation]({% post_url 2013-08-03-next_permutation %}) from a
couple of weeks ago
 word finder uses
next_permutation to find words in character sequences. Uses the
 aspell C api to look up each
permutation. Searching for 3,4,5 and 6 character words in a 6
character sequence takes about 200ms. 
 Using C++11 meant that I could use a nice lambda…
Graham Brooks: Architect, Software Engineer 
 Over the years I have been described as a programmer, analyst programmer, software developer, software engineer and many other derivation of software X professional. For most of the time it has not seemed to be important. Recently though I have started to wonder how these names might affect the way software professionals see their role and perhaps…
Working on a small program recently I found a quirk in
next_permutation. The prorgam read a sequence of characters from the
command line and then tried to find words by testing each
permuation. For a sequence of 3 characters there are 6 permutations. 
 Most of the online examples look something like this: 
 vector < int > set { 'a' , 'b' , 'c' }; 
 
 do { 
 for (…