Coding Architect — essays

Open source update: six new tools and what changed, September to October 2026

Sun, 25 Oct 2026 09:07:00 -0600

Between 1 September and 25 October 2026, my public repositories at github.com/grahambrooks cut 92 releases across 27 repositories. Most of those numbers are plumbing. This post separates the plumbing from the parts you’d notice.

It’s for anyone who uses one of these tools, or who’s wondering whether one of them is worth trying. Each project gets a one-line definition the first time it appears, so you shouldn’t need to have read anything else here first.

Reading a change as two aligned files, in a terminal (increment)

Sun, 25 Oct 2026 09:06:00 -0600

A patch shows you what changed. It doesn’t show you the file the change landed in. increment is my attempt at showing both, without leaving the terminal.

increment is a terminal diff viewer. The command is inc. It renders a change as two aligned panes, old on the left and new on the right, with each line level with the line it corresponds to. Modified lines get word-level highlighting, unchanged regions fold away, and in the interactive browser there’s a change map down the right edge. The reference I was copying is the JetBrains diff view, and the goal was to get that view in a terminal and in a pipe.

Mermaid to SVG without a browser, and with the labels still there (mmd)

Sun, 25 Oct 2026 09:05:00 -0600

Convert a Mermaid diagram to PDF with an SVG-only toolchain and you can get boxes and arrows with no words in them, and no error telling you the words are gone. mmd exists because of that failure.

mmd is a command-line tool and Rust library that renders Mermaid diagram source to SVG. It’s pure Rust: no Node, no headless browser, no JavaScript runtime, no C toolchain. It’s for anyone who publishes Mermaid diagrams somewhere other than a web page that runs Mermaid’s own JavaScript, such as a PDF, a static docs build, or an editor preview that wants to draw the diagram itself.

When an agent can already write the file, what is an MCP server for?

Sun, 04 Oct 2026 08:25:17 -0600

Agents are very good at writing files. So when a tool’s input is a file, an MCP server in front of it starts out with a problem: the agent can already do the job without it. The server has to earn its place by doing something a file can’t. Most of the ones I’ve considered building didn’t.

This post is about the one that did, and about how much narrower its win turned out to be than the plan said.

The release pipeline four tools kept reinventing (release-kit)

Sun, 27 Sep 2026 08:34:15 -0600

Every tool I build for myself needs the same last mile: binaries for my machines, a Homebrew formula, something bx can run. That’s the same work each time, and I kept writing it again for each tool. The fix wasn’t a smarter workflow. It was admitting that the release process is a tool with a user of its own, and that user is me.

In Building Your Own Tools I argued that software with one known user gets to delete its configuration layer. There’s no need for options when you know exactly who’s running it. This post is about what I missed in that argument. Once there are several of those tools, the work around them starts repeating, and each copy grows its own small configuration layer. Nobody designs it. It just builds up.

Stop declaring what you can already read (myspec)

Sun, 27 Sep 2026 08:34:11 -0600

Every time you ask someone to tell your tool something it could have found out, you’ve created a second copy of a fact. Second copies drift. In an agent’s toolchain there are a lot of facts, and until recently I was asking for a lot of second copies.

This is the first post about myspec. It’s a Rust CLI that wraps Claude Code and keeps my repositories consistent and their agents well-equipped. It started as a personal spec-driven development workflow, meaning the agent works from a written change proposal and its spec deltas rather than straight from a prompt. Then on 18 September it changed direction. The design doc records the reason as a critique of the original plan: “The spec workflow alone doesn’t keep repositories consistent as practice moves, doesn’t make sure agents have their tools, and can’t tell a running session what happened in the repository.”

Letting an agent read your mail: split the reader from the network

Sat, 26 Sep 2026 17:19:50 -0600

Every email in your inbox was written by someone else, and most of them were written by someone you’ve never met. Hand that inbox to a model and you’ve handed it several hundred prompts from strangers. You can ask the model nicely to ignore them. Or you can arrange things so that when it doesn’t, nothing much happens.

This is the first post about agentic-twin, “the twin” from here on. It’s a personal agent system that runs on my Mac and takes on recurring work I’ve handed to it. It checks my GitHub repositories every morning, gathers news, drafts blog topics and writes a daily note. Most of that work is done by small deterministic programs, and a model is used only where judgement is actually needed. I wrote about sandboxing coding agents in March, and about a bounded role for the model in running my GitHub account in July. This is the same argument applied to something more personal than a repository: my email.

Cadence is a budget line: what scheduled automation cost a private repo

Sat, 26 Sep 2026 17:19:28 -0600

A cron line looks like a latency setting. 0 * * * * reads as “check every hour, so nothing waits long.” In a private repository it’s also a purchase order, and it reorders every hour whether or not there’s anything to buy.

In July I wrote about running a personal GitHub account as a control plane: configuration as code, scheduled workflows, a deliberately non-admin GitHub App, and a bounded role for the model. This post follows up on part of that design, the scheduled part, after it did something I hadn’t priced in. On 26 September my account’s GitHub Actions budget was $30 over. Development CI didn’t overrun it. The automation meant to make the portfolio cheaper to maintain did.

Making a Code Graph Admit What It Doesn't Know (symgraph)

Tue, 22 Sep 2026 06:30:00 -0600

A tool that says “I don’t know” is annoying. A tool that guesses, and returns the guess in the same shape and the same confident tone as a fact, is worse than useless — because the thing reading it is an agent, and an agent has no way to tell the two apart.

symgraph indexes a codebase into a symbol graph — functions, types, the calls and imports between them — and serves it to a coding agent over MCP, the protocol Claude Code and similar tools use to reach external capabilities. I’ve written about why I built it and about using the same graph for review rather than generation. This post is about the month since, which went somewhere I didn’t plan.

Building Your Own Tools

Mon, 07 Sep 2026 12:54:34 -0600

Configuration is the tax you pay for not knowing who your user is. It has always been priced into the cost of building software, so we stopped noticing it was there. Build something for exactly one person and the tax disappears — along with the onboarding, the migration path, and the entire “but what if they want it the other way” branch of every decision.

Agents have changed the economics of building tools. That much is now uncontroversial and it is also the boring half of the observation. The interesting half is what the new economics let you build, which is not more software but a different kind of software: software with exactly one user, whose habits, directory layout and tool preferences the author knows precisely, because the author is the user.

Giving the Consumer a Representative in the Working Tree (brake)

Mon, 24 Aug 2026 09:30:00 -0600

An agent decides it is done when the checks it can run come back green. Every one of those checks is a question about the repository it is standing in. The team that generates a client from your OpenAPI file is not in that repository, is not in the test suite, and is not in the agent’s context window — so nothing in the loop objects when a field quietly disappears from a response.

Architecture the Agentic Loop Can Actually Check (tropism)

Sat, 08 Aug 2026 10:12:00 -0600

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 analyzer for polyglot repositories. This post is about the problem it’s aimed at, the one design decision the whole thing hangs off, and — at some length, because it’s the part most tool posts skip — what it measurably cannot do.

A Control Plane for a Personal GitHub Account

Sat, 25 Jul 2026 00:00:00 +0000

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 renovate.json and a couple of workflow files into every repo. I’ve done that. It doesn’t work at this scale — not because it fails, but because changing your mind fails. A policy tweak becomes 120 pull requests. The config drifts per repo. Half the repos end up on a stale copy of a workflow nobody remembers writing.

Porting Midje's Arrow to Rust (facts)

Mon, 25 May 2026 10:00:00 -0600

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, approx, mockall, rstest, proptest. Each crate is good. Together they form a Galápagos of small DSLs that all read slightly differently.

Running Local MCP Servers Without a Node or Python Runtime (bx)

Sat, 23 May 2026 12:00:00 -0600

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/pipx, except there is no Node and no Python anywhere in the picture.

The Agentic Inner Loop: Sensors, Substrate, and Skills for Polyglot Development

Sat, 23 May 2026 00:00:00 +0000

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 the seat throughout, dispatching each step and reading the output.

Team Code Review Without the Server: a CLI (casual-review)

Thu, 30 Apr 2026 14:00:00 -0600

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, runs equally on a developer workstation and in CI, and is designed for both human and agent (LLM) consumers.

Code Review After the Pull Request

Sun, 26 Apr 2026 19:15:00 -0600

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 institutionalized the change as the thing we look at. Eighteen years later, “review” and “review the diff” mean the same thing to almost everyone.

A Code Knowledge Graph for Review, Not Generation

Sun, 26 Apr 2026 18:30:00 -0600

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 generation.

That’s the obvious application. It’s also the smaller half of the problem.

A Rust-Native Architecture Toolchain: forge, puml, and adoc

Sun, 26 Apr 2026 17:54:39 -0600

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 wants both, depending on which piece you’re using. Each one is a perfectly fine tool. Together they’re a small operations problem – the kind of thing that quietly breaks every CI pipeline I’ve ever set up, and the kind of thing AI coding agents have an especially hard time bootstrapping inside a sandbox.

Sandboxing AI Coding Agents: Why Isolation Matters

Sun, 22 Mar 2026 12:13:20 -0600

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 can read your codebase, run commands, install packages, and modify files across your project. To be most useful, you want to give them broad access. To maintain flow you want the agent to run to completion without continuously interrupting and asking for permission for every action or confirming that it can use use something safely in the future. But every tool you grant is a tool that can misfire.

Exploring Your Backstage Catalog Without Backstage

Sat, 21 Feb 2026 12:00:00 -0700

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 catalog-info.yaml files scattered across their repositories. The format is well-designed, the ecosystem is mature, and the idea – a single catalog of everything your organization builds and operates – is genuinely powerful.

Visualizing Project Structure with rv

Sat, 21 Feb 2026 00:00:00 -0700

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 that all blur together. Or you click through directories in your editor, building a mental model one folder at a time. Neither approach gives you the kind of immediate, intuitive sense of a project’s shape that you get from actually working in it for weeks.

Seeing Your Codebase as a City

Sat, 21 Feb 2026 00:00:00 -0700

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. Before long you have dozens or hundreds of repositories, and nobody has a clear picture of what’s actually there.

This is a surprisingly common problem. A new engineer joins the team and asks: “Which services are the big ones? What’s old? What language is everything written in?” The answers live in people’s heads, in outdated wiki pages, or buried across GitHub’s repository listings. There’s no way to just look at your codebase and see the shape of it.

Building a Code Knowledge Graph for AI Agents

Sun, 15 Feb 2026 08:35:20 -0700

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 understanding the codebase they’re writing it in.

When you ask Claude, Copilot, or Codex to make a change to your project, the agent does what any new developer would do: it greps around, reads some files, builds a mental model, and starts editing. But unlike a human developer who accumulates understanding over weeks and months, the AI starts from scratch every session. Worse, it’s working through a keyhole – reading files one at a time, piecing together relationships from text patterns, burning context window on exploration before it can even begin the real work.

Vibe Coding

Sun, 25 Jan 2026 15:18:33 -0700

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 creating a positive and immersive experience while coding. It involves setting the right atmosphere, whether through music, lighting, or workspace arrangement, to enhance focus and inspiration. The goal is to enter a state of “flow,” where developers are fully absorbed in their work, leading to higher quality code and increased satisfaction.

Pair Programming, Mob Programming, and AI Co-Pilots: A Comparative Analysis

Wed, 05 Jul 2023 00:00:00 +0000

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.

Pair Programming

Pair programming, a well-established practice from the agile development world, involves two developers working together at one workstation. One developer, “the driver”, writes the code, while the other, “the navigator”, reviews each line of code as it’s written, providing a fresh perspective and immediate feedback. The two programmers often switch roles.

Working in Interesting Times: Generative AI as Disruptive Tech in Software Development

Mon, 03 Jul 2023 00:00:00 +0000

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 down, thus making life fascinatingly intriguing.

This blog post was almost entirely generated with the help of AI Assistant based on the following prompt to explore the possible.

A blog article in asciidoc format that talks about working in interesting times. Just when I thought that software development was set on a path of continuous improvement a disruptive technology of generative ai comes along to throw a spanner in the works and makes life fascinating

— Graham Brooks

Iteration Zero - the first iteration

Fri, 25 Nov 2022 00:00:00 +0000

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 considered to be an agile ceremony fraught with the dangers we have seen with other activities that have been brought under the agile umbrella. Just like the other things in this umbrella, like stand-ups, retrospectives, and so on, Iteration Zero is a tool that can be used by a team to delivery value to customers more quickly and with better safety. It is not to applied blindly. There are likely cases and projects where it does not make sense but in today’s web based world it should be more of a decision not to use it.

Kilpse Blogging

Sat, 11 Sep 2021 00:00:00 +0000

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 is really exciting - especially when writing unit tests. The RED/GREEN refactor loop running as you type is a real boost

User-defined build settings for Bazel builds

Mon, 30 Aug 2021 00:00:00 +0000

Text fingerprints

Sun, 06 Jun 2021 00:00:00 +0000

Installing built binaries locally with Bazel

Mon, 31 May 2021 00:00:00 +0000

Go and Bazel to build containers

Sun, 05 Apr 2020 00:00:00 +0000

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 is still relatively new but gaining in popularity. Over the last 6 months or so stability and functionality has really improved. Bazel really shines when combined with a mono-repo approach. For this example the bazel configuration feels more than required to achieve the result.

Technical Health over Technical Debt

Thu, 27 Dec 2018 00:00:00 +0000

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 code. Over time people have added more and more items to the general bucket of technical debt.

Sun, 09 Dec 2018 00:00:00 +0000

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 their disposal. That power was reflected in the servers that powered the early internet. With the increase in computing power both memory and CPU meant that less efficient but more effective runtimes could be supported. Java, .NET, Ruby all benefited from this additional power.

Sun, 29 Apr 2018 00:00:00 +0000

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 most popular implementations - music and dance.

Sat, 17 Feb 2018 00:00:00 +0000

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 risk. A single character change in an HTML file or template is much lower risk than the same level of change in a configuration setting that affects the behavior of the entire application or service. Let assume that each cause a problem. In the first case a error affects a single view. In the later the impact could be the entire application crashes if the configuration setting is unexpected in production.

The path to a million (loc)

Fri, 07 Jul 2017 00:00:00 +0000

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 repositories publicly available. This article is about one of them elasticsearch

Builder anti-patterns

Mon, 19 Jun 2017 00:00:00 +0000

Commit History Metrics

Thu, 15 Jun 2017 00:00:00 +0000

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 a dashboard from gathered metrics. Building full stack meant great flexibility but a lot of work and finding time for that work challenging with busy schedules. Over the past couple of weeks I have been working on feeding data from the collectors into elasticsearch and then using kibana to visualise the collected data.

Defending the Domain Model

Tue, 06 Jun 2017 00:00:00 +0000

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.

Domain Driven Design (DDD) offers an alternate approach. By decomposing systems around bounded contexts and domains the models we produce are not only simpler because the capture less of the overall business domain but they are also optimized for a particular context. Each domain maintains its own models. Changes to a domain should have little or no impact on another domain.

Testing Logging

Fri, 26 May 2017 00:00:00 +0000

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 these feedback cycles with showcases of the developing application. Quite often these ceremonies highlight the functionality delivered and leave little room for conversations around cross functional requirements. For most development projects this is quite reaonable - after all the functionality is what is going to generate revenue. Logging and other cross functional requirements are considered a cost of doing business. This is true for logging as much as other cross cutting concerns.

Templated styles

Sat, 20 May 2017 00:00:00 +0000

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 here

Emacs es-mode - REPL experiences for ElasticSearch development

Tue, 09 Aug 2016 00:00:00 +0000

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 becomes a frustrating exercise. es-mode takes away a lot of that pain.

Dependency Inversion - Applying the principle

Mon, 11 Jul 2016 00:00:00 +0000

The Value of Value Types

Sun, 25 Jan 2015 00:00:00 +0000

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 reason for this lack of attention is that we have some pretty powerful substitutes already supported by our implementation languages - int, double, string. But is that really good enough?

Build Analytics - better development understanding

Mon, 19 Jan 2015 00:00:00 +0000

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 many moving parts and changes. Incidents are more frequent and their impact much larger. A broken build or build system can affect 10s or 100s of people. For these larger development projects I find I have to collect and chart data, looking for tends and anomalies and then delve deeper into the data if and systems if there are problems.

Service IoC containers

Mon, 07 Apr 2014 00:00:00 +0000

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 servers running instances of the services that they need. Essentially each system with dependencies news an instance of its dependencies. Inverting this dependency requires a container but it leads to some interesting advantages.

Container-less web apps

Mon, 07 Apr 2014 00:00:00 +0000

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 and configure. Containers were a way of deploying applications more quickly and with greater safety. But time change and today’s patterns and teams favour lighter weight, nimble solutions. Our ability to manage servers and networks through code is one of the key drivers for this change.

Team Distribution Models and Conways Law

Mon, 31 Mar 2014 00:00:00 +0000

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 are copies of the communication structures of these organizations

Conway, Melvin E. (April 1968), “How do Committees Invent?”, Datamation 14 (5): 28–31, retrieved 2009-04-05

lazybuilder v0.3

Sun, 23 Feb 2014 00:00:00 +0000

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 mac. lazy builder uses CoreServices.

CODE keyboard

Tue, 28 Jan 2014 00:00:00 +0000

After a long wait CODE keyboards 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 but nicely designed.

Cling A C++ REPL?!

Thu, 19 Dec 2013 00:00:00 +0000

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 thing. There was no distribution for OS X so my first thought was to build from source. This is a little more complex than I thought it should be. You need to set up a viable llvm development environment and run some patches to get cling to compile. I ran into a number of problems doing this both on my Mac and on an Ubuntu VM. (compilation, linking and version incompatibilities between the repositories). Really wished for some CI goodness at that point.

Boost program_options

Fri, 06 Dec 2013 00:00:00 +0000

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 start to explore an API to a library I start by writing tests. After working with the program_options library on a few small applications the same pattern came up each time so I thought I would share the results as a complete app, although admittedly the app does nothing other than accept command line parameters.

Java build tools 2013

Fri, 15 Nov 2013 00:00:00 +0000

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 task.

ci console 0.0.2 released

Sat, 12 Oct 2013 00:00:00 +0000

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 found here https://github.com/grahambrooks/ci/

Zero Down-time - relational databases

Thu, 29 Aug 2013 00:00:00 +0000

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 the deployments but maintaining a very high degree of up-time during those deployments. Automating deployments involves both development and techops groups so I thought I would search for some worked examples that would help illustrate the techniques and steps required. I found several blogs and articles talking about different approaches but no worked examples.

word-finder

Tue, 13 Aug 2013 00:00:00 +0000

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 expression to process each permutation by passing the function object to the permute() function.

What's in a name?

Sat, 10 Aug 2013 00:00:00 +0000

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 how they view themselves.

In certain countries and regions the term engineer has more special definition. Wikipedia emphasizes the method or approach to developing software. In Europe the term infers that someone has undergone formal training and attained a status through examination or peer election to a learned society.

next_permutation

Sat, 03 Aug 2013 00:00:00 +0000

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 (auto x : set)
            cout << (char)x;
        cout << endl;
    } while (next_permutation(set.begin(), set.end()));

Emacs Sharing

Thu, 25 Jul 2013 00:00:00 +0000

I like Emacs. Some people like VI(M) but emacs has been in my toolbox for a long time and I feel very at home working with it.

Updating the editor has become easier over the years and installing an update is a simple matter of drag and on my Mac. But I use several computers and keeping each in sync with my current favorite settings was becoming a problem.

I recently came up with the idea of using Dropbox to share a single configuration file set for all the computers I use.

Campaign for better IO

Sun, 03 Mar 2013 00:00:00 +0000

Over the last 30 years I have used a lot of computers ranging from teletypes to laptops. I have also visited a lot of offices and seen the standard keyboards that people are using on a daily basis. In my opinion it is time for an upgrade. We humans interact with computers through keyboards, mice and screens and yet quite often these are afterthoughts. Keyboards and mice can be bought very cheaply and naturally suppliers opt for these when putting together a package.

If

Thu, 14 Feb 2013 00:00:00 +0000

Quotes: Things that inspire and be remembered

“If you can dream - and not make dreams your master; If you can think - and not make thoughts your aim; If you can meet with Triumph and Disaster And treat those two impostors just the same;”

Kipling

All truth

Thu, 14 Feb 2013 00:00:00 +0000

“All truth passes through three stages. First, it is ridiculed. Second, it is violently opposed. Third, it is accepted as being self-evident.”

Arthur Schopenhauer, German philosopher (1788 – 1860)

I can't believe I missed this!

Wed, 06 Feb 2013 00:00:00 +0000

Just over 20 years ago Jack W. Reeves wrote an article in the C++ Journal entitled “What is Software Design?” and I missed it. Not only that but no one thought to point out that I was missing a very important article. An article that challenged and changed/clarified my mental model of software design and construction - 20 years after it was published. A copy of the original article can be found here. I guess it is better late than never and it demonstrates that some things stay relevant and important. Sometimes they remain controversial.

DRYing out code

Mon, 31 Dec 2012 00:00:00 +0000

Removing duplicate code is a great way to improve the internal quality of your application code. Duplications mean that you have more code than you should and are often the source of more subtle bugs of the “I’ve already fixed that ..” variety.

While working on a scriptable command line tool for Java (see Automated refactoring for library updates) I discovered a neat way of identifying duplications at the method and block level.

Integrating GPUs in Application Development - From Concept to Deployment

Mon, 24 Dec 2012 00:00:00 +0000

This post is a little overdue :(

In June I presented at QCon NYC on using GPUs. It was a great chance to catch up on all the changes to C and C++ that I have missed out on in recent years. You can catch up on the presentation over on InfoQ

The source code used in the presentation is on github https://github.com/grahambrooks/qcon-ctod

Automated refactoring for library updates

Mon, 23 Jul 2012 00:00:00 +0000

After watching Clang MapReduce – Automatic C++ Refactoring at Google Scale I was struck with the idea that this could help with the upgrade problem. Almost every application uses libraries. Those libraries need to be updated from time but each time they are updated all the code using those libraries also needs to be updated. For development teams finding time to upgrade to the latest libraries against competing functional updates is challenging. What if as part of the release a set of refactoring commands or programs accompanied the libraries. These refactoring scripts would automatically update the consuming application code to use the new libraries saving time and money.

Metrics based Refactoring for cleaner code

Mon, 02 Jan 2012 00:00:00 +0000

Refactoring is a key practice to improved code hygiene. Making refactoring part of your next project is one thing but if you have just joined a team or project with a significant amount of debt how do you work on making things better? Over the last few months I have been assessing a number of code-bases and speaking about technical debt management. While preparing for these engagements I realized that combining two code and project metrics could be used to help focus efforts on code that would deliver the most benefit. Toxicity is a combined measurement of static code analysis metrics. Volatility a measure of changes made to files within a code-base over time. By combining these two measures we can create a source file scatter chart correlating toxicity against volatility.

Oh My ZSH shell productivity

Tue, 27 Dec 2011 00:00:00 +0000

oh-my-zsh is framework for managing zsh configuration. The default configuration adds some interesting enhancements.

The following shows all the Java files in the current and sub directories.

ls **/*.java

Ryan Bates has a nice Railscast episode covering oh-my-zsh

I have been using oh-my-zsh for the last couple of weeks. The GIT enhancement showing the current git branch in the prompt is a nice useful and elegant enhancement.

AgileDC - Introduction to Continuous Delivery

Thu, 27 Oct 2011 00:00:00 +0000

Yesterday I presented a talk entitled Introduction to Continuous Delivery at AgileDC. The audience was great and the room packed which is always a recipe for success. I really enjoyed talking about Continuous Delivery and there were some really interesting questions.

As promised I have uploaded the slides from the presentation to broken link

As I mentioned yesterday Jez Humble was kind enough to donate his slides from which I borrowed shamelessly.

Agile DC

Tue, 25 Oct 2011 00:00:00 +0000

I am really syched about talking at AgileDC tomorrow. The topic of my talk is an Introduction to Continuous Delivery

Encapsulating Databases

Thu, 11 Aug 2011 00:00:00 +0000

Small systems grow with success. As these systems grow they often take on more and more functionality either directly into the main system component or into sub-systems. As the systems grow in complexity and responsibility their database requirements grow at a similar rate become more and more complex.

In these complex systems each component needs to not only have access to data but also to transitive data generated by other components. This need often leads to the database becoming the inter-component communication channel.

Insulating against failure using Caching Reverse Proxies

Thu, 07 Jul 2011 00:00:00 +0000

Reverse proxies have been around for a very long time and depending on your application either interesting additions or a key element to your architecture.

Despite their long history I was recently reminded of some interesting applications of Caching reverse proxies that are worth revisiting.

First lets look at a fairly typical configuration where a caching reverse proxy is fronting some sort of web application. The web application exposes its functionality on one port (say 8080) and the proxy connects to this port for in-bound HTTP requests (say on port 80). The application responds with the data matching the request and if cacheable the proxy stores a copy of that content in its cache. There are lots of other paths - typically around failure and different responses but essentially the proxy acts as a pipe between the Internet and the application.

asciidoc experiments

Sun, 26 Jun 2011 00:00:00 +0000

I have always been interested in text processing systems. This is probably rooted in the time that I discovered computing and programming. At that time the state of the art was ROFF (T)ROFF and a whole family of plain text processing engines that produced nicely formatted output.

With the advent of word processing applications the emphasis moved away from plain test precessing systems to more sophisticated systems involving opaque binary formats. More recently the use of binary formats has fallen out of favor and many word processing systems now provide a level of interoperability with other systems though more open document formats.

Open Source project durations

Thu, 28 Apr 2011 00:00:00 +0000

During a recent discussion about open source development we wondered how long these projects lasted. In particular if there was a rapid drop off in activity.

One of the great things about recent open source code repositories is that they often provide APIs allowing this sort of analysis. The chart below was generated from a sample of 2360 public GitHub repositories. I took the started pushed-at and created-at dates to calculate how many days a repository had been worked on. I then grouped them together into 30 day increments and charted the count in each 30 day period.

Stabilizing Velocity

Sat, 26 Mar 2011 00:00:00 +0000

I came across this post by Michael Norton and thought I would reference it here: Stabilising Velocity Michael makes some keen observations on both causes and effects of unstable velocity.

Predictable velocity is a key agile planning metric. There is an implicit assumption in agile planning that this iterations velocity will be similar to the last iteration. Without this predicability it is very difficult, if not impossible, to provide and sort of forecast.

Rake db:migrate MySQL gem dependency

Mon, 24 Jan 2011 00:00:00 +0000

If you have already added gem ‘mysql2’ to your Gemfile but get a message saying that it is missing when you try to migrate

Make sure that you have installed libmysql-ruby

sudo apt-get install libmysql-ruby

This one caught me out on the weekend and it took a while to work out what was going on. I am guessing that not having libmysql-ruby installed caused the gem to incorrectly advertise that it was not available. I did not get any errors when installing the mysql2 gem which is strange.

Create MySQL database with Capistrano

Mon, 24 Jan 2011 00:00:00 +0000

I was playing about with Capistrano over the weekend. I wanted to automate the deployment of a Rails application to my server. The server was (I thought) just about ready to accept the app but I did not want to go through another manual deployment. I thought I would take the opportunity to script the deployment. The first task I set myself was to create a production MySQL database. Searching for how to do this threw up lots of interesting information about building and deploying database.yml files, but not much about configuring MySQL. The first set of tasks I came up with were:

Five Ws sitting on a bench

Sat, 22 Jan 2011 00:00:00 +0000

Over the past year I have been involved in preparing quite a few documents, proposals, presentations etc. I have also been asked to review quite a few of these documents. As an author or reviewer I like test what I am working on against 5 Ws and one H to see if the important aspects have been covered. The Wikipedia article provides a good background and history, including the 1902 reference to Rudyard Kipling Just So Stories.

The new Mac App Store

Fri, 07 Jan 2011 00:00:00 +0000

When Apple announced the new App Store for OS X I have to say I was a little underwhelmed at the prospect and did not think the new store would hold much interest. After all I have been pretty happy with finding and installing apps. I could see the point for the iPhone and iPad but for my laptop?

So with today’s updates came the new App Store application and out of general interest in what has been updated and installed I decided to take the app for spin.

Pulse Camp 1.0 and RHoK

Fri, 07 Jan 2011 00:00:00 +0000

One of the great things about working at a consultancy is that I get to meet a wide range of interesting clients with interesting problems that need solving. One of the most interesting for me was Pulse Camp 1.0, a 3 day event to start defining a system framework that can help NGOs and other groups make better informed decisions based on real-time data.

The UN Global Pulse initiative is in the early stages of development but the excitement, participation and drive I experienced at Pulse Camp 1.0 fills me with hope that this ambitious program of work will be successful.

Progressive Enhancement

Fri, 24 Dec 2010 00:00:00 +0000

Progressive Enhancement is a web development technique or pattern. The basic premise is that a web site should be accessible to all users and then to overlay additional functionality based on the client’s capability.

Web technologies and good web development practices over the last few years had encouraged this approach. Popular web sites delivery semantic HTML to allow screen readers and other client devices to understand the content of being delivered. Advances in both browser capabilities and CSS have encouraged this and the use of inline styles has reduced over time. The advent of JavaScript libraries that hide browser compatibility problems have made the development of progressively enhanced content easier to achieve.

Emacs Package manager

Fri, 24 Dec 2010 00:00:00 +0000

I have a long history with text editors and I have always been facinated with the different flavours of interfaces and capabilities. After working my way through ED and then VI Emacs was a bit of a revalation. I found myself idle for a few minutes this morning and thought I would do some editor maintenance and install haml-mode into my copy of Emacs. While surfing around I came across the Emacs Lisp Package Archive which made the installation a breeze and I then found myself installing all sorts of other additions that might be useful in the future.

Haml

Sun, 19 Dec 2010 00:00:00 +0000

Haml is a markup language for generating xml and other markup - most popularly HTML. Over the past few weeks I have been writing a few Ruby on Rails applications and chose Haml as the templating language. For someone who has traditionally avoided positional languages this was a strange choice. Having written a few simple applications I find that the writing HTML in Haml is both straightforward and intuitive. Good HTML is naturally hierarchical and having this structure both encouraged and enforced in Haml feels right.

Watching the white horses on the Hudson ...

Sun, 12 Dec 2010 00:00:00 +0000

Watching the white horses on the Hudson today and wondering why I am flying on a day like today.

A good day of discussions in Chicago tod...

Tue, 16 Nov 2010 00:00:00 +0000

A good day of discussions in Chicago today. Although I should say yesterday given the time.

Test Driven Talks

Sun, 07 Nov 2010 00:00:00 +0000

Taking a leaf out of the XP book and in particular test driven development I have had some successes in using this idea when doing a presentation. I have dubbed the idea ‘Test driven talks’. The basic idea is to quickly canvas the audience for things that they would like covered during the presentation. Once these have been captured on a whiteboard or flip-chart.

The next step is to filter the topics in the same way as an agile team accepts stories into an iteration it is likely that I wont be able to cover all the expectations from the audience. The nice thing about this step is that I can manage people’s expectations. If I accept a question or topic then people should expect me to satisfy them. If I reject the topic then people know that I won’t be able to satisfy their need.

Testing - what to test when

Wed, 20 Oct 2010 00:00:00 +0000

After tweeting that I wanted to have suggestions for blog entries I got a single reply asking for my thoughts on DAO and unit testing – essentially asking should DAO be unit tested.

The problem with me answering this question is not that I don’t have an opinion but as the question was posed I was reading Steve Freeman, Nat Pryce on just that topic in their new book ‘Growing Object-Oriented Software, Guided by Tests’.

Technology Synergy

Wed, 20 Oct 2010 00:00:00 +0000

I started writing this post quite some time ago but never got around to wrapping up the loose ends. The article is really a summary of what I learnt during a pretty intense media web site development project. Since pictures equate to 1000s of words here is my effort to express how technologies can work symbiotically to delivery value that is more than the sum of their parts.

![Technology Synergy]({{ site.url }}/images/technology-synergy.jpg)

But since systems are built from parts: here are the parts that we used.

Extended SiteMesh

SiteMesh is a pretty amazing technology for creating web sites mashups – or combining HTML documents on the server. We found that by partitioning the content and the parts of the server that delivered that content before combining the individual HTML documents together using SiteMesh to be extremely effective. The server code for each HTML document need only handle the a well defined area but the site could be easily reconfigured to aggregate the content for new purposes.

In memory tests

Think super fast builds, no deployment (in fact no need for a web server), pure Java acceptance tests (i.e. refactorable) and the 80/20 rule on what is good enough to give you confidence that the system works.

Post/Redirect/Get pattern

We built into the application framework that enforced the PRG pattern. POST request handlers could only return a redirect. Any database access performed during a GET request worked with a read only connection or a connection with an transaction rollback making GET requests idempotent.

Simple transaction boundaries

Transaction boundaries have been enforced so that developers do not need to worry about them at all in production code. GET requests run in a transaction that will always be rolled back, POST requests will always commit if successful and always roll back if an exception is thrown. Some serious work went into taming Hibernate so that it did not auto commit, had no mutable static state and was completely encapsulated.

AHAH (Asynchronous HTML and HTTP)

This enables much simpler JavaScript to be written (think JavaScript that never needs to replicate the domain model or business rules on the client) and allows for complete reuse of server side logic. This combined with behaviour CSS bindings ( http://www.bennolan.com/behaviour/ ) leads to NO in-line JavaScript nastiness and more semantic html.

No Session State just persistent documents

The application servers had NO session state, all state changes to documents are persisted which leads to a number of advantages: Users never loose data they have filled in, marketing can see exactly how far a user got before bailing out of a work flow. Users can return to incomplete work and complete the tasks. Users can fill in data in any order they want and only when they are ready do we action their request. Domain objects are only updated once the document has been validated.

Progressive Enhancement and Accessibility

All stories are played vanilla html version first and a second story for JavaScript enhancements. This leads to cleaner simpler semantic html and also allows feedback from the first story to be tacked onto the second story.

NO Logic in the View

We are using StringTemplate to enforce that NO logic can be written in the view, plus it’s super fast, has no “or loops” (think ruby each blocks).

Fighting layout bugs

Wed, 06 Oct 2010 00:00:00 +0000

Finding problems in the layout of web pages is just plain hard. But fighting layout bugs seems to hold a glimmer of light for web developers. Definitely something to check out. Michael Tamm presenting his brainchild is available http://www.infoq.com/presentations/Fighting-Layout-Bugs

Eben Bayer: Are mushrooms the new plastic?

Wed, 06 Oct 2010 00:00:00 +0000

Fascinating TED video on using mushrooms to create materials with plastic characteristics. It looks like Nature got there first...

Dallas geek night

Wed, 18 Aug 2010 00:00:00 +0000

Last week I happened to be in Dallas for a client and was invited along to the Dallas Geeknight held at the ThoughtWorks offices there.

The Dallas Geeknight is ‘oldschool’ which is not surprising since Paul Hammant informed me he formed the original Geeknight in the UK. The primary driver is producing code and committing that code to a repository.

At the start of the evening people offered up their current open source projects elevator pitch style. I pitched two projects bvira and Intercept. There was interest in both but as most people have their own web frameworks the consensus was to work on Intercept.

Using a local Wiki for personal knowledge management

Tue, 03 Aug 2010 00:00:00 +0000

For sometime I have been wondering how best to manage all the information that collects in my laptop. I don’t even have to try to collect data it just arrives in an irregular stream of emails, instant messenger and other symptoms of this connected world. And then there are the other things I want to collect, data from websites, blog articles, eBooks, PDFs and other documents. Added to this meeting notes, observations, ideas for new projects.

Agile Software Development and Golf

Wed, 30 Jun 2010 00:00:00 +0000

![Golf putting]({{ site.url }}/images/golf-putting-banner.jpg)

Faced with the question ‘What do you do?’ from family and friends is more challenging than it should be. Most other professions have been around longer than a generation but writing software applications is different. Especially for my parents and so this is for the vast majority of people who don’t do what I do but would like some sort of idea of what I do.

Optimising build times

Mon, 28 Jun 2010 00:00:00 +0000

I just came across this post and want to remember it so posing here. http://doublebuffered.com/2009/02/11/optimizing-build-times-for-large-c-projects/. I am most interested in the uplift in compilation time based on unused #includes and build reductions for SSDs.

New BTree algorithms for virtual memory systems

Sun, 20 Jun 2010 00:00:00 +0000

This is a very interesting article http://queue.acm.org/detail.cfm?id=1814327 which demonstrates that we should not take things for granted - including algorithms that have been around for a long time.

Blogging from emacs

Wed, 05 May 2010 00:00:00 +0000

After installing WebloggerMode some time ago I had not gotten around to trying it out so I thought I would take it for a spin with this entry.

Nothing earth shattering but the interface is clean and I have a personal commitment to reaquaint myself with the power of emacs.

Installation and setup is straightforward although I would like a little more 1,2,3 style instructions. But then there are only 3 basic instructions before this point:

Performance testing web applications

Sun, 25 Apr 2010 00:00:00 +0000

When performance testing a web application (as in raw operations per second) I have seem many people try to benchmark their new system against the agreed performance level right off the bat. The problem with this approach is that most applications need to be tuned to get the most out of them. Optimistically firing off 100s of requests will most likely cause the server to choke and if you are unlucky die in a gibbering heap.

ReleaseIt partial review

Sat, 10 Apr 2010 00:00:00 +0000

I have been catching up on my reading recently and one of the books I have been trying looking forward to reading is ReleaseIt. I had heard very good things about the book and to my delight they are true. If you are a developer building almost any sort of application but in particular working on java based web applications you need to read this book! I wish it had been available years ago and that I had read it.

7 days with the iPad

Sat, 10 Apr 2010 00:00:00 +0000

So it has been 7 days since buying an iPad. Has it been the life changing event promised by all the pre-launch advertising?

In my case I don’t think my life has changed but it has been enhanced by having one. In a similar way that the iPhone made many on the go tasks easier and in a lot of cases fun the iPad has made other tasks more engaging and fun. I wanted an eReader that would allow me to read technical books while on the go and was willing to pay for that facility. The iPad delivers. Reading is a pleasure and since I already had a nice collection of books from the pragmatic programmers who offer multiple formats for each of their books my bookshelf is nicely full. For other publications in PDF Calibri does a reasonable conversion.

Scraping Railscasts

Wed, 07 Apr 2010 00:00:00 +0000

I had a few moments today to get reacquainted with Ruby and Rails programming. It has been a while but I have found time to watch the occasional Railscast. I want to watch these videos while on the move but unfortunately the iTunes podcasts are not compatible with the iPad/iPhone. Downloading each one is tedious so I came up with the following:

require 'open-uri'
require 'hpricot'

(1..6).each do |page|

  doc = Hpricot(open("http://railscasts.com/episodes?page=#{page}"))

  (doc/"a").each do |l|
    href = l[:href]
    if href =~ /.*ipod_videos.*/ then
      file_name = File.basename(href)

      unless File.exist?(file_name) then
        puts "Downloading #{file_name}"

        File.open(File.basename(href), "w") do |file|
          file.write(open(href).read)
        end
      end
    end
  end
end

iPad and keyboards

Tue, 06 Apr 2010 00:00:00 +0000

There are some quirks to the way the apple bluetooth keyboard works with the iPad. Most of the keys work as you might expect and the pairing system works just fine. There is no real way to navigate around applications and the system that I have found using the a keyboard though so I find myself switching back and forth between screen and keyboard.

The dock is quite vertical which can make the screen position a little off if your are tall and working on a normal desk and chair.

iPad first day on the road

Mon, 05 Apr 2010 00:00:00 +0000

Today I took my new iPad for a day at work:

A colleague had a 3G card for his laptop and shared the connection. Strangely this caused the iPad to pause quite often as if it were trying to connect to something on the net. The connection seemed to drop quite frequently and I was asked to reconnect quite often.

In a meeting I took notes using Pages. On the whole that was successful but downlighting from the ceiling was a little distracting. I was using the iPad with the apple case which inclines the iPad at an angle that makes the keyboard easier to use.

iPad first impressions

Sun, 04 Apr 2010 00:00:00 +0000

There has been a lot of hype around the iPad and I have to confess that after watching the original advertisement I was hooked. But was all the hype justified?

On first use if you are an iPhone user there are few surprises. The larger touch screen is truly superb as an interface and the apps load quickly. I was disappointed that the iBook application was not installed by default and it took me a while to realize I had to download it from the app store.

Post Redirect Get web interaction pattern

Sat, 27 Mar 2010 00:00:00 +0000

Post/Redirect/Get or Redirect after Post is an HTTP interaction pattern that can be used when developing web applications. I have been mentioning it quite a few times in my consulting work and thought I would take a stab a at diving a little deeper in the pattern and its benefits.

Post-Redirect-Get pattern

![Basic Post Redirect Get pattern]({{ site.url }}/images/Basic-Post-Redirect-Get.png)

The sequence diagram above shows how the pattern works to create a resource. First the client requests a form that is used to create the resource. The server obliges returning a HTTP 200 status code and the mark up containing the form.

Collaborating distributed teams

Tue, 23 Mar 2010 00:00:00 +0000

Internet Relay Chat (IRC) has been around for a very long time (1988) and Instant Messaging (IM) for even longer – although IM did not become really popular until the mid 90’s with the emergence of GUI clients. There are many similarities between the two systems but for this article I am concentrating on the differences, specifically around their use as a team communication medium.

IM is optimised for point to point communication between two people. There are options for group communication but this is more of an exception where one person takes on the role of organiser and brings other people into the conversation. IRC on the other hand uses the channel concept, where a channel is synonymous with a topic of conversation. The channel exists independent of the participants in the conversation. Neither system offers a view of the entire conversation, although a lot of clients log conversations.

It always takes a second

Thu, 18 Mar 2010 00:00:00 +0000

Why do application developers think that adding more functionality is always a good thing for the user? When I first started working on GUI applications (Windows 1.0) we worked very hard to get sub-second response times. Now in theory applications running on multi-core 2+GHz processors should out strip 286 CPUs running in the MHz range. What seems to have append instead is that applications have maintained the same sort of response times (in general) taking 1 or more seconds to perform a task.

Inclined Keyboard on MBP

Sat, 06 Mar 2010 00:00:00 +0000

![Raising the MBP Keyboard]({{ site.url }}/images/raised-mbp-keyboard.jpg)

As anyone who knows me will say I have a thing about keyboards and have a few in my current collection.

On a whim today I bought the apple wireless keyboard thinking that I would pair it with my laptop for when I am at home working at my desk. I already have the wired version and have been very happy with the feel of the keyboard. Unfortunately it occupies a USB slot and when I have both my external drive and SLR connected I have to keep swapping peripherals.

Face to Face pairing

Sun, 28 Feb 2010 00:00:00 +0000

Since joining ThoughtWorks in 2004 I have enjoyed Pair Programming and my programming skills have improved significantly. Working on a problem with someone else full time is one of those practices that is difficult to convince people off until they have actually tried it. Laurie Williams at NCSU has done some pretty interesting research into the effectiveness of of pair programming, which is well worth a read.

There are various different styles of pair programming WikiPedia talks about remote and ping-pong paring where people sit side by side using the same screen, keyboard and mouse. Work is typically split along test/application boundaries where one pair writes a test and the other then implements the code to support the test. Control switches back and forth between each of the pairs. The are many variations on this including the use of two keyboards and mice. Pairing in this way with a laptop is often quite difficult unless a separate keyboard and mouse are used.

Server Rebuild - Part II

Thu, 25 Feb 2010 00:00:00 +0000

So after having the server nicely set up and ready for configuration I could not resist just ‘getting on with it’. I had grand plans to plan it out and record everything (good practice) but each step seemed so simple it seemed simplest just to get stuck in.

And for the most part it was simple. Running Unbuntu makes installing software and tools a breeze and after a few hours of intermittent changes everything was up and running from the old server.

Server rebuild – part 1

Thu, 18 Feb 2010 00:00:00 +0000

I have been running my own server for some time now but my requirements have changed and the current underlying VM architecture does not conveniently support what I want to do.

The current linux server is running under OpenVZ which is not that conducive to running Java Applications. So after spending quite a few hours struggling with that thorny problem I have decided to stay with my current hosting provider (VPSlink) but switch to Xen.

Look after your tools

Thu, 18 Feb 2010 00:00:00 +0000

Look after your tools and they will look after you!

I was very lucky to grow up in the country with a father who enjoyed teaching me practical skills like carpentry, motor mechanics and just about every other skill needed to keep the house, car and garden up to scratch. One of the things that was drummed into me at this early age was to look after the tools (at that time I had to borrow my father’s tools).

Don't use application Zoom

Thu, 18 Feb 2010 00:00:00 +0000

A plaintive call to not over use the lovely zoom features in Excel and Word. The zoom parameters are stored in the document so when you receive them it is very unlikely that your zoom setting will match my zoom requirements.

If I change the zoom setting then the document has been changed.

If you store your documents in version control like me then playing about with the zoom settings means a lot more binary style checkins too.

Age discrimination in technology

Thu, 18 Feb 2010 00:00:00 +0000

This article post ‘The painful truth about age discrimination in tech’ left me a little confused. Am I still considered a developer or have I given up the mantle and considered a statistic.

Do I cut code? - yes but not as much as I would like and it is not the thing I do every day.

Is there age discrimination? If there is it not that explicit or something I have taken an offence at.

The rise and fall of waterfall - on you tube

Tue, 09 Feb 2010 00:00:00 +0000

If you have been in software development for a while this might make you chuckle :)

The Rise And Fall Of Waterfall

Switching back and forth - Intellij IDEA and Eclipse

Fri, 05 Feb 2010 00:00:00 +0000

I have to confess that I am an IntelliJ Idea fan. I will confess that the key bindings take a little getting used to - especially on a Mac but I find I am most productive using it.

I do like to keep up with what is happening with the Eclipse project and thought I would pick p the latest Eclipse 3.6M5 (Helios) release. Not really intending to do more than load up a couple of projects and play around for a while.

XP and the cost of change

Mon, 01 Feb 2010 00:00:00 +0000

I have found myself drawing the classic cost of change graph a few times recently so thought I would blog about it. The graph was popular a few year ago in explaining the differences between and eXtream Programming (XP) team cost and a waterfall team cost.

The important thing to remember in interpreting the graph is that the lifetime of a software system is typically far longer than the initial development. Most systems spend much longer in ‘maintenance’ than they ever did in ‘development’ so anything that can be done to make maintenance (ongoing development) more effective has to make sense.

Screen casting

Sun, 31 Jan 2010 00:00:00 +0000

There have been a number of threads recently talking about screen/podcasting and the software required to do a decent job so I thought I would blog about the setup I am using.

After trying a few applications I eventually settled on IShowU HD. It handles screen capture well and supports a wide range of formats.

![Samson microphone]({{ site.url }}/images/0F73A0E6-AE9E-440A-9593-D4D6B19E1F25.jpg)

I tried a couple of microphones (including the built in mic on my MBP) before settling on the Samson C10U. The mic works well but I have not found it to be that sensitive so have to position it between the laptop and me which sometimes makes it difficult to type. Perhaps I will have to invest in a boom to bring the mike over the top - although that may make it more difficult to see the screen.

Wordpress theme update failure

Sat, 30 Jan 2010 00:00:00 +0000

If like me you installed WordPress and added some themes before understanding that WordPress has a great way of adding themes through the UI then make sure that you have changed the ownership of the folders containing those themes.

Otherwise the autoupdate fails and if you update the current theme end up with a maintenance screen. Getting rid of the maintenance screen is pretty easy (delete the .maintenance file) in the blog folder but it still takes a few minutes to solve the problem.

Web application testing - episode 1

Wed, 20 Jan 2010 00:00:00 +0000

This is my first screencast so all and any comments welcome!!

This screencast is about adding an acceptance test to validate the title element in the returned HTML from the application.

[flowplayer src=http://www.grahambrooks.com/video/testing-web-apps-episode-1.mp4 width=550 height=413 ]

The companion code for this episode can be downloaded from http://www.github.com/wookie870/bvira

Subway reading

Sun, 13 Dec 2009 00:00:00 +0000

Over the last month I have been reading Prmodoro Technique Illustrated a fascinating book detailing a technique to apply real focus to problem solving and work in general. One problem I have with almost any kind of reading is finding the time to actually read. But this book is nicely split up into bite-sized chapters which can be read on short journeys. I have taken to downloading books to Stanza an iPhone application which accepts epub format documents. The transfer is a little fiddly but once a URL to the book download is entered Stanza takes care of the download.

Cross post: A Brief And Incomplete History Of Build Pipelines

Sun, 13 Dec 2009 00:00:00 +0000

Sam Newman has just published a Brief And Incomplete History Of Build Pipelines which makes interesting reading.

It will be interesting to see where the concepts take us in the next few years.

Testing abstrations

Wed, 18 Nov 2009 00:00:00 +0000

These ideas were presented as at ThoughtWorks Agile Southeast conference in Atlanta. The idea for these diagrams came about after the first time I spoke about web test driven development at Agile East in Philadelphia and New York. I am striving to show how introducing a level of abstraction affects development costs.

Web applications should testing at various levels, from unit tests through acceptance, workflow and performance (to name just a few categories). For the purposes of this article Acceptance and Workflow tests are defined as follows:

How the Pendulum Swings

Thu, 05 Nov 2009 00:00:00 +0000

![Car parts in a box]({{ site.url }}/images/car-parts-in-a-box.jpg)

A couple of decades ago I spent quite a lot of time working on my car. To be honest it was near the end of its life when I bought it at auction but I had only saved/borrowed enough for a car of that age and at the time I thought I knew a lot more about maintenance than I really did but what I did not know I now had my own car to learn from. As you might expect it was not too long before disaster struck and driving home one day the engine died and resisted my attempts to revive it. Time to to get stuck into car maintenance 101.

WebTDD at Agile East

Sat, 31 Oct 2009 00:00:00 +0000

Just a quick note to say thank you to everyone who attended my talk on Test Driven Web Development at Agile East this week.

Prag Pro Wri Mo

Sat, 31 Oct 2009 00:00:00 +0000

I am going to take part in Prag Pro Wri Mo to find out if I have the inclination and capacity to write or if I am one of those people who would have liked to have written a book.

This initiative seems like a really fun and challenging idea and I am looking forward to getting started.

Agile East WebTDD

Mon, 26 Oct 2009 00:00:00 +0000

On Thursday this week I will presenting a talk entitled ‘WebTDD’ at the ThoughtWorks Agile East conference in Conshohocken PA. It is the first outing for this talk and I have been working on the supporting software for some time.

I am really looking forward to this first speaking opportunity in the US this year.

If you are reading this and attending I look forward to meeting you there.

Wednesday evening in Seattle

Thu, 08 Oct 2009 00:00:00 +0000

![Hyatt Regency]({{ site.url }}/images/IMG_0018.jpg)

This photo was taken from the hotel bar on the top floor of the Hyatt Regency. We were lucky to arrive just as the sun was setting. If you look closely at the horizon you can just make out the mountain profile. Some are already topped with snow.

Just for a moment looking at the sunset makes all the travel worthwhile.

Its Tuesday in Seattle

Wed, 07 Oct 2009 00:00:00 +0000

Not that I have seen anything of the city but I now find myself on the west cost after arriving on the east cost just over a week ago.

The Hyatt Regency here is a pretty nice hotel though and I look forward to a nice nights sleep.

The big apple

Fri, 02 Oct 2009 00:00:00 +0000

![New York]({{ site.url }}/images/IMG_0009.jpg)

October finds me in New York and for the last couple of days I have been walking to and from work (about 10 blocks).
One thing that has struck me is that finding your way around the city is a piece of cake in comparison to say London. In NY the grid system not only makes is easy to find a place but also to know how far away you are.

Another excellent talk on Ted

Fri, 02 Oct 2009 00:00:00 +0000

Adium 1.4ß

Mon, 24 Aug 2009 00:00:00 +0000

I have just discovered that Adium - my favourite IM client for the mac has a new ß version available and now supports IRC so one less application to run every day.

Ultimate agility?

Sun, 19 Jul 2009 00:00:00 +0000

The truly amazing Dan Osman

This has got to be one of the ultimate demonstrations of agility, confidence and poise....

Shenandoah '06

Sun, 19 Jul 2009 00:00:00 +0000

I found this whilst going through some old(ish) photos taken in Shenandoah national park in 2006.

It brought a lot of memories back about that trip - which was just a weekend away but a little adventurous - the first time I had seen a Bear in the wild and probably the hottest, dampest walk I have every done.

Relaxation

Sun, 19 Jul 2009 00:00:00 +0000

Another photo from the trip to Shenandoah. Yours truly taking time out…

I remember there was a cool breeze drifting up the river - it was a warm day

Java Properties handling - 1

Sat, 18 Jul 2009 00:00:00 +0000

I have been on a number of Java projects recently and one of the things I end up brewing for each of these projects is some enhanced management of runtime properties.

Having said there are problems with using .properties files they are well understood and supported by all the major Java tools and IDEs. There would have to be a very strong reason to use another format (and no I don’t mean XML).