Design Patterns for Scalable and Concurrent Systems

(Focus: The “what, why, and how” of clean code and technical debt reduction)

This module provides the vocabulary and techniques for improving existing code.

• Principles of Clean Code: Writing code that is readable, simple, and expressive.
• Identifying Code Smells: Learning to spot common issues such as:
  • Bloaters: Long Method, Large Class, Data Clumps.
  • Change Preventers: Shotgun Surgery, Divergent Change.
  • Dispensables: Duplicate Code, Dead Code, Comments as a crutch.
  • Couplers: Feature Envy, Inappropriate Intimacy, Message Chains.
• Core Refactoring Techniques: Learning specific, safe techniques to fix smells.
  • Composing Methods: Extract Method, Inline Method.
  • Moving Features: Move Method, Move Field, Extract Class.
  • Organizing Data: Replace Magic Number with Symbolic Constant.
  • Simplifying Conditionals: Decompose Conditionals.
• Functional Python techniques (e.g., function-based “template methods” using first-class functions).
• Hands-On: Participants will be given a codebase with known code smells and will apply specific refactoring techniques to improve its quality.

(Focus: The five pillars of modern object-oriented architecture)

A focused deep dive into the principles that enable flexible and maintainable systems.

• S – Single Responsibility Principle: A class should have only one reason to change.
• O – Open/Closed Principle: Software entities should be open for extension, but closed for modification.
• L – Liskov Substitution Principle: Subtypes must be substitutable for their base types.
• I – Interface Segregation Principle: Many client-specific interfaces are better than one general-purpose interface.
• D – Dependency Inversion Principle: Depend upon abstractions, not concretions.
• Encapsulation, Cohesion, and Loose Coupling: Mastering the balance for flexible and robust components.
• Hands-On:  Multiple design and coding exercises where participants refactor a system that violates several SOLID principles into a compliant, robust design.

(Focus: Implementing proven solutions to common problems)

This module introduces the foundational “Gang of Four” patterns, with a heavy emphasis on practical implementation.

• Creational Patterns: Factory, Singleton, Builder (Solving object creation problems).
• Structural Patterns: Adapter, Composite, Proxy (Simplifying how objects and classes are composed).
• Behavioral Patterns: Observer, Command (Managing object responsibilities and communication).
• Hands-On: Implement a feature using Observer and Factory patterns to create a flexible and extensible system.
• Hands-on emphasis on Builder, Observer, and Composite; lower-priority patterns may be omitted as needed.

(Focus: Writing correct and efficient concurrent code)

This module tackles the challenges of multithreading, focusing on patterns that prevent common errors like race conditions and deadlocks.

• Core Concepts: Threads, shared resources, race conditions, and synchronization strategies.
• The Producer-Consumer Pattern: A deep dive into one of the most common concurrency problems.
• Thread Pool Pattern & Executor Frameworks: Managing thread lifecycles efficiently.
• Other Concurrent Patterns: A look at Future/Promise and Observer in concurrent contexts.
• Future/Promise patterns with dedicated hands-on exercises.
• Link concurrency discussions to the Observer pattern (reactive eventing and callbacks).
• Hands-On:
  • Build a thread-safe producer-consumer system from scratch.
  • Hands-on with Future/Promise to coordinate async workflows (de-emphasizing executor-focused drills).