iOS Development at Scale: App Architecture and Design Patterns for Mobile Engineers

Table of Contents
About the Author
About the Technical Reviewers
Introduction
Chapter 1: Swift Familiarization
	This Chapter Includes
	Structures and Classes
		Exploring Reference and Value Types
			Summarizing Value and Reference Types
		Inheritance for Classes
			A Brief Note on Static and Dynamic Polymorphism
			Inheritance vs. Polymorphism
		Protocols
			Wrapping Up Classes and Structs
				Classes and Protocols
				Classes Have Capabilities That Structs Do Not Have
	Generics in Action
		Generic Functions
			Notes on Placeholder Types
		Generic Types
	Summary
		Three Key Takeaways from This Chapter
		Further Learning
Chapter 2: Memory Management
	This Chapter Includes
	Swift Program Memory Usage
		The Stack
			Characteristics of Stack Memory
		The Heap
			Characteristics of Heap Memory
		Buffer Overflow and Underflow
	Swift Memory Model
		Swift Stack Allocation
		Swift Heap Allocation
	Automatic Reference Counting
		Reference Counting in Action
		ARC Observed Lifetime Bugs
			Some Potential Solutions
	Method Dispatch
		Direct Static Dispatch
		Dynamic Dispatch
		Supporting Polymorphism for Value Types
			The Existential Container
			Inline Value Buffer
			Value Witness Table (VWT)
			Protocol Witness Table (PWT)
			Handling Nested Reference Types
			Handling Generics
				The Implications of Different Sized Types on PWT Memory Management
					Small Types
					Large Types
		Applied Memory Management
			Bug Fixing
	Summary
		Further Learning
Chapter 3: iOS Persistence Options
	Overview
		This Chapter Includes
	iOS Persistence Options
		Saving to a File
			File System Security
		NSUserDefaults
		Keychain
		Core Data
			Managed Objects
			NSManagedObjectContext
			NSPersistentStore
			NSPersistentCoordinator
			Considering When to Use Core Data
		Diving into SQLite
			What Is SQLite
				Serverless
				Self-Contained
				Zero Configuration
			SQLite Architecture
				SQL Compiler: The Front End
				SQLite Core
				SQLite Back End
					Deep Dive: B+ Tree Implementation
						Search
						Insert
						Delete
	Practical Example: Caching a Photo Stream
		Performantly Fetch the Images
		Persist Cached Images Across Application Launches
		Encapsulate the Caching Solution
		Wrapping Up
			Questions for the Reader
	Summary
		Key Takeaways from This Chapter
		Further Learning
Chapter 4: Concurrent Programming
	Overview
		This Chapter Includes
	Concurrent Parallel or Async?
		Concurrency
		Multithreading
		Parallelism
		Asynchronous Programming
		Where Is This Going?
	Cost of Concurrency
		Thread Cost
		Managing State Sharing
		Difficult to Debug
	Implementing Concurrency
		Threads and Locks
			Brief Aside on Locks
		Using GCD and Dispatch Queues
			GCD Key Concepts
			Applying GCD to Our Example
		Operation Queues
			Benefits of Operation Queues
		Swift Concurrency
			Async Functions
			Actors
			Swift Tasks
				Structured Tasks
				Unstructured Tasks
			Applying Swift Concurrency
			Contrasting with GCD
			Rough Edges
			Conclusion on Swift Concurrency
		Deep Dive: Challenges of Implementing Concurrency
			Race Condition
			Deadlock
			Priority Inversion
			Thread Explosion
	Considerations for Real-World Applications
		Example 1: Scaling Meta’s Newsfeed
			Key Takeaway: Design for Scaling
		Example 2: Building Swift Concurrency
			Key Takeaway: Principles Transcend the Implementation Details
	Summary
		Three Key Takeaways from This Chapter
		Further Learning
Chapter 5: The Importance of Good Architecture
	Overview
	Defining Good Architecture
		Applying Our Modular and Testable Framework to SOLID
			Single Responsibility Principle
			The Open-Closed Principle
			Liskov Substitution Principle (LSP)
			Interface Segregation Principle
			Dependency Inversion
	Modularity
		Modularity Case Studies
			Uber Redesign for Scale
			Creating Component Kit
			Airbnb Designing for Productivity
		Wrapping Up Modularity
	Testability
		Testing Case Studies
			Large-Scale Testing and Sapienz at Meta
			Ziggurat Square’s Testable Architecture
		Wrapping Up Testability
	Choosing an Architecture
	Summary
		Three Key Takeaways from This Chapter
		Further Learning
Chapter 6: Common Design Patterns
	Overview
		This Chapter Includes
	Why Design Patterns Are the Building Blocks for Design
		Specific Needs of Mobile Engineers
	Design Patterns
		Overarching Themes
			Creational
			Structural
			Behavioral
		Delegate Pattern
			The Problem
			The Solution
			Architecture
				Code
			Trade-Offs
		Facade Pattern (Structural)
			The Problem
			The Solution
			Architecture
				Pseudocode
			Trade-Offs
		The Builder Pattern
			The Problem
			The Solution
			Architecture
				Code
			Note: A Simpler Builder
			Trade-Offs
				Pros
				Cons
		The Factory Pattern
			The Problem
			The Solution
				For the Factory Method
				For the Abstract Factory
			Architecture
				Code
					Factory Method
					Abstract Factory
			Trade-Offs
		Singleton
			The Problem
			The Solution
			The Architecture
				Code
			Trade-Offs
				Pros
				Cons
		Dependency Injection (DI)
			The Problem
			The Solution
			The Architecture
				Pseudocode
			Trade-Offs
		Coordinators
			The Problem
			The Solution
			Architecture
				Basic Coordinator
				Application-Wide Coordinator
				Pseudocode
			Trade-Offs
		Observer
			The Problem
			The Solution
			Architecture
				Example Code
			Trade-Offs
				Runtime Behavior
				Memory Management
				Complex State Management
	Summary
		Two Key Takeaways from This Chapter
		Further Learning
Chapter 7: Model View Controller (MVC)
	Overview
		This Chapter Includes
	A Detailed Look at MVC
		MVC Components
			The Model
			The View Controller
			The View
		Component Interactions
			Object Construction
			Updates to the Model
			Updates to the View
			The View Controller’s Role
			The View State Storage and Updates
		Practical Example
		Discussion
			Trade-Offs
			Modularity
				A Note on Avoiding Premature Optimization
			Testability
			MVC at Scale
	Summary
		Three Key Takeaways from This Chapter
		Further Learning
Chapter 8: Model View View-Model (MVVM)
	Overview
		This Chapter Includes
	A Detailed Look at MVVM
		MVVM Components
			The Model
			The View-Model
			The View Controller
			The View
		Component Interactions
			Object Construction
			Updates to the Model
			The View-Model
			The View Controller
			Updates to the View
			The View State
		Practical Example
		Discussion
			Trade-Offs
				Overhead
				Reactive Programming
			Modularity
			Testability
	Summary
		Three Key Takeaways from This Chapter
		Further Learning
Chapter 9: VIPER
	Overview
		This Chapter Includes
	A Detailed Look at VIPER
		VIPER Components
			The View
			The View Controller
			The Interactor
			The Presenter
			The Entity
			The Router
		Component Interactions
			Object Construction
			Updates to the Model: The Interactor
			The Presenter
			The View Controller
			Updates to the View
			The View State
		Practical Example
		Discussion
			Trade-Offs
			Advantages
			Drawbacks
			Modularity
			Testability
	Summary
		Three Key Takeaways from This Chapter
		Further Learning
Chapter 10: The Reactive Programming Paradigm
	Overview
		This Chapter Includes
	Reactive Programming
		The Rules of the Game
		Data Propagation Techniques
			Topological Sorting
		Interaction with Mutable State
	Functional Reactive Programming
		Category Theory
		Functors
		Monoid
		Monads
	FRP and Combine
		Publishers and Subscribers
		Combine Behaviors
			Functor
			Monad
		Application Architecture
			Application Overview
			Area Owner
			Feature Owner
	Benefits of Reactive Programming and FRP
	Summary
		Three Key Takeaways from This Chapter
		Further Learning
Chapter 11: System Design Process
	Overview
		This Chapter Includes
	Software Development Life Cycle (SDLC)
		How SDLC Works
			Plan
				Strategy Review
				Long-Range Planning Document
				Road Map
				Differences in Planning at Small and Big Companies
			Design
			Implement
			Test
			Deploy
			Maintain
		SDLC Models
			Waterfall
				Key Tenets
				Pros and Cons
			Spiral
				Key Tenets
				Pros and Cons
			Agile
				Key Tenets
				Pros and Cons
			Extreme Programming (XP)
				Key Tenets
				Pros and Cons
			Methods Review
	Crucial Role of the TL
	A Skill-Focused View
		Problem Navigation
		Solution Design
		Communication
			Communication Framework
				Understand Everyone’s Point of View
				Guiding the Conversation
				Using a Common Language and Value Framework
				Communicating Risk
			Technical Communication
			Communicating Business Needs
	Setting Goals for Success
		S: Specific
		M: Measurable
		A: Achievable
		R: Relevant
		T: Time-Bound
			Goal for Product and Infrastructure Teams
			Goal for Metric-Driven Teams
	Why Is SDLC Important?
	Summary
		Four Key Takeaways from This Chapter
		Further Learning
Chapter 12: Testability
	Overview
		This Chapter Includes
	Why Test
	Unit Testing
		Writing Code That Stays Testable
		Setter Injection
	Integration Testing
	Contract Testing
	UI Testing
		Snapshot Testing
	Manual Testing
	Managing Testing at Scale
		Test Case Prioritization
		Categorizing Test Suites
		Prioritizing Manual Testing
		Managing Testing Over Time
	What If I Have No Tests?
	Summary
		Four Key Takeaways from This Chapter
		Further Learning
Chapter 13: Performance
	Overview
		This Chapter Includes
	Why Performance Matters
	iOS Factors to Consider
	Key Concepts
		Topline Metrics
		Intermediate Metrics
		Funnel Logging
		Evaluating Percentiles
		Monitoring and Alerting
	The Complete Performance Cycle
		Know Your Tools
		Application Growth
		Debugging Performance Problems
		Apply Occam’s Razor
		Continuous Testing and Evaluation
	Performance Metrics
		Application Size
		Application Startup Time
		Application Responsiveness (Hangs)
		Battery Drain
		Application Crashes
			What Is Symbolication?
		Network-Related Metrics
			Latency
			Load
			Errors
		Engagement Metrics
	A Brief Practical Example
	Summary
		Four Key Takeaways from This Chapter
		Further Learning
Chapter 14: Experimentation
	This Chapter Includes
	Why Experimentation Is Important
	Theoretical Experimentation Platform
		Universes for Experimentation
		Experiment Tooling
			Cluster Testing (The Network Effect)
		Metrics Evaluation Platform
	The Scientific Method and Hypothesis Testing
		Applying the Scientific Method to Our Photo Stream Example
		Experiment Design and Implementation
			Choosing Test Statistics
			Assess Sample Size and Distribution
				Required Sample Size and Effects on Analysis
				Factors That Could Impact User Eligibility
		Results Analysis
			Types of Errors
			Understanding Statistical Significance
				Calculating the P-Value
					Two- vs. One-Sided Tests
			Statistical Power and the Minimum Detectable Effect (MDE)
			Holistic Results Analysis
			Practical Example for Holistically Interpreting Results
	Common Pitfalls
		Multiple Comparison Problem
		Experiment Pollution
		Claiming Not Statistically Significant Results are Neutral
		Running Experiments That Are Too Small (Underpowered)
		P-Hacking
		Filtering on Posttreatment Variables
		Dilution
		Not Waiting for Results to Stabilize
		Nonrepresentative Test Experiences and Populations
		Ignoring the Network Effect
		Pre-AA Bias
	Additional Validation Steps
	Summary
		Key Takeaways
		Further Learning
Chapter 15: Application Release and Maintenance
	This Chapter Includes
	Managing Continuous Integration and Delivery: The Build Process
		Keeping Master Stable
		Managing Build Times
		Continuous Delivery
		The Release Infrastructure
			Release Oncall
			How to Measure System Success
			Can We Move Faster?
	Releasing a Large Project
		When Building Our Feature
			Who Are These Concerned Business Partners?
		Meeting Launch Standards
		Dogfooding and Limited Release
		Release
	Alerting and Monitoring
		Logging
		Monitoring
		Alerting
		Logging to Alerting Example
	Maintenance
	Summary
		Key Takeaways
		Further Learning
Chapter 16: Leading Multiple Teams
	This Chapter Includes
	Engineer Archetypes
		Fixer
		Tech Lead
		Architect
		Executive Assistant
	Requirements of Senior Engineer
		Breadth
		Depth
		Scope
		Applying Depth, Breadth, and Scope
		Level Three: Senior Engineer
		Level Four: Staff Engineer
		Level Five and Beyond: Principal Engineer and Above
		Connecting the Overall System
		Brief Aside for Metric-Driven Teams
			Establish the Goal
			Through Iterative Experimentation, Establish Leading Levers
			Understand Additive Combinations for the Launch Candidate
		Balancing Each Dimension
	Becoming a Well-Rounded Senior Engineer
		Brief Aside on Understanding Technical Concepts
		Why Are Soft Skills Needed?
		Situational Leadership Model
			Leadership Styles
			Development Levels
			Common Pitfalls
				Oversupervision: Micromanaging
				Undersupervision
			Applied to Leading Multiple Teams
			Practical Example
			Trade-Offs
			Relationship Between Senior Engineers and Managers
			Mentorship: Scaling Oneself
		Building Relationships
			How to Be Nice
			How to Build Trust
			How to Influence People
			Combining the Frameworks
	Summary
		Key Takeaways
		Further Learning
Chapter 17: Practical Example
	Top-Down vs. Bottom-Up
		Setting the Scene
			Notes on the Planning/Scoping Phase
			Jumping Back into Our Story…
			Notes on the Execution/Testing Phase
			Jumping Back into Our Story…
			Notes on the Deployment/Maintenance Phase
	Notes on the Case Study Roles and Archetypes
		Archetypes
			Chief Architect
			Tech Lead
			Executive Assistant
			Fixer
		Overall Notes
	Summary
Appendix: Completed Five-Year Plan
	Problem Alignment
		High-Level Approach
		Goals
		Review Problem Alignment
	Solution Alignment
		Key Scoping Documents for MVP Feature Set
		Key Flows
		Key Logic
	Launch Plan
		Key Milestones
		Operational Checklist
		Changelog
		Open Questions
Index