Three 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 using software-design and cost-of-change metrics.
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 three different ways: procedural, object-oriented, and event-driven. Same requirements, three different trade-offs. Each one solves some design problems and creates new ones. You'll see where coupling hides, where cost-of-change considerations become visible, and why no single approach makes everything easier. This is the starting point of Building Breakout — the first product in the Cost-of-Change Challenge. The workshop sets up the design question. The course that follows measures the results.
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 language, and trace four decades of design evolution: procedural, object-oriented, event-driven. Each one solves some problems and creates others. We compare responsibilities, coupling, data flow, and cost-of-change considerations side by side. 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.
Three 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 considerations 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 software-design problem addressed in Combinant® courses and materials.
This is the first workshop of Building Breakout — the first product in the Cost-of-Change Challenge. Three products, three different domains — all studied through Combinant® course materials, code examples, tests, and metrics to compare design decisions and cost-of-change behavior.
Next in the Challenge: → Building MiniVi → Building Trading Alerts
Prerequisites: None. Open to everyone and a great entry point to the series.
Free online workshop
Duration: 3.5 hours
Introduction and Setup
Goals, criteria, and how to read code through design lenses.
Integer BASIC — Where It Started
Structured programming in practice — from Wozniak's hardware to software
Assembly Language — Before Structure
No roles, no modules — just jumps and memory
Review 1: From Procedures to Modules
Functions, parameters, and the first useful boundaries
Review 2: Object-Oriented — The Mainstream
Objects, responsibilities, and invisible coupling
Review 3: 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. 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?
Build the game using Combinant® course materials, code examples, tests, and software-development metrics.