Design Patterns in Swift

Discover the modern implementation of design patterns with Swift
Design Patterns in Swift
File Size :
2.16 GB
Total length :
8h 39m



Dmitri Nesteruk


Last update

Last updated 7/2019



Design Patterns in Swift

What you’ll learn

Recognize and apply design patterns
Refactor existing designs to use design patterns
Reason about applicability and usability of design patterns
Implement each pattern in a coding exercise

Design Patterns in Swift


Good understanding of Swift
Familiarity with latest Swift features
Good understanding of object-oriented design principles


Course Overview
This course provides a comprehensive overview of Design Patterns in Swift from a practical perspective. This course in particular covers patterns with the use of:
The latest versions of the Swift programming languageUse of modern programming approaches: dependency injection, reactive programming and moreUse of modern developer toolsDiscussions of pattern variations and alternative approaches
This course provides an overview of all the Gang of Four (GoF) design patterns as outlined in their seminal book, together with modern-day variations, adjustments, discussions of intrinsic use of patterns in the language.
What are Design Patterns?
Design Patterns are reusable solutions to common programming problems. They were popularized with the 1994 book Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, John Vlissides, Ralph Johnson and Richard Helm (who are commonly known as a Gang of Four, hence the GoF acronym).
The original book was written using C++ and Smalltalk as examples, but since then, design patterns have been adapted to every programming language imaginable: Swift, C#, Java, PHP and even programming languages that aren’t strictly object-oriented, such as JavaScript.
The appeal of design patterns is immortal: we see them in libraries, some of them are intrinsic in programming languages, and you probably use them on a daily basis even if you don’t realize they are there.
What Patterns Does This Course Cover?
This course covers all the GoF design patterns. In fact, here’s the full list of what is covered:
SOLID Design Principles: Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle and Dependency Inversion PrincipleCreational Design Patterns: Builder, Factories (Factory Method and Abstract Factory), Prototype and SingletonStructrural Design Patterns: Adapter, Bridge, Composite, Decorator, Façade, Flyweight and ProxyBehavioral Design Patterns: Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Null Object, Observer, State, Strategy, Template Method and Visitor
Who Is the Course For?
This course is for Swift developers who want to see not just textbook examples of design patterns, but also the different variations and tricks that can be applied to implement design patterns in a modern way.
Presentation Style
This course is presented as a (very large) series of live demonstrations. All demos are single-file, so you can download the file attached to the lesson and run it in CLion, XCode or another IDE of your choice (or just on the command line).

This course does not use UML class diagrams; all of demos are live coding. I use Visual Studio Code for the demos.


Lecture 1 Introduction

Section 1: SOLID Design Principles

Lecture 2 Overview

Lecture 3 Single Responsibility Principle

Lecture 4 Open-Closed Principle

Lecture 5 Liskov Substitution Principle

Lecture 6 Interface Segregation Principle

Lecture 7 Dependency Inversion Principle

Lecture 8 Summary

Section 2: Builder

Lecture 9 Overview

Lecture 10 Life Without Builder

Lecture 11 Builder

Lecture 12 Fluent Builder

Lecture 13 Faceted Builder

Lecture 14 Summary

Section 3: Factories

Lecture 15 Overview

Lecture 16 Point Example

Lecture 17 Factory Method

Lecture 18 Factory

Lecture 19 Inner Factory

Lecture 20 Abstract Factory

Lecture 21 Summary

Section 4: Prototype

Lecture 22 Overview

Lecture 23 Copy Constructors

Lecture 24 Explicit Deep Copy Interface

Lecture 25 Summary

Section 5: Singleton

Lecture 26 Overview

Lecture 27 Singleton Implementation

Lecture 28 Testability Issues

Lecture 29 Singleton in Dependency Injection

Lecture 30 Monostate

Lecture 31 Summary

Section 6: Adapter

Lecture 32 Overview

Lecture 33 Vector/Raster Demo

Lecture 34 Adapter Caching

Lecture 35 Summary

Section 7: Bridge

Lecture 36 Overview

Lecture 37 Bridge

Lecture 38 Summary

Section 8: Composite

Lecture 39 Overview

Lecture 40 Geometric Shapes

Lecture 41 Neural Networks

Lecture 42 Summary

Section 9: Decorator

Lecture 43 Overview

Lecture 44 Custom String Builder

Lecture 45 Multiple Inheritance

Lecture 46 Dynamic Decorator Composition

Lecture 47 Static Decorator Composition

Lecture 48 Summary

Section 10: Façade

Lecture 49 Overview

Lecture 50 Façade

Lecture 51 Summary

Section 11: Flyweight

Lecture 52 Overview

Lecture 53 Repeating User Names

Lecture 54 Text Formatting

Lecture 55 Summary

Section 12: Proxy

Lecture 56 Overview

Lecture 57 Protection Proxy

Lecture 58 Property Proxy

Lecture 59 Proxy vs. Decorator

Lecture 60 Summary

Section 13: Chain of Responsibility

Lecture 61 Overview

Lecture 62 Command Query Separation

Lecture 63 Method Chain

Lecture 64 Broker Chain

Lecture 65 Summary

Section 14: Command

Lecture 66 Overview

Lecture 67 Command

Lecture 68 Undo Operations

Lecture 69 Summary

Section 15: Interpreter

Lecture 70 Overview

Lecture 71 Handmade Interpreter: Lexing

Lecture 72 Handmade Interpreter: Parsing

Lecture 73 Summary

Section 16: Iterator

Lecture 74 Overview

Lecture 75 Iterator Object

Lecture 76 Array-Backed Properties

Lecture 77 Summary

Section 17: Mediator

Lecture 78 Overview

Lecture 79 Chat Room

Lecture 80 Summary

Section 18: Memento

Lecture 81 Overview

Lecture 82 Memento

Lecture 83 Undo and Redo

Lecture 84 Summary

Section 19: Null Object

Lecture 85 Overview

Lecture 86 Null Object

Lecture 87 Summary

Section 20: Observer

Lecture 88 Overview

Lecture 89 Events

Lecture 90 Property Observers

Lecture 91 Handling Dependent Observable Properties

Lecture 92 Summary

Section 21: State

Lecture 93 Overview

Lecture 94 Handmade State Machine

Lecture 95 Summary

Section 22: Strategy

Lecture 96 Overview

Lecture 97 Dynamic Strategy

Lecture 98 Static Strategy

Lecture 99 Summary

Section 23: Template Method

Lecture 100 Overview

Lecture 101 Template Method

Lecture 102 Summary

Section 24: Visitor

Lecture 103 Overview

Lecture 104 Intrusive Expression Printing

Lecture 105 What is Dispatch?

Lecture 106 Reflection-Based Printing

Lecture 107 Classic Visitor (Double Dispatch)

Lecture 108 Summary

Section 25: Course Summary

Lecture 109 Creational Patterns Summary

Lecture 110 Structural Patterns Summary

Lecture 111 Behavioral Patterns Summary

Lecture 112 End of Course

Lecture 113 Bonus Lecture: Other Courses at a Discount

Beginner and experienced developers,Anyone interested in design patterns

Course Information:

Udemy | English | 8h 39m | 2.16 GB
Created by: Dmitri Nesteruk

You Can See More Courses in the Developer >> Greetings from

New Courses

Scroll to Top