updates

Author: Sean-Bradley

README.md

@@ -73,15 +73,19 @@ So, in this book, you will learn about these 23 Design Patterns,
 
 ## Pattern Types
 
-In the list of patterns above, there are Creational, Structural and Behavioral patterns.
+*...Refer to Book or Videos for extra content.*
+
+<!-- In the list of patterns above, there are Creational, Structural and Behavioral patterns.
 
 * **Creational** : Abstracts the instantiation process so that there is a logical separation between how objects are composed and finally represented.
 * **Structural** : Structural patterns focus more on how classed and objects are composed using the different structural techniques, and to form structures with more or altered flexibility.
-* **Behavioral** : Are concerned with the inner algorithms, process flow, the assignment of responsibilities and the intercommunication between objects. 
+* **Behavioral** : Are concerned with the inner algorithms, process flow, the assignment of responsibilities and the intercommunication between objects.  -->
 
 ## Class Scope and Object Scope Patterns
 
-Each pattern can be further specified whether it relates more specifically classes or instantiated objects.
+*...Refer to Book or Videos for extra content.*
+
+<!-- Each pattern can be further specified whether it relates more specifically classes or instantiated objects.
 
 Class scope patterns deal more with relationships between classes and their subclasses.
 
@@ -93,4 +97,4 @@ Object scope patterns deal more with relationships that can be altered at runtim
 | Builder, Prototype, Singleton                                                   | Defers object creation to objects          | Object | Creational  |
 | Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy                                   | Describes a way to assemble objects        | Object | Structural  |
 | Interpreter, Template                                                                             | Describes algorithms and flow control      | Class  | Behavioral |
-| Chain of Responsibility, Command, Iterator, Mediator, Memento, Observer, State, Strategy, Visitor | Describes how groups of objects co-operate | Object | Behavioral |
+| Chain of Responsibility, Command, Iterator, Mediator, Memento, Observer, State, Strategy, Visitor | Describes how groups of objects co-operate | Object | Behavioral | -->

adapter/README.md

@@ -48,11 +48,13 @@ The Adapter is used when you have an existing interface that doesn't directly ma
 
 ## Source Code
 
-In this concept source code, there are two classes, `ClassA` and `ClassB`, with different method signatures. Let's consider that `ClassA` provides the most compatible and preferred interface for the client.
+*...Refer to Book or Videos for extra content.*
+
+<!-- In this concept source code, there are two classes, `ClassA` and `ClassB`, with different method signatures. Let's consider that `ClassA` provides the most compatible and preferred interface for the client.
 
 I can create objects of both classes in the client and it works. But before using each objects method, I need to do a conditional check to see which type of class it is that I am calling since the method signatures are different.
 
-It means that the client is doing extra work. Instead, I can create an Adapter interface for the incompatible `ClassB`, that reduces the need for the extra conditional logic.
+It means that the client is doing extra work. Instead, I can create an Adapter interface for the incompatible `ClassB`, that reduces the need for the extra conditional logic. -->
 
 ## Output
 
@@ -66,14 +68,16 @@ method B
 
 ## Example Use Case
 
-The example client can manufacture a **Cube** using different tools. Each solution is invented by a different company.
+*...Refer to Book or Videos for extra content.*
+
+<!-- The example client can manufacture a **Cube** using different tools. Each solution is invented by a different company.
 The client user interface manages the Cube product by indicating the **width**, **height** and **depth**. This is compatible with the company A that produces the Cube tool, but not the company B that produces their own version of the Cube tool that uses a different interface with different parameters. 
 
 In this example, the client will re-use the interface for company A's Cube and create a compatible Cube from company B. 
 
 An adapter will be needed so that the same method signature can be used by the client without the need to ask company B to modify their Cube tool for our specific domains use case.
 
-My imaginary company needs to use both cube suppliers since there is a large demand for cubes and when one supplier is busy, I can then ask the other supplier.
+My imaginary company needs to use both cube suppliers since there is a large demand for cubes and when one supplier is busy, I can then ask the other supplier. -->
 
 ## Example UML Diagram
 

bridge/README.md

@@ -65,11 +65,13 @@ The implementer part of a Bridge, can have one or more possible implementations
 
 ## Source Code
 
-In the concept demonstration code, imagine that the classes were tightly coupled. The concrete class would print out some text to the console.
+*...Refer to Book or Videos for extra content.*
+
+<!-- In the concept demonstration code, imagine that the classes were tightly coupled. The concrete class would print out some text to the console.
 
 After abstracting the class along a common ground, it is now more versatile. The implementation and has been separated from the abstraction and now it can print out the same text in two different ways.
 
-The befit now is that each refined abstraction and implementer can now be worked on independently without affecting the other implementations.
+The befit now is that each refined abstraction and implementer can now be worked on independently without affecting the other implementations. -->
 
 ## Output
 
@@ -83,15 +85,17 @@ c
 
 ## Example Use Case
 
-In this example, I draw a square and a circle. Both of these can be categorized as shapes.
+*...Refer to Book or Videos for extra content.*
+
+<!-- In this example, I draw a square and a circle. Both of these can be categorized as shapes.
 
 The shape is set up as the abstraction interface. The refined abstractions, `Square` and `Circle` , implement the `IShape` interface.
 
 When the Square and Circle objects are created, they are also assigned their appropriate implementers being `SquareImplementer` and `CircleImplementer` .
 
 When each shape's `draw` method is called, the equivalent method within their implementer is called.
 
-The Square and Circle are bridged and each implementer and abstraction can be worked on independently.
+The Square and Circle are bridged and each implementer and abstraction can be worked on independently. -->
 
 ## Example UML Diagram
 

composite/README.md

@@ -40,15 +40,17 @@ Examples of using the Composite Design Pattern can be seen in a file
 
 ## Source Code
 
-In this concept code, two leaves are created, `LEAF_A` and `LEAF_B`, and two composites are created, `COMPOSITE_1` and `COMPOSITE_2` .
+*...Refer to Book or Videos for extra content.*
+
+<!-- In this concept code, two leaves are created, `LEAF_A` and `LEAF_B`, and two composites are created, `COMPOSITE_1` and `COMPOSITE_2` .
 
 `LEAF_A` is attached to `COMPOSITE_1` .
 
 Then I change my mind and attach `LEAF_A` to `COMPOSITE_2` .
 
 I then attach `COMPOSITE_1` to `COMPOSITE_2` .
 
-`LEAF_B` is not attached to composites.
+`LEAF_B` is not attached to composites. -->
 
 ## Output
 
@@ -68,13 +70,15 @@ COMPOSITE_2     id:2050574298128
 
 ## Composite Example Use Case
 
-Demonstration of a simple in memory hierarchal file system.
+*...Refer to Book or Videos for extra content.*
+
+<!-- Demonstration of a simple in memory hierarchal file system.
 
 A root object is created that is a composite.
 
 Several files (leaves) are created and added to the root folder.
 
-More folders (composites) are created, and more files are added, and then the hierarchy is reordered.
+More folders (composites) are created, and more files are added, and then the hierarchy is reordered. -->
 
 ## Composite Example UML Diagram
 

decorator/README.md

@@ -49,13 +49,15 @@ Decorator Method(Component Method)
 
 ## Example Use Case
 
-Let's create a custom class called `Value` that will hold a number. 
+*...Refer to Book or Videos for extra content.*
+
+<!-- Let's create a custom class called `Value` that will hold a number. 
 
 Then add decorators that allow addition (`Add`) and subtraction (`Sub`) to a number (`Value`).
 
 The `Add` and `Sub` decorators can accept integers directly, a custom `Value` object or other `Add` and `Sub` decorators.
 
-`Add`, `Sub` and `Value` all implement the `IValue` interface and can be used recursively.
+`Add`, `Sub` and `Value` all implement the `IValue` interface and can be used recursively. -->
 
 ## Example UML Diagram
 

facade/README.md

@@ -41,9 +41,11 @@ B
 
 ## Example Use Case
 
-This is an example of a game engine API. The facade layer is creating one streamlined interface consisting of several methods from several larger API backend systems. 
+*...Refer to Book or Videos for extra content.*
 
-The client could connect directly to each subsystems API and implement its authentication protocols, specific methods, etc. While it is possible, it would be quite a lot of consideration for each of the development teams, so the facade API unifies the common methods which becomes much less overwhelming for each new the client developer to integrate into.
+<!-- This is an example of a game engine API. The facade layer is creating one streamlined interface consisting of several methods from several larger API backend systems. 
+
+The client could connect directly to each subsystems API and implement its authentication protocols, specific methods, etc. While it is possible, it would be quite a lot of consideration for each of the development teams, so the facade API unifies the common methods which becomes much less overwhelming for each new the client developer to integrate into. -->
 
 ## Example UML Diagram
 

flyweight/README.md

@@ -50,11 +50,13 @@ When describing flyweights, it is useful to describe it in terms of intrinsic an
 
 ## Source Code
 
-A context is created using the string `abracadabra`.
+*...Refer to Book or Videos for extra content.*
+
+<!-- A context is created using the string `abracadabra`.
 
 As it is output, it asks the Flyweight factory for the next character. The Flyweight factory will either return an existing Flyweight, or create a new one before returning it.
 
-`abracadabra` has many re-used characters, so only 5 flyweights needed to be created.
+`abracadabra` has many re-used characters, so only 5 flyweights needed to be created. -->
 
 ## Output
 
@@ -67,11 +69,13 @@ FlyweightFactory has 5 flyweights
 
 ## Example Use Case
 
-In this example, I create a dynamic table with 3 rows and 3 columns each. The columns are then filled with some kind of text, and also chosen to be left, right or center aligned. 
+*...Refer to Book or Videos for extra content.*
+
+<!-- In this example, I create a dynamic table with 3 rows and 3 columns each. The columns are then filled with some kind of text, and also chosen to be left, right or center aligned. 
 
 The letters are the flyweights and only a code indicating the letter is stored. The letters and numbers are shared many times.
 
-The columns are the contexts and they pass the extrinsic vales describing the combination of letters, the justification left, right or center, and the width of the table column that is then used for the space padding.
+The columns are the contexts and they pass the extrinsic vales describing the combination of letters, the justification left, right or center, and the width of the table column that is then used for the space padding. -->
 
 ## Example UML Diagram
 

interpreter/README.md

@@ -57,7 +57,9 @@ Once the AST is created, you can then choose the root node and then run the Inte
 
 ## Source Code
 
-In this example, I interpret the string `5 + 4 - 3 + 7 - 2` and then calculate the result.
+*...Refer to Book or Videos for extra content.*
+
+<!-- In this example, I interpret the string `5 + 4 - 3 + 7 - 2` and then calculate the result.
 
 The grammar of the string follows a pattern of Number -> Operator -> Number -> etc.
 
@@ -70,7 +72,7 @@ I then construct the AST manually, by adding a
 3. Non-Terminal `Add` row containing the previous Non-Terminal row and the `7`
 4. Non-Terminal `Subtract` row containing the previous Non-Terminal row and the `2`
 
-The AST root becomes the final row that was added, and then I can run the `interpret()` method on that, which will interpret the full AST recursively because each AST row references the row above it.
+The AST root becomes the final row that was added, and then I can run the `interpret()` method on that, which will interpret the full AST recursively because each AST row references the row above it. -->
 
 ## Output
 
@@ -84,9 +86,11 @@ python ./interpreter/interpreter_concept.py
 
 ## Example Use Case
 
-The example use case will expand on the concept example by dynamically creating the AST and converting roman numerals to integers as well as calculating the final result.
+*...Refer to Book or Videos for extra content.*
+
+<!-- The example use case will expand on the concept example by dynamically creating the AST and converting roman numerals to integers as well as calculating the final result.
 
-The Image below, is an AST for the expression `5 + IV - 3 + VII - 2`
+The Image below, is an AST for the expression `5 + IV - 3 + VII - 2` -->
 
 ![Abstract Syntax Tree Example](/img/interpreter_ast_roman_numeral.svg)
 

iterator/README.md

@@ -36,13 +36,15 @@ The benefits of using the Iterator pattern are that the client can traverse a co
 
 ## Source Code
 
-In this concept example, I create 4 objects called Aggregate and group them into a collection.
+*...Refer to Book or Videos for extra content.*
+
+<!-- In this concept example, I create 4 objects called Aggregate and group them into a collection.
 
 They are very minimal objects that implement one method that prints a line.
 
 I then create an Iterable and pass in the collection of Aggregates.
 
-I can now traverse the aggregates through the Iterable interface.
+I can now traverse the aggregates through the Iterable interface. -->
 
 ## Output
 
@@ -56,13 +58,15 @@ This method has been invoked
 
 ## Example Use Case
 
-One reason for not using the inbuilt Python data structures that implement iterators already, or using the [iter](#python-iter) function directly over an existing collection, is in the case when you want to create an object that can dynamically create iterated objects, you want a custom order of objects or an infinite iterator.
+*...Refer to Book or Videos for extra content.*
+
+<!-- One reason for not using the inbuilt Python data structures that implement iterators already, or using the [iter](#python-iter) function directly over an existing collection, is in the case when you want to create an object that can dynamically create iterated objects, you want a custom order of objects or an infinite iterator.
 
 The iterator in this brief example will return the next number in the iterator multiplied by 2 modulus 11. It dynamically creates the returned object (number) at runtime.
 
 It has no `has_next()` method since the result is modulated by 11, that will loop the results no matter how large the iterator index is. It will also appear to alternate between a series of even numbers and odd numbers.
 
-Also, just to demonstrate that implementing abstract classes and interfaces is not always necessary, this example uses no abstract base classes or interfaces.
+Also, just to demonstrate that implementing abstract classes and interfaces is not always necessary, this example uses no abstract base classes or interfaces. -->
 
 ## Example UML Diagram
 

mediator/README.md

@@ -34,11 +34,13 @@ While the Facade is a structural pattern, and the Mediator also implies structur
 
 ## Source Code
 
-In the example concept, there are two colleague classes that use each other's methods. Instead of the Colleagues calling each other's methods directly, they implement the Mediator interface and call each other via the Mediator. Each colleague is designed for a different purpose, but they utilize some related functionality from each other. 
+*...Refer to Book or Videos for extra content.*
+
+<!-- In the example concept, there are two colleague classes that use each other's methods. Instead of the Colleagues calling each other's methods directly, they implement the Mediator interface and call each other via the Mediator. Each colleague is designed for a different purpose, but they utilize some related functionality from each other. 
 
 The system, in this case, would work without the Mediator, but adding the Mediator would allow extending functionality to a potential third colleague that provides a different service, such as AI analysis or monitoring, without needing to add specific support or knowledge into the two original colleagues.
 
-In this first example the Mediator is structurally acting as a multi directional relay between the two colleagues.
+In this first example the Mediator is structurally acting as a multi directional relay between the two colleagues. -->
 
 ## Output
 
@@ -50,13 +52,15 @@ COLLEAGUE2 <--> Here is the Colleague1 specific data you asked for
 
 ## Example Use Case
 
-In this example use case, we will implement some behavior into the mediation process.
+*...Refer to Book or Videos for extra content.*
+
+<!-- In this example use case, we will implement some behavior into the mediation process.
 
 Before the mediation logic is added, consider that the below example is a series of components all subscribed to a central location being the subject. They all implement the [Observer](/observer) pattern.
 
 Each component is updated independently by external forces, but when it has new information, it notifies the subject which in turn then notifies the other subscribed components.
 
-During the synchronization of all the subscribed components, without the extra mediation, the component that provided the new information will receive back the same message that it just notified the subject of. In order to manage the unnecessary duplicate message, the notifications will be mediated to exclude to component where the original message originated from.
+During the synchronization of all the subscribed components, without the extra mediation, the component that provided the new information will receive back the same message that it just notified the subject of. In order to manage the unnecessary duplicate message, the notifications will be mediated to exclude to component where the original message originated from. -->
 
 ## Example UML Diagram