Clean Code and Design Patterns: a pragmatic approach

Course overview

Description generated based on course syllabus and open data.

A practical course focused on speeding up and simplifying development with design patterns and clean code principles. Under the mentorship of a lecturer with 15+ years of experience, you will work through 20+ patterns, refactoring techniques, and architecture, analyzing both popular and specialized patterns to improve application structure and code quality.

Program and format: clean code and design patterns

• 16 online sessions (Mondays and Wednesdays).
• 20+ patterns: GoF, structural, behavioral, and architectural approaches.
• Hands‑on refactoring and architecture improvements.
• Course project: a game using design patterns.

Lecturer and industry background

Viacheslav Shchupak, Software Developer at Sportradar.

• 15+ years in software development and project management; last 4 years — backend at Sportradar (sports analytics).
• Consulted the Diia team on the feature «commissioning of a facility» (bug localization, system configuration).
• Developed mobile apps for Kyiv City State Administration and systems for contact center «1551».
• Built systems for translators at SDL International; experience with Big Data.

Who benefits from clean code and design patterns

When this design‑pattern approach fits

• Developers seeking to apply software patterns consistently in production code.
• Engineers maintaining or evolving backend and cross‑platform applications.
• Those strengthening refactoring practices and documenting architectural decisions.

When it may not fit

• If you need only framework‑specific topics without general patterns.
• If you expect pure theory without code and hands‑on practice.

Development issues → outcome via design patterns

• Code bloat → clean code refactoring to reduce coupling and duplication.
• Fragile architecture → selecting suitable patterns (e.g., Strategy, Adapter, Factory) for requirements.
• Hard‑to‑test modules → decomposition and dependency inversion for simpler unit testing.
• Legacy code → incremental refactoring patterns without full rewrites.

Comparison with alternatives: clean code and design patterns

• Self‑study: flexible but slower due to curation; a structured path with practice helps consistency.
• Framework‑only tutorials: fast within a stack but less portable; patterns are stack‑agnostic.
• Books/lectures only: strong theory, yet practice is harder; here the focus is on applied coding.

Practical outcomes after learning clean code and patterns

• Systematic selection and composition of software patterns.
• Clear architecture and controlled complexity.
• Stepwise refactoring of legacy solutions.
• Well‑reasoned documentation of technical choices.
• A completed course project — a game using design patterns.