Become a senior developer

• Type Hints: You'll explore types and type systems in programming, with a focus on dynamic typing versus static typing in languages like Java and C#. You'll see how types can improve code readability and prevent errors, while also diving into different typing paradigms. Plus, you'll learn how type annotations can enhance code quality and boost your productivity as a developer.
• Data Types: You'll learn how important data types are for handling data efficiently and understanding your code better. By exploring numerical types, text types, and limited state types, you'll see how they help you avoid performance issues, prevent precision errors, and make your code more readable and less prone to mistakes.
• Data Structures: Explore core data structures like lists, dictionaries, tuples, and sets, discussing their strengths, weaknesses, and best use cases for efficient software design. Additionally, you'll learn about key concepts such as mutability, order, and uniqueness.
• Classes and Data Classes: Explore Python classes, focusing on both data-focused and behavior-focused types, and their role as blueprints for creating objects. You'll also cover advanced features of data classes, alternative packages like Pydantic and attrs, memory optimization techniques, and the importance of encapsulation using underscores.
• The Mighty Function: You'll learn to appreciate the simplicity of functions over classes and explore key functional programming concepts like pure functions, higher-order functions, and partial function application to write more readable and maintainable code.
• Inheritance and Abstractions: Understand inheritance, a core concept in object-oriented programming where a class inherits properties and methods from another, offering benefits like code reusability and flexibility, but also potential complexity. You'll also learn how abstract base classes (ABCs) enforce method implementation and how protocols allow objects to conform to an interface without explicit inheritance, helping you write more modular and maintainable code.
• Mixins: Explore mixins, a pattern that uses multiple inheritance to inject behaviors into a class, offering horizontal class extension unlike traditional inheritance. Through practical examples like an employee management system, you'll see how mixins combine functionalities, while also addressing complexities such as order-dependent behavior, conflicts with instance variables, and challenges with typing systems.

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. In this module, I'll cover:

• Favor Composition over Inheritance: Effectively use inheritance and composition to create subclasses that extend existing classes by adding or overriding methods and properties. You'll also learn to avoid common misuse of inheritance, which can lead to tightly coupled, complex code.
• High Cohesion: Improve your code by focusing on cohesion, ensuring each part has a single responsibility for easier management and clarity. You'll learn about cohesion issues in functions and modules, and learn the importance of regular refactoring to maintain high cohesion, resulting in cleaner, more modular, and easier-to-update code.
• Low Coupling: Understand coupling—the dependency between different parts of code—and how low coupling leads to more independent, reusable, and modifiable modules. You'll explore various types of coupling and learn the principle of least knowledge (the law of Demeter) to strategically manage dependencies and design better software.
• Start with the Data: Improve your code by using inheritance and composition effectively, allowing subclasses to extend existing classes. You'll learn to avoid the misuse of inheritance, which can lead to tightly coupled, complex code, and understand how improper use often increases complexity.
• Depend on Abstractions: Learn key design principles for complex software across programming paradigms, focusing on abstraction to reduce coupling. Furthermore, you'll explore how to decouple code with protocols and abstract base classes, creating flexible and maintainable software by prioritizing core principles over specific design patterns.
• Separate Creation from Use: Improve your code's cohesion by separating object creation from usage, as combining them can lead to tightly coupled and harder-to-manage code. You'll explore techniques like the factory design pattern, creator functions, and dependency injection to help decouple object creation from usage, making your code easier to extend and maintain. Additionally, you'll learn about the open-closed principle, understanding that while this approach simplifies extending functionality, it can sometimes make core modifications more challenging.
• Keep Things Simple: Focus on writing simpler, more effective code by embracing simplicity without losing functionality. Think of simplicity as crafting code that's easy for you and others to understand, change, and test. You'll learn key principles like DRY (Don't Repeat Yourself), KISS (Keep It Simple, Stupid), and YAGNI (You Ain't Gonna Need It) to help you achieve simplicity.

• Project Scaffolding: Organize your projects effectively by establishing a solid structure that supports growth and collaboration. Think of proper organization as creating a foundation that keeps your code manageable, maintainable, and scalable as your project expands. You'll learn how to set up a well-structured project, choose the right tools, and avoid common pitfalls, ensuring your Python development process stays smooth and controlled.
• Organizing Your Code: Proper organization here is key to keeping your codebase clear, maintainable, and scalable as your project evolves. In this lesson, you'll learn essential definitions, best practices, and how to avoid common mistakes, ensuring your code remains well-structured from the beginning.
• Error Handling: Managing errors and exceptions is vital in building robust software applications, with a key distinction between errors, which are critical issues, and exceptions, which can often be handled. You'll learn how to effectively use try-except blocks, custom error classes, and context managers in Python to enhance your code's reliability. You'll also see best practices for when, what, and how to raise and manage errors, helping you design more resilient software.

This module elevates your understanding and the importance of domain-focused design in software development. You'll learn how to approach your projects with a deep understanding of the domain, ensuring that the solutions you create are not only functional but also aligned with the needs of your users or clients.

• Introduction to Domain Modeling: An overview of what parts to expect from this module.
• Domain Building Blocks: In this lesson, you'll gain a solid understanding of the foundational building blocks of domain-centric design, an essential skill for any software developer. You’ll learn how to identify and work with entities, value objects, and aggregates—core concepts that help you structure and organize complex domain models.
• Domain Modeling: You'll learn how to effectively translate a domain into code by identifying core and supporting domains, determining key objects, entities, and aggregates, and understanding their relationships. You'll discover that domain modeling isn't about perfectly mirroring reality but simplifying and approximating it to create a manageable system.
• Implementing Effective Domain Models: In this lesson, you'll learn how to implement a domain model in code, recognizing that a direct one-to-one mapping between models and code structures isn't always possible. You'll explore how architectural patterns and design principles support domain-driven design in both object-oriented and functional programming. You'll understand the importance of iterating on your models and code as you gain new insights, allowing for flexibility and continuous refinement to better meet user needs.
• (BONUS) Collaboration and Communication Strategies: In this bonus lesson, you'll learn the importance of proactive communication in software development and how to effectively engage with users, customers, and stakeholders. Additionally, you'll understand the benefits of fostering a learning culture.

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.

• Introduction and Domain Model: 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 set up an API server, integrate with a database, and design the data structures that you'll need.
• Architecture: Set up 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: Learn how to effectively use AI tools such as ChatGPT by asking 4 types of questions that help you design great software.

Adopt coding practices that prioritize clarity, simplicity, and maintainability. Focus on creating well-structured, efficient code by following design wins to improve your design without focusing on certain patterns and principles. These wins only take a few minutes and will improve your software design.

Design Patterns are like the dovetail joint in carpentry—reliable, reusable solutions. The classic 1994 book introduced patterns based on object-oriented design, but those are now nearly 30 years old. Sticking with them can leave your code feeling outdated. ⚙️

That's why I created Pythonic Patterns, an extension of The Software Designer Mindset. It brings modern language features and moves beyond rigid object-oriented methods. 🐍✨

Pythonic Patterns includes my favorite, battle-tested patterns, adapted for modern languages like Python. You'll learn to harness powerful tools like protocol classes, tuples, higher-order functions, and partial function application. With these, you'll be able to design cleaner, faster software like never before.

Here's what you'll get:

• 3+ hours of extra video content covering modern versions of Strategy, Bridge, Command, Template Method, and more
• Advanced patterns using functional programming concepts
• Practical Python code examples 🐍
• Quizzes, exercises and Mermaid diagrams
• Reference implementations for each pattern
• Lifetime access and A Certificate of Completion 🎓

Regular price: $179. But, if you order Pythonic Patterns along with The Software Designer Mindset today, it's just $99. Simply select the extension at checkout to get the discount.