Building Breakout

Why a Game?

Breakout is small enough to build in six sessions and rich enough to surface real design problems: collisions, rules, inputs, views, tests, and code structure.

It is not about the game. It is about studying how design decisions affect complexity, implementation effort, and cost-of-change metrics in a working software product.

This is the first course in the Cost-of-Change Challenge. After Breakout, later courses study a text editor and a trading-alert system using the same measurement approach.

Three Steps

Building Breakout is organized in three steps.

1. Design Review — "The Breakout Game: Different Designs Compared". Different implementations of the same game are reviewed side by side. We compare what each design makes easier to change, what each design makes harder, and what the metrics show. Free and open to everyone.
2. Course — "Building Breakout". Over six sessions, I walk you through building a complete Breakout game from scratch using Combinant® course materials, code examples, tests, and metrics. At key design moments, we stop, compare alternatives, and reason about implementation choices.
3. Results — "Building Breakout: What We Built". The final product, the code, and the metrics dashboard. We review the data, compare design decisions, and answer questions. Free and open to everyone.

What You'll See

I’ll build a complete 2D text-based Breakout game from scratch, step by step. You’ll follow each design decision, each test, and each snapshot of the product.

At key moments, we work together on challenging software-design problems using code, tests, and metrics.

• Decentralized collisions — developed one test at a time, without relying on a single centralized conditional-heavy algorithm.
• Rule variations — scoring, lives, and win/lose conditions compared through implementation examples.
• View variations — local terminal and remote Telnet views observing the same model.
• Input variations — keyboard and TCP input examples compared through implementation choices.
• Software structure — design decisions reviewed for complexity, maintainability, and cost-of-change metrics.

Features will be added: power-ups, new brick types, and new rules. Each change is measured using a metrics dashboard that tracks implementation effort and software-development data.

You'll see it all in the numbers: a metrics dashboard tracking real effort across every feature. The dashboard shows how implementation effort changes across features. That's the point.

The code from this course becomes a reference product for later Combinant® courses, including Building MiniVi and Building Trading Alerts. Different products, different domains, measured with the same metrics.

The Cost-of-Change Challenge

Building Breakout is the first product in the Cost-of-Change Challenge. Three products. Three domains. Measured with the same metrics.

→ Building Breakout — A game. You are here. → Building MiniVi — A text editor. → Building Trading Alerts — A data alert system.

Dates & Registration

Click on the time to see it in your timezone

The Instructor

Francesco Cirillo. Creator of the Pomodoro® Technique. Senior software designer, Extreme Programming pioneer. Decades of software design led to one question: how do software teams make cost-of-change considerations visible and measurable?

Related

• Why collision detection is still a centralized problem.
• How we measure the cost of change