iOS Development at Scale

Scale mobile applications to handle an enormous user base and development team. This book outlines the scaling challenges that mobile engineers face and some standard techniques and design patterns to deal with those issues.

You already know the basics of iOS development, but how do you learn the key concepts and patterns to scale a mobile application? You’ll start by learning the fundamentals of the iOS platform often overlooked when using out-of-the-box iOS solutions. While standard iOS solutions might work at a small scale, the most prominent tech companies reinvent these for highly customized usage, making understanding the underlying concepts crucial. Understanding these concepts reduces ramp-up time and allows engineers to understand the "why" intuitively.

Having mastered the fundamentals, you'll next focus on architecture and design principles to build, maintain, and release features within a large codebase and the soft skills to enact change in a larger organization. You’ll be empowered with a deeper understanding of iOS design patterns and the industry knowledge necessary to take their features from idea to production. You’ll also study the people skills to get things done in a large organization—a critical step to growing one's career.

Upon completing iOS Development at Scale, you'll understand the solutions and tradeoffs you can leverage to build better applications and grow your career.

WHAT YOU'LL LEARN

* Apply computer science and engineering fundamentals to the iOS platform


* Implement knowledge of iOS architecture and best practices at large-scale companies


* Identify current gaps in your product and gain alignment within the broader organization
* Solve problems with knowledge of systems architecture and industry best practices to identify and address gaps in your codebase

WHO THIS BOOK IS FOR

iOS software engineers and mobile engineer managers. Additionally, any software engineer, manager, or business stakeholder wanting to learn more about mobile development and the challenges that mobile engineers face.

ERIC VENNARO is a Team Lead at Meta, where he has a track record of delivering high-impact, technically complex projects across mobile, web, and backend infrastructure. He is interested in applied machine learning and privacy, especially the intersection of improving privacy using machine-learning-backed integrity tooling. While working on the iOS platform and recruiting new iOS engineers, Eric noticed a gap in the existing literature for mobile engineering best practices and architectural principles at scale. To address this gap, he decided to write this book using his experience in leading mobile projects. Before working at Meta, Eric founded his own company and worked at Stitch Fix during its explosive growth phase and subsequent IPO. Part 1: General Apple System Knowledge

Chapter 1: Structures and Classes

1.1 Structures And Classes

1.2 Initializing

1.3 Instance Variables

1.4 Properties

1.5 Methods

1.5 Protocols

1.6 Generics

1.7 Conclusion

Chapter 2: Swift Memory Management

2. Memory Management

2.1 App Memory Usage

2.2 Swift Memory Model

2.3 Automatic Reference Counting (ARC) Overview

2.4 ARC Object Ownership

2.5 Heap Allocation

2.6 Stack Allocation

2.7 Method Dispatch

2.8 Conclusion

Chapter 3: Persistent Storage for iOS

3. Persistence For iOS

3.1 Core Data

3.2 Deep Dive SQLite

3.3 Core Data Alternatives and Tradeoffs

3.4 Conclusion

Chapter 4: Concurrency and Parallelism

4.1 Concurrency, Parallelism, and Async Programming

4.2 Benefits Concurrent Programming

4.3 Implementing concurrent programming using threads and locks

4.4 Using GCD For Concurrency

4.5 Using NSOperation queues

4.6 Swift Structured Concurrency

4.7 Conclusion: Choosing The Right Abstraction

Chapter 5: Algorithms and Data Structures

5. Algorithms and Data Structures

5.1 Arrays

5.2 Dictionaries

5.3 Tree Traversals

5.4 Conclusion

Part 2: Common App Architecture and Design Patterns

Chapter 6: Mobile Systems Design

6. Mobile Systems Design

6.1 Approaching Systems Design At Scale

6.2 Importance Of Modularity

6.3 API Engineering For Mobile Engineers

6.4 Advanced State Management - deep links and notifications

6.5 Conclusion

Chapter 7: Mobile Systems Architecture

7. Mobile App Architecture

7.1 MVC Architecture

7.2 MVVM Architecture

7.3 Reactive Programming

7.4 VIPER

7.5 Conclusion

Chapter 8: Mobile Design Patterns

8. Mobile Design Patterns

8.1 Coordinators

8.2 Delegate Pattern

8.3 Dependency Injection

8.4 Aspect-Oriented Programming

8.5 Singletons

8.6 Conclusion

Part 3: Apps At Scale

Chapter 9: Testable Mobile Applications

9. Testability

9.1 Unit testing

9.2 E2E testing

9.3 Leveraging QA

Chapter 10: Enforcing Modularity

10. Dependency Management

10.1 Splitting to improve build time

10.2 Shared libraries

10.3 Conclusion

Chapter 11: Releasing Your Application

11. Build/Release Pipeline

11.1 Automated tests

11.2 Automated code quality

11.3 Automated releases

11.4 Building a release cycle - managing the process, handling changes, and bugs

11.5 Project timing for releases mobile is special

11.6 Forced deprecation

11.7 Analytics, Monitoring, and Alerting

11.8 Mobile On-Call

11.9 Compliance, Privacy, and Security

11.10 Third-party libraries

11.11 ePD/GDPR regulations

11.13 Conclusion

Chapter 12: App Performance

12. Performance

12.1 Establishing performance goals

12.2 App size

12.3 Adding logging

12.4 Making it part of the experimentation process

12.5 iOS Performance Tooling Review

12.6 Conclusion

Chapter 13: Developing For All Audiences13. Localization

13.1 Understanding the market

13.2 Getting content specialists involved

13.3 Automating the tedious parts

13.4 Supporting RTL mode

13.5 Supporting all languages - Tamil (tall characters) Russian (long strings)

13.6 Accessibility in iOS

13.7 Testing accessibility

13.8 Conclusion

Chapter 14: Experimentation

14. Experimentation

14.1 Understanding the value of A/B Testing

14.2 Understanding what metrics are important for the team and app-wide

14.3 Considerations for a successful experiment and shipping

14.4 Statistical considerations for evaluating experiments

14.5 Network effects

14.6 Designing and using a holdout

14.7 Considering performance

14.8 Conclusion

Chapter 15: Cross-Platform Development

15. Cross-Platform Versus Native Development

15.1 Avoid mobile release cycle

15.2 Small team iterate quickly

15.3 Less ability to take advantage of new features and high performance

15.4 App dependent

15.5 Shared core libraries in C

Chapter 16: Becoming a true team lead

16. Leading and working with large teams

16.1 Understanding engineer archetypes and roles

16.2 TL Large team - Delegate

16.3 TL large team - Uplevel others

16.4 The TL and the project lifecycle

16.5 Questioning Mindset

16.6 Communication - verbal and written

16.7 Scaling oneself

16.8 Conclusion

Part 4: Bringing Everything Together

Chapter 17: Practical Examples

17. Practical Examples

17.1 Example 1 - Building A Photo Viewing App

17.2 Example 2 - Improving A Legacy Airplane App

17.3 Example 3 - Re-building A Messaging App Implementing Encryption

17.4 Conclusion