Autoplay
Autocomplete
Previous Lesson
Complete and Continue
iOS Lead Essentials
Start here
Welcome (4:10)
A Tested and Proven Methodology
The iOS Lead Essentials Structure
The Decisive Factors of Your Training
The iOS Lead Essentials High-Performance Mindset
Behavioral Profiles
Thriving Through Adversity
Building a Remarkable Reputation
Planning and Getting Things Done Effectively
Learning Faster
Instructions and Guidelines
Collect Your Bonuses
The Lead Developer Essentials
Mentoring Sessions
Planning, Initial System Design and Requirements Analysis
Are Singletons and Global Instances Damaging your System Design and Testability? (26:00)
Intro to Dependency Diagrams and Composition (17:52)
Intro to Modular Design (15:27)
BDD, TDD, Use Cases, Architecture and Modular Design (22:14)
Effectively Developing Swift Apps Before the Backend/Design Is Ready (10:50)
Networking Module
Automated Testing Setup Guide
From Singletons and Globals to Proper Dependency Injection (23:54)
Asserting a Captured Value Is Not Enough + Cross-Module Access Control (7:34)
Handling Errors + Stubbing vs. Spying + Eliminating Invalid Paths (21:58)
A Classicist TDD Approach (No Mocking) to Mapping JSON with Decodable + Domain-Specific Models (40:03)
Automating Memory Leak Detection + Preventing a (Way Too Common) Async Bug (16:14)
Conforming to Feature Abstractions While Maintaining System Modularity + Keeping Test Details Out of Production With Enum Pattern Matching and Async Expectations (13:26)
Four Approaches to Test(-Drive) Network Requests: End-to-End, Subclass & Protocol-Based Mocking, and URLProtocol Stubbing (31:44)
Speeding up Development by: Reducing Debugging Time, Minimizing Risk & Maximizing Learning, and Decoupling Tests From Implementation Details (41:17)
Randomizing & Parallelizing Tests, Code Coverage, Testing in Integration with the Backend, and Automating a Continuous Integration (CI) Pipeline (22:15)
Identifying, Debugging, and Solving Data Races with the Thread Sanitizer (10:19)
What Many Apps Get Wrong About Reachability and How To Get It Right
🥇 The Feed API Challenge
Recap
Overview
Key Stats and Insights to Maximize Your Development Output
Persistence Module
URLCache as a Persistence Alternative & Solving The Infamous “But it works on my machine!” Caching Problem (10:27)
Clarifying Requirements, Enhancing Cross-Team Domain Knowledge, and Iterative vs. Big Upfront Design (10:41)
Decoupling Use-Case Business Logic From Framework Details + Controlling Time + Multi-Method Abstractions Following The Interface Segregation and Single Responsibility Principles (30:59)
Proper Memory-Management of Captured References Within Deeply Nested Closures + Identifying Highly-Coupled Modules (11:43)
Visualizing and Solving High-Coupling Issues by Decentralizing Components Using Data Transfer Model Representations (20:13)
Performing Calendrical Calculations Correctly, Dealing With Coincidental Duplication While Respecting the DRY Principle, Decoupling Tests From Implementation With Tiny DSLs, and Test Triangulation to Increase Coverage & Confidence (28:22)
Test-driving Cache Invalidation + Identifying Complex (Bloated) Functionality With The Command–Query Separation Principle (8:40)
Separating Queries & Side-effects for Simplicity and Reusability, Choosing Between Enum Switching Strategies, and Differentiating App-Specific from App-Agnostic Logic (20:00)
Separating App-specific, App-agnostic & Framework logic, Entities vs. Value Objects, Establishing Single Sources of Truth, and Designing Side-effect-free (Deterministic) Domain Models with Functional Core, Imperative Shell Principles (20:32)
Dependency Inversion Anatomy (High-level | Boundary | Low-level), Defining Inbox Checklists and Contract Specs to Improve Collaboration and Avoid Side-effect Bugs in Multithreaded Environments (12:47)
Persisting/Retrieving Models with Codable+FileSystem, Test-driving in Integration with Real Frameworks Instead of Mocks & Measuring Test Times Overhead with `xcodebuild` (29:34)
Deleting Models and Handling Errors with Codable+FileSystem, Making Async Code Look Sync in Tests to Eliminate Arrow Anti-Pattern, and More Essential Test Guidelines to Improve Code Quality and Team Communication (18:34)
Designing and Testing Thread-safe Components with DispatchQueue, Serial vs. Concurrent Queues, Thread-safe Value Types, and Avoiding Race Conditions (11:37)
Protocol vs Class Inheritance, Composite Reuse Principle, and Extracting Reusable Test Specs with Protocol Inheritance, Extensions and Composition (8:18)
Core Data Overview, Implementation, Concurrency Model, Trade-offs, Modeling & Testing Techniques, and Implementing Reusable Protocol Specs (5:44)
Finishing the Cache Implementation with Business Logic + Core Data Integration Tests—Unit vs. Integration: Pros/Cons, Performance, Complexity & How to Achieve The ideal Testing Pyramid Distribution (19:46)
🥇 The Feed Store Challenge
Recap
Overview
Key Stats and Insights to Maximize Your Development Output
Bonus
Improving Model Composability With Swift’s Standard Result and Optional Types, Map, Functors, and Powerful Refactorings Backed by Tests and Types (Compiler!) (16:02)
UI + Presentation Module
Gathering Fast Feedback and Validating UI Design and Dev Decisions Through Realistic App Prototypes (16:05)
Supporting Multiple Platforms with Swift Frameworks While Separating Platform-specific Components to Facilitate Loose Coupling and Speed up Development (9:12)
Apple MVC, Test-driving UIViewControllers, Dealing with UIKit’s Inversion of Control & Temporal Coupling, and Decoupling Tests from UI Implementation Details (19:44)
Effectively Test-driving MVC UI with Multiple Views/Models/State, Efficiently Loading/Prefetching/Cancelling Image Requests, Inside-Out vs. Outside-In Development, and Identifying the Massive View Controller Anti-pattern by Following Design Principles (35:34)
Refactoring Massive View Controllers Into Multiple Tiny MVCs + Using Composers & Adapters to Reduce Coupling and Eliminate Redundant Dependencies (22:08)
MVVM: Reducing Boilerplate, Shifting Reusable Presentation Logic from Controllers into Cross-Platform (Stateful & Stateless) ViewModels, and Decoupling Presentation from UI Frameworks with Swift Generics (26:42)
MVP: Creating a Reusable and Cross-Platform Presentation Layer, Implementing Service Adapters, and Solving Cyclic Dependencies & Memory Management issues with the Proxy Pattern (31:29)
Storyboard vs. Code: Layout, DI and Composition, Identifying the Constrained Construction DI Anti-pattern, and Optimizing Performance by Reusing Cells (23:47)
Creating, Localizing, and Testing Customer Facing Strings in the Presentation Layer + NSLocalizedString Best Practices (17:38)
Decorator Pattern: Decoupling UIKit Components From Threading Details, Removing Duplication, and Implementing Cross-Cutting Concerns In a Clean & SOLID Way (14:55)
🥇 The UI Design Patterns Challenge
Test-driven Approach to Effectively Dealing with Legacy Code (Code With No Tests!) + Extracting Cross-platform Components From a Platform-specific Module (27:56)
Recap
Overview
Key Stats and Insights to Maximize Your Development Output
Main + Composition Module
Feed Image Data Loading and Caching with URLSession/CoreData + Composing Modules Into a Running iOS Application with Xcode Workspaces (14:11)
Composite Pattern: Implementing a Flexible & Composable Strategy for Loading Data with Fallback Logic (27:54)
Interception: An Effective, Modular and Composable Way of Injecting Behavior and Side-effects in the App Composition (27:04)
Validating Acceptance Criteria with High-Level UI Tests, Controlling Network and App State in UI tests with Launch Arguments and Conditional Compilation Directives (32:22)
Validating Acceptance Criteria with Fast Integration Tests, Composition Root, and Simulating App Launch & State Transitions (26:52)
Validating the UI with Snapshot Tests + Dark Mode Support (23:22)
Preventing a Crash when Invalidating Work Based on UITableViewDelegate events (7:26)
Organizing Modular Codebases with Horizontal and Vertical Slicing (24:04)
Continuous Delivery and Deployment: Automating the App Deploy to App Store Connect (18:44)
From Design Patterns to Universal Abstractions Using the Combine Framework (31:59)
Recap
Overview
Key Insights to Maximize Your Development Output
[Bonus Lives] Navigation + Advanced Patterns Module
#001 - [Image Comments API] From Dependency Injection to Dependency Rejection (139:52)
#002 - [Image Comments Presentation] Reusable Presentation Logic (151:20)
#003 - [Image Comments UI] Reusable UI Components, Diffable Data Sources, Dynamic Type, Snapshot Testing (164:29)
#004 - [Image Comments Composition] Navigation and Feature Composition (124:44)
🥇 The Image Comments Challenge
#005 - Keyset Pagination with Caching Strategy (168:47)
#006 - Logging, Profiling, and Optimizing Infrastructure Services (101:04)
#007 - Async Injection: Decoupling the Domain from Infra Details (126:03)
Request your Certificate of Completion and Blue belt 🔵
From Design Patterns to Universal Abstractions Using the Combine Framework
Lesson content locked
If you're already enrolled,
you'll need to login
.
Enroll in Course to Unlock