Six ways to build the same game. From 1976 to today. Each approach solves some design problems — and creates new ones. We compare them side by side to find out what each one actually costs.
Free workshop. Open to everyone.
Every design approach makes some things easier and other things harder. But you rarely see that on the same product. In this workshop, we take one game — Breakout — and build it six different ways: structured, procedural, object-oriented, functional, event-driven, and in raw assembly. Same requirements, six different trade-offs. Each one solves some design problems and creates new ones. You'll see where coupling hides, where the cost of change rises, and why no single approach makes everything easier. This is the starting point of Combining Breakout — the first product in the Decreasing Cost Challenge. The workshop sets up the question. The course that follows measures the answer.
We start with Breakout in Integer BASIC — the language Wozniak used when he wanted to recreate the game in software on the Apple II. Then we look under the hood at assembly, and trace four decades of design evolution: procedural, object-oriented, functional, event-driven. Each one solves some problems and creates others. We compare responsibilities, coupling, data flow, and cost of change across all six. The event is free. We'll also give away one free ticket for the hands-on course sessions.
You write software for a living. You've used at least two or three of these approaches. You have opinions about them. This session puts them side by side on the same product — so you can see what each one actually costs when requirements change.
Six approaches. Decades of evolution in software design. See how each one solves some problems — and what new ones it creates. Compare responsibilities, coupling, cohesion, and cost of change side by side on the same product. Leave with a sharper intuition for evaluating design trade-offs in your own code — and a clear picture of the problem that Combinant® Design sets out to solve.
This is the first workshop of Combining Breakout — the first product in the Decreasing Cost Challenge. Three products, three different domains — all built with Combinant® Design to find out: can this method actually reduce the cost of change?
Next in the Challenge: → Combining MiniVi → Combining Trading Alerts
Prerequisites: None. Open to everyone and a great entry point to the series.
Free online workshop
Duration: 2.5 hours
Introduction and Setup
Goals, criteria, and how to read code through design lenses.
Review 1: Integer BASIC — Where It Started
Structured programming in practice — from Wozniak's hardware to software
Review 2: Assembly — Before Structure
No roles, no modules — just jumps and memory
Review 3: From Procedures to Modules
Functions, parameters, and the first useful boundaries
Review 4: Object-Oriented — The Mainstream
Objects, responsibilities, and invisible coupling
Review 5: Functional — The Alternative
Pure functions, immutable state, and the cost of purity
Review 6: Event-Driven — The Most Decentralized
Decoupled behavior through events — until flexibility becomes complexity
Comparative Takeaways & Q&A
Your questions, observations, and what comes next
Francesco Cirillo. Senior software designer, Extreme Programming pioneer. Decades of designing software led to a question: how do you reduce the cost of change? Combinant® Design is his answer.
Build the game by applying Combinant® Design. Measure the cost of change