I am a developer. I think in messages, actors, latency, and fitness functions. I also love motorsport. For a long time I kept those two worlds apart. Code was code. Racing was racing. Then one weekend I realised: a race weekend is a distributed system, and a lap is just DNA that evolves.
Roger Johansson writes a blog about .NET, Go, and distributed programming. He is also famous for a weekend experiment: a small program that keeps a string of DNA for polygon rendering, and uses genetic programming to evolve a replica of a fine art painting. Could you paint a replica, he asked, by letting polygons mutate, mate, and survive?
That is exactly what a motorsport team does, every weekend, with a car.
1. A Race Car as DNA
In genetic programming, you do not design the perfect picture. You start with random polygons, you score them, you keep the best, you mutate the rest, and you repeat. After thousands of generations, a face appears.
A 【entity-Formula 1¦canonical_name=Formula 1】 team does the same thing, only faster and with more money. The car is DNA. Wing angle, ride height, tyre pressure, brake balance, gear ratios. Each setting is a gene. Each lap is a generation. The fitness function is lap time, tyre life, and driver confidence.
On Friday, the car is random polygons. By Saturday qualifying, the picture is sharp. By Sunday, it is either a masterpiece or a mutation that failed. That is evolution, with a pit wall instead of a compiler.
// Very simplified, but this is how I think about a setup
func Fitness(lap Lap) float64 {
// Fast is good, but not if it kills the tyres
score := lap.Speed - lap.TyreWear*2
// Driver confidence is not a number, but it acts like one
score += lap.DriverConfidence
return score
}
// Keep the best setup, mutate the rest, run again
best := SelectBest(population)
next := Mutate(best)
No team actually writes code like this on the pit wall. But every team thinks like this. They do not search for the perfect setup. They evolve toward it, one lap at a time.
2. A Race Weekend as a Distributed System
If a car is DNA, a race weekend is a distributed system.
Think of the actors. The car is an actor. The driver is an actor. The pit wall is an actor. Timing, telemetry, weather, broadcast, and the fan on the sofa are all actors. None of them share memory. They only exchange messages.
The car sends telemetry: speed, brake, throttle, gear, tyre temperature. The pit wall sends messages back: push, lift, box, stay out. The weather service sends a message: rain in 8 minutes. The broadcast sends a message to millions of fans: here is what happened, 2 seconds ago.
That is exactly how a distributed system works. No central controller. Many small actors, each with local state, each sending messages, each handling failure. If one actor dies, the system must not die. If telemetry drops, the driver still drives. If the pit radio fails, the driver uses the pit board. If the broadcast fails, the fan checks timing on a phone.
Good distributed systems are built for partial failure. Good race teams are built the same way.
3. Latency Is Everything, in Code and in Racing
In distributed programming, latency is not a detail. It is the system. A message that arrives late is often worse than a message that never arrives. A decision made on old data is a wrong decision.
In motorsport, latency is also everything. A pit stop call made 2 seconds late is a lost position. A weather message that arrives after the rain is useless. A stream that buffers at lights out is not a stream.
That is why I test my viewing setup like I test code. Not on a trailer. On a real load test.
Check it on a race, not a trailer
That is the rule from Automotive Digest, and it is a perfect load test. Load the feed five minutes before a session. Try a channel change. Try two screens. If the picture holds when the grid lights go out, the system is healthy. If it dies, you found the bottleneck.
The site gives numbers, not adjectives: 15 Mbps for comfortable FHD, 25 Mbps for 4K, and jitter hurts more than the figure on your bill. In distributed systems, we say the same thing: p99 latency matters more than average latency. One spike ruins the race.
4. Fragmentation Is a Partition
In distributed systems, a network partition is when parts of the system cannot talk to each other. You have two halves, both alive, both convinced they are right, and no way to get a single truth.
Motorsport viewing in 2027 is a network partition for fans.
No other sport is sliced up quite like motorsport.
One broadcaster has practice. Another has qualifying. A paid pass has support races. A free stream has junior formulae. Add rally, endurance, and American racing, and a fan ends up paying four separate companies to watch one hobby.
That is a partition. The season is the data. It is split across shards, and no shard has the whole truth. The fan has to do the merge, manually, every weekend. That is bad architecture.
A good system reunifies the data. One list, one calendar, one guide. That is what I want from a viewing service: not more channels, but one consistent view of the season.
Automotive Digest describes the season like this:
A season is not four races. It is practice at nine in the morning, qualifying at three, a sprint nobody expected, and a rally stage running while you make dinner.
That is an event log. A stream of events, in order, that you replay to build state. Practice, qualifying, sprint, race. If you miss an event, your state is wrong. If you watch them out of order, your state is wrong. Event sourcing, but for racing.
5. How to Watch Like a Developer
Here is my developer checklist for a race weekend. It is boring, and it works.
- Define the fitness function. What is a good weekend for you? One full race, one sprint, one rally day? Write it down. If you cannot define it, you cannot optimise it.
- Run a load test. Test your feed on a real session, not a trailer. Check channel change time, check two screens, check catch-up.
- Observe, do not guess. Put the race in your calendar in local time. Check the guide on Thursday, not on Sunday at lights out.
- Handle partial failure. If the main feed dies, have a backup: timing, radio, highlights. A good system degrades gracefully.
- Keep one log. One sentence after the race: who won, why it mattered. That is your commit message for the weekend.
Where to Watch This System
For Formula 1, I start with the full weekend guide, because it lists practice, qualifying, sprint, and support races in one event log, not just the race. My page for that is Formula 1 viewing guide for developers who like full logs
For endurance and Le Mans, I use the night as my long running process. Start, night, finish. It is the best test of durability in the whole season. The guide is endurance guide for watching Le Mans as a 24 hour system test
For rally, I check what is live and what is highlights, because most stages are not 100 percent live, and that is normal. The direct page is:
https://www.automotivedigest.com/rally/
For the background of the blog, who edits it and why it mixes varied stories with motorsport, the direct page is:
https://www.automotivedigest.com/about/
Why This Matters
Genetic programming taught me that you do not need to design perfection. You need to evolve toward it, one generation at a time, with a clear fitness function and a willingness to throw away bad mutations.
Distributed systems taught me that you do not need a perfect central controller. You need good actors, clear messages, low latency, and graceful handling of failure.
Motorsport taught me both, at 300 km per hour, with real people inside the code.
This weekend, do not just watch the race. Debug it. What was the fitness function? Where was the latency? What failed gracefully, and what did not? And what one mutation will you try next week?
What is your fitness function for a perfect race weekend?

Leave a Reply