• • Setting Up Your Development Environment - Learn how to setup your development environment for success (this is more important than you think): which plugins/extensions to use and what settings to change to make your life easier.

  • Types And Type Hints - Knowing what types and type hints are and how they work in Python is really important. In this lesson I dive into the details of type systems, how things work in Python, and show you best practices so you get the most out of using type hints.

  • Data Structures - A core piece of software design is using data structures correctly. Each data structure has its own pros and cons. Knowing about these is going to help you take better decisions about which data structure to use when.

  • Classes And Data Classes - Though this is not a complete introduction of object-oriented programming, I talk about classes and data classes in detail in this lesson and how they fit into software design.

  • The Mighty Function - This lesson is a deep dive into functions: what they are, more advanced things you can do with them and when to use functions as opposed to classes in your design.

  • Inheritance, ABCs And Protocols - In the final lesson of this module, you learn about abstraction, which is a core element of software design. I cover the various ways in which you can achieve abstraction in Python to help you choose the best option for your design.

The second part of the course presents the 7 Principles Of Modern Software Design. It takes many of the existing design principles and adapts them to the needs of the modern software designer. It goes way beyond object-oriented design by teaching you generic principles that apply to any programming language and paradigm, whether that’s object-oriented, purely procedural, or functional.

• Favor Composition Over Inheritance - Learn how to approach inheritance in code and use it in a balanced way by looking at several code examples.
• High Cohesion - Various techniques for making sure that the code you write has clear responsibilities.
• Low Coupling - Learn how to reduce coupling between different areas of your application so that your code is easier to maintain in the future.
• Start With The Data - What role does data play in the design process? When should we think about data and data structures in software design? And what is a practical process for modeling the data structures in your software?
• Depend On Abstractions - Abstractions such as ABCs and Protocols help reduce dependencies. In this lesson I show you how to use these abstractions effectively.
• Separate Creation From Use - You learn different ways of creating objects in a software system, and how to have better control as a software developer over how and when objects are being created.
• Keep Things Simple - As a software developer, how do you keep things simple? I talk about different ways to make sure your code stays simple, even if the application itself is complex.

• Mixins - You learn what Mixins are, why you need to be very careful with them, and what the much better alternatives are.
• Dealing With Errors - Any application has to properly deal with errors. Here you learn how error handling works in Python, what the different possibilities are as well as some of the more advanced error handling mechanisms such as context managers.
• Setting Up A Complex Software Project - Learn about files, folders, modules, packages, absolute and relative imports. Learn how to structure your code properly, and what should generally be in a code repository.

This module truly takes the course to the next level, offering an in-depth, practical case study where I teach you how to build an API from scratch in Python. I'll go through the entire process with you covering every aspect:

• Modelling The Domain - Why understanding the domain before you start developing is important, and how you can quickly create a model using dataclasses.
• Project Scaffolding - Complete scaffolding of an API product, learn to quickly setup an API server, integrate with a database and design the data structures that you'll need.
• Architecture - Setup the architecture of the API, and structure your code accordingly, applying the principles you've learned in the first three modules to make the code future-proof.
• Building Out The System - Create multiple endpoints, implement the basic operations of the API, using a clean architecture to nicely separate the different areas of the API.
• Creating A Testable API - Add unit tests to the API software to make the code more robust. Learn how architecture and design help make testing your code a lot easier.
• Using AI Sparring (NEWLY ADDED!) - Learn how to effectively use AI tools such as ChatGPT by asking 4 types of questions that help you design great software.

A really fun series of 15 videos, each highlighting one simple thing you can do to improve your software's design that takes only a few minutes from avoiding type abuse and writing symmetrical code, to avoiding redundancy and using protocol segregation.

Design Patterns are standard, reusable solutions to common problems, like the dovetail joint in carpentry, or the 4-cylinder motor design. In software, we have design patterns as well. The ones most people know have been published in a 1994 book called “Design Patterns: Elements of Reusable Object-Oriented Software”. But software and the way we design it evolves. These patterns are 30 years old now and follow object-oriented design, a design methodology from the same time period. If you stick to using these patterns only, you risk ending up with code that feels outdated and doesn’t integrate well with the way we work nowadays.

I realized that we need a new take on design patterns. One that relies on modern language features and that is less tied to object-oriented design. So I’ve created Pythonic Patterns: an extension of The Software Designer Mindset that teaches design patterns differently.

Pythonic Patterns contains my favourite design patterns that I’ve been using successfully for many years and adapts them to use modern features offered by programming languages like Python: protocol classes, tuples, higher-order functions, partial function application and more. With these patterns, you’ll have a completely new set of incredibly powerful tools at your fingertips that will help you design great software faster than ever before.

Pythonic Patterns offers:

• A natural extension of The Software Designer Mindset that builds directly on the principles from the course
• Over 3 hours of extra video training material covering modern variations of Strategy, Bridge, Command, Template Method, Chain Of Responsibility, and several other patterns that are not in the literature
• Advanced patterns using concepts taken from functional programming
• Practical code examples in Python
• Quizzes
• Exercises to practice with the material
• Downloadable Mermaid diagrams ready to integrate into your own designs
• Reference implementations of each of the patterns
• Lifetime access to all the material
• Certificate of Completion