[Update Links] Essential Developer - Make better iOS apps Free Download

Essential Developer – Make better iOS apps
English | Size: 18.04 GB
Genre: eLearning

*** Course # 1: iOS Lead Essentials ***
Welcome
Are Singletons and Global Instances Damaging your System Design and Testability?
Intro to Dependency Diagrams and Composition
Intro to Modular Design
BDD, TDD, Use Cases, Architecture and Modular Design
Effectively Developing Swift Apps Before the Backend/Design Is Ready
From Singletons and Globals to Proper Dependency Injection
Asserting a Captured Value Is Not Enough + Cross-Module Access Control
Handling Errors + Stubbing vs. Spying + Eliminating Invalid Paths
A Classicist TDD Approach (No Mocking) to Mapping JSON with Decodable + Domain-Specific Models
Automating Memory Leak Detection + Preventing a (Way Too Common) Async Bug
Conforming to Feature Abstractions While Maintaining System Modularity + Keeping Test Details Out of Production With Enum Pattern Matching and Async Expectations
Four Approaches to Test(-Drive) Network Requests: End-to-End, Subclass & Protocol-Based Mocking, and URLProtocol Stubbing
Speeding up Development by: Reducing Debugging Time, Minimizing Risk & Maximizing Learning, and Decoupling Tests From Implementation Details
Randomizing & Parallelizing Tests, Code Coverage, Testing in Integration with the Backend, and Automating a Continuous Integration (CI) Pipeline
Identifying, Debugging, and Solving Data Races with the Thread Sanitizer
URLCache as a Persistence Alternative & Solving The Infamous “But it works on my machine!” Caching Problem
Clarifying Requirements, Enhancing Cross-Team Domain Knowledge, and Iterative vs. Big Upfront Design
Decoupling Use-Case Business Logic From Framework Details + Controlling Time + Multi-Method Abstractions Following The Interface Segregation and Single Responsibility Principles
Proper Memory-Management of Captured References Within Deeply Nested Closures + Identifying Highly-Coupled Modules
Visualizing and Solving High-Coupling Issues by Decentralizing Components Using Data Transfer Model Representations
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
Test-driving Cache Invalidation + Identifying Complex (Bloated) Functionality With The Command–Query Separation Principle
Separating Queries & Side-effects for Simplicity and Reusability, Choosing Between Enum Switching Strategies, and Differentiating App-Specific from App-Agnostic Logic
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
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
Persisting/Retrieving Models with Codable+FileSystem, Test-driving in Integration with Real Frameworks Instead of Mocks & Measuring Test Times Overhead with `xcodebuild`
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
Designing and Testing Thread-safe Components with DispatchQueue, Serial vs. Concurrent Queues, Thread-safe Value Types, and Avoiding Race Conditions
Protocol vs Class Inheritance, Composite Reuse Principle, and Extracting Reusable Test Specs with Protocol Inheritance, Extensions and Composition
Core Data Overview, Implementation, Concurrency Model, Trade-offs, Modeling & Testing Techniques, and Implementing Reusable Protocol Specs
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
Improving Model Composability With Swift’s Standard Result and Optional Types, Map, Functors, and Powerful Refactorings Backed by Tests and Types (Compiler!)
Gathering Fast Feedback and Validating UI Design and Dev Decisions Through Realistic App Prototypes
Supporting Multiple Platforms with Swift Frameworks While Separating Platform-specific Components to Facilitate Loose Coupling and Speed up Development
Apple MVC, Test-driving UIViewControllers, Dealing with UIKit’s Inversion of Control & Temporal Coupling, and Decoupling Tests from UI Implementation Details
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
Refactoring Massive View Controllers Into Multiple Tiny MVCs + Using Composers & Adapters to Reduce Coupling and Eliminate Redundant Dependencies
MVVM: Reducing Boilerplate, Shifting Reusable Presentation Logic from Controllers into Cross-Platform (Stateful & Stateless) ViewModels, and Decoupling Presentation from UI Frameworks with Swift Generics
MVP: Creating a Reusable and Cross-Platform Presentation Layer, Implementing Service Adapters, and Solving Cyclic Dependencies & Memory Management issues with the Proxy Pattern
Storyboard vs. Code: Layout, DI and Composition, Identifying the Constrained Construction DI Anti-pattern, and Optimizing Performance by Reusing Cells
Creating, Localizing, and Testing Customer Facing Strings in the Presentation Layer + NSLocalizedString Best Practices
Decorator Pattern: Decoupling UIKit Components From Threading Details, Removing Duplication, and Implementing Cross-Cutting Concerns In a Clean & SOLID Way
Test-driven Approach to Effectively Dealing with Legacy Code (Code With No Tests!) + Extracting Cross-platform Components From a Platform-specific Module
Feed Image Data Loading and Caching with URLSession/CoreData + Composing Modules Into a Running iOS Application with Xcode Workspaces
Composite Pattern: Implementing a Flexible & Composable Strategy for Loading Data with Fallback Logic
Interception: An Effective, Modular and Composable Way of Injecting Behavior and Side-effects in the App Composition
Validating Acceptance Criteria with High-Level UI Tests, Controlling Network and App State in UI tests with Launch Arguments and Conditional Compilation Directives
Validating Acceptance Criteria with Fast Integration Tests, Composition Root, and Simulating App Launch & State Transitions
Validating the UI with Snapshot Tests + Dark Mode Support
Preventing a Crash when Invalidating Work Based on UITableViewDelegate events
Organizing Modular Codebases with Horizontal and Vertical Slicing
Continuous Delivery and Deployment: Automating the App Deploy to App Store Connect
From Design Patterns to Universal Abstractions Using the Combine Framework
#001 – [Image Comments API] From Dependency Injection to Dependency Rejection
#002 – [Image Comments Presentation] Reusable Presentation Logic
#003 – [Image Comments UI] Reusable UI Components, Diffable Data Sources, Dynamic Type, Snapshot Testing
#004 – [Image Comments Composition] Navigation and Feature Composition
#005 – Keyset Pagination with Caching Strategy
#006 – Logging, Profiling, and Optimizing Infrastructure Services
#007 – Async Injection: Decoupling the Domain from Infra Details

*** Course # 2: iOS Dev Mentoring Sessions***
#001 – Luis Zapata – Eliminating Core Data concurrency issues & Sharing state between screens (43:51)
#002 – Maurício Maniglia – Passing Interview Code Challenges (101:19)
#003 – José Roberto Abreu – MVVM, Dynamic UI, and Services (56:46)
#004 – Khoi Nguyen – Senior iOS Developer Interview (149:35)
#005 – Jose Alvarez – SOLID Principles Applied (71:52)
#006 – Rodrigo Manguinho – Architecture and Software Design (39:31)
#007 – Shun Lung Chen – Mock Design Interview (74:43)
#008 – Andre Kvashuk – Test-driven MVVM with RxSwift (98:14)
#009 – Shady Kahaleh – Populating UI from Multiple Services (64:39)
#010 – Danil Lakhtin – App Authorization & Permission Roles (91:46)
#011 – Nicolás Landa – From iOS Developer to Team Lead (75:06)
#012 – Andrey Chirkov – Sign in with Apple + Firebase + Combine (98:43)
#013 – Hanyu Chen – Threading, Operations, and Queues (77:23)
#014 – Paul Lee – Login, Authentication, and Tokens (65:03)
#015 – Gordon Smith – DiffableDataSources, Pagination & Infinite Scroll (78:52)
#016 – Yaroslav Nosik – Improving legacy iOS/Swift codebases (109:43)
#017 – Tsungyu Yu – Test-driving UI Views and Controls (68:56)
#018 – Damian Modernell – Becoming an iOS Team Lead, Managing dev/prod Envs, and Mitigating App Security Threats (64:02)
#019 – Gordon Smith – SwiftUI & DI Patterns: Passing dependencies to distant views (50:52)
#020 – Dinesh Kumar – From MVVM to Clean Architecture: Core Data Transaction Consistency (37:05)

If any links die or problem unrar, send request to
forms.gle/e557HbjJ5vatekDV9

[Update Links] Essential Developer – Make better iOS apps

Leave a Comment Cancel reply