Mastering Design Patterns and Software Design - Swift, iOS

Explore the prototype design pattern, creating objects by cloning an existing prototype into a clone, understanding benefits like avoiding expensive initialization, and managing shallow versus deep copies in Swift.

Explore how shallow copying copies references in a prototype design pattern, contrasted with deep copying that duplicates content using a meeting and its location example.

Demonstrates deep copying within the prototype pattern by copying the actual content of referenced objects, so cloned meetings obtain separate location instances and independent state.

Define singleton as a single shared class instance across the app to share data and functionality, saving memory; with real-world examples like printers, and note only classes support singletons.

Implement a Swift singleton to share a color picker's data and random color function via a static shared instance, ensuring global access and consistent updates across classes.

Explore how final and @objc influence Swift performance by enabling static binding and Objective-C runtime exposure, and compare static, dynamic, and runtime dispatch to optimize method dispatch.

Explore core system design concepts, dependency graphs, and object oriented system dependencies, and learn how partial and direct dependencies affect maintainability, flexibility, and extensibility.

Manage dependencies in object oriented design with firewalls and abstraction, using protocols or interfaces to achieve loose coupling, flexibility, and easier maintainability and extendibility.

Emphasize dependency on abstractions rather than concrete implementations to keep code loosely coupled. Use inheritance or protocols to achieve abstraction and localize changes, increasing flexibility and maintainability.

Learn how the factory design pattern hides object creation behind a specification, delivering instances via abstraction to reduce coupling and boost flexibility, with a nod to the abstract factory variant.

Apply the factory design pattern by building a mobile interface and a mobile factory, enabling decoupled, switchable Apple or Samsung implementations.

Explain how abstract factory hides creation and selection by returning a collection of related objects through a factory of factories, all operating on a uniform interface.

Explore how to build computers with basic, standard, and advanced CPU, GPU, and display components using the abstract factory pattern, enabling flexible, extensible object creation.

Master the builder design pattern by separating object configuration from creation, using initialization data to build the object and return it to the caller.

Master the builder pattern by constructing a burger object with properties like name, toppings, ketchup, and cheese, separating configuration from creation and using default values when options are omitted.

Explore the object pool pattern by modeling a three-book library serving ten students, showing how get and return operations reuse resources, avoid expensive initialization, and boost flexibility.

Hide the creation logic from calling components to isolate changes. Use prototype and singleton patterns to avoid expensive initialization and reuse objects, reducing memory footprint and increasing flexibility.

Explore the adapter design pattern, a structural design pattern that converts one interface to another so two incompatible interfaces work together without changing existing code, with examples in Swift programming.

Explore the adapter pattern by converting a basic mobile interface into a smart mobile, enabling calling, disconnecting, and handling photo and video capture through a smart adapter.