Sometimes you just want to switch off your computer and read from a book. So, I’ve revisited and rewritten all of the 23 GoF design patterns and compiled them into a book titled Design Patterns In Python. ASIN B08XLJ8Z2J

Common GOF (Gang of Four) Design Patterns implemented in Python

US : https://www.amazon.com/dp/B08XLJ8Z2J
UK : https://www.amazon.co.uk/dp/B08XLJ8Z2J
DE : https://www.amazon.de/dp/B08XLJ8Z2J
FR : https://www.amazon.fr/dp/B08XLJ8Z2J
ES : https://www.amazon.es/dp/B08XLJ8Z2J
IT : https://www.amazon.it/dp/B08XLJ8Z2J
JP : https://www.amazon.co.jp/dp/B08XLJ8Z2J
CA : https://www.amazon.ca/dp/B08XLJ8Z2J

Design patterns will give you a useful and common vocabulary for when designing, documenting, analysing restructuring new and existing software development projects now and into the future.

Sean


Sometimes you need an object in an application where there is only one instance.

You don’t want there to be many versions, for example, you have a game with a score and you want to adjust it. You may have accidentally created several instances of the class holding the score object. Or, you may be opening a database connection, there is no need to create many, when you can use the existing one that is already in memory. You may want a logging component, and you want to ensure all classes use the same instance. …


Fly in the term Flyweight means light/not heavy.

Instead of creating thousands of objects that share common attributes, and result in a situation where a large amount of memory or other resources are used, you can modify your classes to share multiple instances simultaneously by using some kind of reference to the shared object instead.

The best example to describe this is a document containing many words and sentences and made up of many letters. Rather than storing a new object for each individual letter describing its font, position, colour, padding and many other potential things. You can store just…


Throughout the lifecycle of an application, an objects state may change. You might want to store a copy of the current state in case of later retrieval. E.g., when writing a document, you may want to auto save the current state every 10 minutes. Or you have a game, and you want to save the current position of your player in the level, with its score and current inventory.

You can use the Memento pattern for saving a copy of state and for later retrieval if necessary.

The Memento pattern, like the Command pattern, is also commonly used for implementing…


Not to be confused with object state, i.e., one of more attributes that can be copied as a snapshot, the State Pattern is more concerned about changing the handle of an object’s method dynamically. This makes an object itself more dynamic and may reduce the need of many conditional statements.

Instead of storing a value in an attribute, and then then using conditional statements within an objects method to produce different output, a subclass is assigned as a handle instead. The object/context doesn’t need to know about the inner working of the assigned subclass that the task was delegated to.


The Strategy Pattern is similar to the State Pattern, except that the client passes in the algorithm that the context should run and the execution of the algorithm does not affect the state of the context.

The algorithm should be contained within a class that implements the particular strategies interface.

An application that sorts data is a good example of where you can incorporate the Strategy pattern.

There are many methods of sorting a set of data. E.g., Quicksort, Mergesort, Introsort, Heapsort, Bubblesort. See https://en.wikipedia.org/wiki/Sorting_algorithm for more examples.

The user interface of the client application can provide a drop-down menu…


In the Template Method pattern, you create an abstract class (template) that contains a Template Method that is a series of instructions that are a combination of abstract and hook methods.

Abstract methods need to be overridden in the subclasses that extend the abstract (template) class.

Hook methods normally have empty bodies in the abstract class. Subclasses can optionally override the hook methods to create custom implementations.

So, what you have, is an abstract class, with several types of methods, being the main template method, and a combination of abstract and/or hooks, that can be extended by different subclasses that…


Your object structure inside an application may be complicated and varied. A good example is what could be created using the composite structure.

The objects that make up the hierarchy of objects, can be anything and most likely complicated to modify as your application grows.

Instead, when designing the objects in your application that may be structured in a hierarchical fashion, you can allow them to implement a Visitor interface.

The Visitor interface describes an accept() method that a different object, called a Visitor, will use in order to traverse through the existing object hierarchy and read the internal attributes…


The Interpreter pattern helps to convert information from one language into another.

The language can be anything such as words in a sentence, numerical formulas or even software code.

The process is to convert the source information, into an Abstract Syntax Tree (AST) of Terminal and Non-Terminal expressions that all implement an interpret() method.

A Non-Terminal expression is a combination of other Non-Terminal and/or Terminal expressions.

Terminal means terminated, i.e., there is no further processing involved.

An AST root starts with a Non-Terminal expression and then resolves down each branch until all expressions terminate.

An example expression is A +…


Photo by Lacie Slezak on Unsplash

What does that even mean?

It is the difference between using Module Specifiers Versus Relative Import References in your client side JavaScript ES6 imports.

The error typically happens when using Module Specifiers in your client side import statements. The browser does not understand Module Specifiers by default.

The error you see in the console describes “relative references”. It is expecting a URL.

In this article, I outline the differences of using Relative Import References versus Module Specifiers.

I will use Threejs ES6 module references in the example code.

eg, using Module Specifiers

import * as THREE from 'three'
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls'

Versus…

Sean Bradley

Developer of real time, low latency, high availability, asynchronous, multi threaded, remotely managed, fully automated and monitored solutions.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store