Python: SOLID Principles and Top Design Patterns

In this first part we will briefly go over how we will leverage Python's Object Oriented Capabilities.

We will cover classes, and interface contracts (i.e. abstract classes) as well as how this will relate to the UML diagrams you will see in this course.

NOTE: A PDF Version of this lecture is provided here in case you would like to take hard-copy notes of the lecture content.

In this second part we will continue to go over how we will leverage Python's Object Oriented Capabilities.

We will cover classes, and interface contracts (i.e. abstract classes) as well as how this will relate to the UML diagrams you will see in this course.

NOTE: A PDF Version of this lecture is provided here in case you would like to take hard-copy notes of the lecture content.

In this example we will look at syntax for simple python class.

NOTE: The Source code for all the Code Studies has been attached here.

Each study is named "python_oop_NNN.py" where NNN is the number of the study.
For example "python_oop_001.py" would be the source code for Code Studies Part #1

In this example we will look at class and object aggregation example. This is how you build complex classes by using simple class building blocks.

Introduction to Abstract Classes in Python.

Looking at an example of encapsulation and private as well as protected class variables.

Interface contracts in Python. First look.

More complex Interface contracts in Python. This shows you how you can enforce API utilization of a specific interface through method signatures.

Tying everything together into a more complex Abstract Class example that has both interface contract behaviour as well as re-use logic.

How can you tell what a good Architecture is? What are the main features of a great Architecture? In this lesson we will explore the hallmarks of a great architecture are and how to spot them.

This is a very important topic. The S.O.L.I.D design principles form  the backbone of what a great architecture should have at its base approach. In this lecture we explore these principles in preparation for when we go over the design patterns of this course.

This is a quick hands-on practice session where you will get a chance to exercise your SOLID knowledge by refactoring a bad solution into a good solution as per SOLID principles.

In this session we go over Single Responsibility Principle(SRP)

This is a quick hands-on practice sessions where you will get a chance to exercise your SOLID knowledge by refactoring a bad solution into a good solution as per SOLID principles.

In this session we go over Open/Closed Principle(OCP)

This is a quick hands-on practice sessions where you will get a chance to exercise your SOLID knowledge by refactoring a bad solution into a good solution as per SOLID principles.

In this session we go over Liskov Substitution Principle (LSP)

This is a quick hands-on practice sessions where you will get a chance to exercise your SOLID knowledge by refactoring a bad solution into a good solution as per SOLID principles.

In this session we go over interface Separation Principle (ISP)

This is a quick hands-on practice sessions where you will get a chance to exercise your SOLID knowledge by refactoring a bad solution into a good solution as per SOLID principles.

In this session we go over Dependency Inversion Principle (DIP)

NOTE: Once you are done with this lecture we have provided you with a PDF of SOLID exercises for you to try on your own. The PDF is attached with this lecture.

We introduce the Singleton Design Pattern and discuss its importance and relevance in Software Engineering. In this lesson you will learn what it is and why we need it.
It is a creational design pattern that helps us with ensuring that we have at most a single copy of a given class instance in the whole project scope. You will find out why that is relevant.

In this first part, we further explore the Singleton Pattern and look into the architectural nature of this software recipe through the UML lens.
We explore the simplest implementations and some Python language quirks that come along when you try to implement such a design pattern

In this second part, we will look into the best way to achieve a Singleton in Python: using a metaclass. We also look into the idea behind implementing eager loading in our singletons vs the more usual lazy instantiation we have seen so far.

In this, third Architecture lecture, we will look at the underlying issues with thread-safety and the Singleton Design pattern. We will then look at the implementation of a working solution.

Let's code something using the Singleton Pattern.

In this lesson we will explore how to code this pattern in Python using a few different language constructs that also can help us to ensure thread-safety. We also look at how to create a Singleton Logger wrapper in Python for a practical example of this software recipe.

NOTE: Attached you will find the zipped source code for this lecture.

Let's code something practical using the Singleton Pattern.

In this lecture we will look at 4 different iterations of a custom Logger class which we will explore as a Singleton.

We will start with a simple example, and then go through different phases of making our Logger a thread-safe Singleton that is customizable and flexible through an abstract class concept.

NOTE: attached you will find the zipped source code for this lecture.

This is an optional exercise for the student to do. It is important to practice and try things out.

This will cover two scenarios to use a Singleton Pattern in.

This lecture will take you through the solutions for the extra exercises presented in previous lecture (#30)
I discuss the solutions and the code with some extra discussion about thread-safety.

NOTE: The heavily commented source code for the solutions in attached with this lecture.

We introduce the Factory Method Design Pattern and discuss its importance and relevance in Software Engineering.
In this lesson you will learn what it is and why we need it. It is a creational design pattern that makes the process of object creation more maintainable.

We further explore the Factory Method Pattern and look into the architectural nature of this software recipe through the UML lens.

Let's code something using the Factory Method Pattern. In this lesson we will explore how to code this pattern in Python. We have a fun little application which draws random shapes on the screen by utilizing the Factory Method Pattern and a custom Python Painter.

NOTE: attached you will find the zipped source code for this lecture.

This is an optional exercise for the student to do. It is important to practice and try things out. This will cover two scenarios to use a Factory Method Design Pattern in.

We introduce the Builder Design Pattern and discuss its importance and relevance in Software Engineering. In this lesson you will learn what it is and why we need it. It is a creational design pattern that makes the process of complex object creation more maintainable and decoupled from the client.

We further explore the Builder Pattern and look into the architectural nature of this software recipe through the UML lens.

Let's code something using the Builder Pattern. It's time for some some sandwiches! In this lesson we will explore how to code this pattern in Python. We are going to create a Builder abstraction that will be responsible for creating different types of Sandwiches.

NOTE: attached you will find the zipped source code for this lecture.

This is an optional exercise for the student to do. It is important to practice and try things out. This will cover two scenarios to use a Builder Design Pattern in.

We introduce the Adapter Design Pattern and discuss its importance and relevance in Software Engineering. In this lesson you will learn what it is and why we need it. It is a structural design pattern that allows two different processes to talk to each other even though their view of data is not compatible.

We further explore the Adapter Pattern and look into the architectural nature of this software recipe through the UML lens.

Let's code something using the Adapter Pattern. In this lesson we will explore how to code this pattern in Python. We are going to create an Adapter for some XML and JSON data conversion!

As part of your Adapter pattern Exercise you will add a CSV Adapter to the featured code.

NOTE: attached you will find the zipped source code for this lecture.

This is an optional exercise for the student to do. It is important to practice and try things out. This will cover two scenarios to use a Adapter Design Pattern in.

In this section will will introduce this incredibly simple yet powerful design pattern. This is probably the most popular and useful of all the design patterns in the whole of GoF collection.

We further explore the Strategy Pattern and look into the architectural nature of this software recipe through the UML lens.

Let's code something using the Strategy Pattern. In this lesson we will explore how to code this pattern in Python. We are going to look at how to create different handlers for rendering objects to the screen.

NOTE: The source code for this lecture is attached with this video.

This is an optional exercise for the student to do. It is important to practice and try things out. This will cover two scenarios to use a Strategy Design Pattern in.

It is recommended that you perhaps draw a UML sketch of the code (provided below) so that you can visually refactor it first.

NOTE:
The code for Exercise #1 is attached below: shipping.py
The code for Exercise #2 is attached below in text_processing.py

In this section we will explore the Observer Design Pattern with its very important role in inter-object communications.
Such aspects as notifications about specific events,  and in general signalling about action workflows is what this pattern excels at.

Here we will look at more detail about the Architectural make up of this pattern. We will look at UML as well as general workflow of what makes this pattern great. 

In this lecture we will look at some fun code to showcase how the Observer pattern is useful in a object communication workflow.

NOTE: The source code for this lecture is attached with this video.

This is an optional exercise for the student to do. It is important to practice and try things out.

This will cover two exercises for you to practice the Observer Design Pattern with.

It is recommended that you perhaps draw a UML sketch of the class hierarchies so that you can easily visualize the Observer Design Pattern.

We will go over the concept of what a State and a State Machine is. We will understand how to break down states and associated data into a set of discrete steps that make up a State Machine.

We further explore the State Pattern and look into the architectural nature of this software recipe through the UML lens and get a better understanding of h ow to design a State Machine.

Let's code something using the State Design Pattern. In this lesson we will explore how to code this pattern in Python. We are going to look at how to create controller process for good old traffic lights. We will design and code the state machine for a traffic light.

NOTE: The source code for this lecture is attached with this video.

This is an optional exercise for the student to do. It is important to practice and try things out. This will cover two scenarios to use the State Design Pattern in.

NOTE:
The code for Exercise #1 is attached below: state_design_pattern_exercise_001.py
The code for Exercise #2 is attached below in state_design_pattern_exercise_002.py