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
Requirements
Good understanding of Swift
Familiarity with latest Swift features
Good understanding of object-oriented design principles
Description
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.
Overview
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 CourseDown.com