Game of Life in Python (SOLID + Design Patterns) | Project Series — Episode 2

Welcome to Episode 2 of “Game of Life” series — a practical, non-trivial project where we apply SOLID principles and core GoF design patterns in a real architecture (not toy examples).

🗺️ Episode 2 — Architecture Tour (Layers, SOLID, and Patterns)
Before we write more code, we zoom into the starter architecture and build a clear mental model:
layers, responsibilities, and where each pattern lives — using the layer diagram, class diagram, and sequence diagram.

If you haven’t watched Episode 1 yet (overview + roadmap):
https://www.youtube.com/watch?v=PIDrbtykQPY

And if you want the warm-up before this episode (Stage 1 practice session):
https://www.youtube.com/watch?v=YXYRZpc5pDE

If you’re coming from my Udemy course, this series is the more advanced, end-to-end example that puts those concepts into practice. If you’re new here, this episode and series is designed to be self-contained.

📌 Course (optional, for deeper structured learning)
Python SOLID Principles and Top Design Patterns
“Learn how to improve your Python code through mastery of S.O.L.I.D principles and the Top GoF Design Patterns.”
https://www.udemy.com/course/python-solid-principles-and-top-design-patterns/?referralCode=FF0C76B7BBD9648CB5FC

🧩 What this series builds toward
We’ll end with a multi-session, web-based simulation server, with a clean layered design:
- Domain layer (grid, rules, seeding)
- Engine layer (simulation lifecycle)
- UI & API layers (console, FastAPI, web)

💻 Source code
Supporting repo (code + docs/diagrams):
https://github.com/codecreativeworks/game-of-life-python-solid
If you need a primer now how to get the code from the git go here:
https://www.youtube.com/watch?v=YXYRZpc5pDE

🧭 What we cover:
- High-level layering:
- core: domain (cells, grid, rules)
- engine: simulation lifecycle
- ui: ports + presentation
- config: builder & configuration
- A simple class diagram:
GameEngine, Grid, RulesStrategy, ConsoleUI
- Pattern map (where each pattern lives):
- Strategy: RulesStrategy / ConwayRules
- Factory Method: RulesFactory
- Builder: GameConfigBuilder
- Observer: GameObserver + GameEngine.subscribe(...)
- State: SimulationState (preview)
- Adapter: LocalEngineAdapter
- Why this design already prepares us for a remote/server-based engine later (FastAPI/WebSockets)

▶️ Next episode (Ep 3) — Architecture Tour: Layers, SOLID, and Patterns
We’ll start modeling the domain deeper (Grid, Cells, Neighbors) and move into more concrete implementation details. We will be coding!

⏱️ Chapters
00:00 Coming up
00:23 Welcome + episode goal
00:52 🧭 Roadmap: layers + SOLID + patterns
01:41 Folder structure → architecture layers (SRP)
02:14 Layer diagram overview
02:52 Layer responsibilities (core/engine/ui/config/infra/server)
04:35 File map: where classes live (source files)
06:44 Layer recap: engine at the center
07:06 Sequence diagram walkthrough (UI → port → engine → rules)
08:55 Patterns in the sequence (Strategy + Observer + DIP)
09:43 Stage 1 code tour begins (where patterns show up)
10:03 Core domain: Grid + Rules + RulesFactory
11:30 Strategy pattern in code (RulesStrategy / ConwayRules)
12:10 Factory Method + OCP (RulesFactory)
14:53 Engine + ports overview (Observer + snapshots)
18:28 GameEngine code: subscribe + notify observers
19:04 UI ports: GameObserver + GameUI
20:04 Config layer: Builder pattern (clean construction)
21:54 GameConfigBuilder code walkthrough
23:10 UI + server layers: control loop + adapters
24:35 ConsoleUI: controller + observer responsibilities
26:00 Adapter pattern: RulesEnginePort + LocalEngineAdapter
26:40 ConsoleUI code: on_generation + main loop commands
28:06 LocalEngineAdapter code: start/pause/resume/stop/step
29:38 Remote prep: swapping adapters later (WebSockets)
30:02 Multi-session hint: SimulationRegistry
32:07 Wrap-up + key takeaways
33:27 Next episode preview (domain modeling + neighbors)

More episodes coming soon — subscribe to follow along.
#python #softwarearchitecture #solid #softwarearchitecture #designpatterns

Видео Game of Life in Python (SOLID + Design Patterns) | Project Series — Episode 2 канала CODE CREATIVE