Nail Your Next iOS Engineering Interview

Sorting

• Introduction to Sorting
• Basics of Asymptotic Analysis and Worst Case & Average Case Analysis
• Different Sorting Algorithms and their comparison
• Algorithm paradigms like Divide & Conquer, Decrease & Conquer, Transform & Conquer
• Presorting
• Extensions of Merge Sort, Quick Sort, Heap Sort
• Common sorting-related coding interview problems

Recursion

• Recursion as a Lazy Manager's Strategy
• Recursive Mathematical Functions
• Combinatorial Enumeration
• Backtracking
• Exhaustive Enumeration & General Template
• Common recursion- and backtracking-related coding interview problems

Trees

• Dictionaries & Sets, Hash Tables 
• Modeling data as Binary Trees and Binary Search Tree and performing different operations over them
• Tree Traversals and Constructions 
• BFS Coding Patterns
• DFS Coding Patterns
• Tree Construction from its traversals 
• Common trees-related coding interview problems

Graphs

• Overview of Graphs
• Problem definition of the 7 Bridges of Konigsberg and its connection with Graph theory
• What is a graph, and when do you model a problem as a Graph?
• How to store a Graph in memory (Adjacency Lists, Adjacency Matrices, Adjacency Maps)
• Graphs traversal: BFS and DFS, BFS Tree, DFS stack-based implementation
• A general template to solve any problems modeled as Graphs
• Graphs in Interviews
• Common graphs-related coding interview problems

Dynamic Programming

• Dynamic Programming Introduction
• Modeling problems as recursive mathematical functions
• Detecting overlapping subproblems
• Top-down Memorization
• Bottom-up Tabulation
• Optimizing Bottom-up Tabulation
• Common DP-related coding interview problems

Online Processing Systems

• The client-server model of Online processing
• Top-down steps for system design interview
• Depth and breadth analysis
• Cryptographic hash function
• Network Protocols, Web Server, Hash Index
• Scaling
• Performance Metrics of a Scalable System
• SLOs and SLAs
• Proxy: Reverse and Forward
• Load balancing
• CAP Theorem
• Content Distribution Networks
• Cache
• Sharding
• Consistent Hashing
• Storage
• Case Studies: URL Shortener, Instagram, Uber, Twitter, Messaging/Chat Services

Batch Processing Systems

• Inverted Index
• External Sort Merge
• K-way External Sort-Merge
• Distributed File System
• Map-reduce Framework
• Distributed Sorting
• Case Studies: Search Engine, Graph Processor, Typeahead Suggestions, Recommendation Systems

Stream Processing Systems

• Case Studies: on APM, Social Connections, Netflix, Google Maps, Trending Topics, YouTube

UI Programming and Architecture

• UI challenges involving the usage of TableViews, Collection Views, StackViews, and Layout constraints.
• Deep dive into the programmatic implementation of custom UI components.

• Write clean, organized, and reusable code.
• Challenging interview questions on design patterns: MVC, MVVM, MVP, and VIPER. When to use which design pattern? Benefits and drawbacks of each architecture. Refactoring code from one design pattern to another.

• Questions and case study on DiffableDataSource.

• UIResponder, Events, etc.
• Frequently asked interview questions around app life-cycle and view life-cycle, e.g., Explain the difference between inactive, backgrounded, and suspended app states.

Performantly Fetching and Handling Data

• Introduction to general multithreading concepts like deadlock and race condition. Describe how to make thread-safe. 
• Deep dive into concepts like GCD, queues, and async/await to make API calls that do not block UI and concepts like dispatch carriers. 
• Interesting interview questions around making Network Requests and handling responses. 
• Live coding questions: 
• Give an example of deadlock in iOS (dispatch-sync to a serial queue).
• Implement a thread-safe app using the techniques stated above.
• Debugging questions:
• Given a piece of the code sample, fixing bugs like: 
• UI is not updated in the main thread.
• We were doing time-consuming work like downloading, formatting, and file reading in the main thread. 
• We want data returns in order, but they are rendered randomly, etc.
• Challenging design questions involving making paginated network calls. E.g., 
• Design a Tik-Tok-like application; focus more on optimizations like:
• Reduce load time
• Cache
• Preload and pagination
• Designing an image downloading manager that will allow consumers to pass in a URL in return for an image file.
• Design a booking.com app, which aims for e2e design:
• Should include at least: authentication, search flight, checkout, payment, and confirmation.
• Some corner cases should also be considered like: 
• What if the ticket is sold out during the session
• Different errors: API return errors, tickets not found, payment not successful
• API design: 
• Model design
• Design necessary endpoints

Data Persistence

• A detailed discussion of data persistence strategies through interview questions. E.g., Designing offline features for the WhatsApp application. 
• Challenging design questions involve the following: 
• Persist through 1+ app launches
• Key-chain, CoreData, User Defaults, including file system
• Persist for 1 app lifecycle (or less)
• Questions related to caching: when to cache? Which database to use for caching? 
• Commonly asked interview questions around memory management, memory leaks, ARC, etc.

iOS Systems Design

• Understanding system design interviews (basic): What is a system design interview? What companies are looking to get out of it? How is it different from a regular technical interview?
• Understanding system design interviews (advanced): What to do, what not to do, and how to strategize for system design interviews based on different companies, positions, and experiences.
• Deep dive into system design interview: Generic template to solve client-side system design interview questions (along with a strategy for 1-hour vs 2-hour system design interview and multiple case studies to practice)
• Modularization theory and strategies in practice:
• How modularization adds horizontal scaling to app architecture vertical layers of abstraction; modularization's main benefits (build times and module composability, ownership, and incremental migrations)