Mobile App Development Native iOS Development Flashcards

24 sample cards from the Native iOS Development deck

Sampled from the end of the deck, so these are different cards from the ones shown on the syllabus page.

1. Compare UITableView and UICollectionView.

   UITableView shows a single-column vertical list of rows grouped into sections. UICollectionView supports arbitrary layouts (grids, flow, custom, compositional) via a layout object, generalizing tables to two-dimensional arrangements.

2. Why do UITableView and UICollectionView reuse cells, and which method provides a recycled cell?

   Reuse avoids allocating a cell for every item, keeping memory and scrolling performance bounded to on-screen cells. `dequeueReusableCell(withIdentifier:for:)` returns a recycled (or newly created) cell.

3. In a UITableView data source, what do `numberOfRowsInSection` and `cellForRowAt` each return?

   `numberOfRowsInSection` returns the count of rows for a given section. `cellForRowAt` returns the configured `UITableViewCell` for a specific index path.

4. What is a modern Diffable Data Source and what problem does it solve?

   `UITableViewDiffableDataSource` / `UICollectionViewDiffableDataSource` drive updates from immutable snapshots of sections and item identifiers, computing and animating differences automatically, eliminating manual `insert/delete` batch-update crashes from inconsistent counts.

5. How do you embed a SwiftUI view inside a UIKit view controller?

   Wrap the SwiftUI view in a `UIHostingController` and add that controller as a child view controller (or use its `.view`).

6. How do you embed a UIKit view or view controller inside SwiftUI?

   Conform a struct to `UIViewRepresentable` (for a UIView) or `UIViewControllerRepresentable` (for a UIViewController), implementing the make/update methods and optionally a Coordinator for delegation.

7. In UIViewRepresentable, what is the role of the Coordinator?

   The Coordinator is an object that acts as delegate/data source or target-action handler for the wrapped UIKit view, bridging UIKit callbacks back into SwiftUI state.

8. What is the basic sequence to perform a GET request with URLSession using completion handlers?

   Create a `URL`, build a `URLRequest` (or use the URL directly), call `URLSession.shared.dataTask(with:) { data, response, error in ... }`, then call `.resume()` to start the task.

9. In URLSession, why must you call `.resume()` on a data task?

   Tasks are created in a suspended state; `.resume()` starts execution. Forgetting it means the network request never fires.

10. What is the async/await equivalent of a URLSession data task, and what does it return?

    `let (data, response) = try await URLSession.shared.data(from: url)` (or `data(for: request)`), returning a tuple of the response body `Data` and the `URLResponse`.

11. In Swift concurrency, what is the difference between `async let` and a `TaskGroup`?

    `async let` binds a fixed, statically known number of concurrent child tasks awaited later. A `TaskGroup` spawns a dynamic number of child tasks (e.g. in a loop) and collects their results, all with structured lifetimes.

12. What does the `@MainActor` attribute guarantee?

    It guarantees the annotated code (property, method, or type) runs on the main thread/main actor, which is required for updating UIKit/SwiftUI UI.

13. In structured concurrency, what does it mean that child tasks have bounded lifetimes?

    A parent task cannot complete until all its child tasks have finished (or been cancelled), so task lifetimes are nested within the enclosing scope, preventing leaked or orphaned work.

14. What is the difference between `Task { }` and `Task.detached { }`?

    `Task { }` inherits the current actor context, priority, and task-local values. `Task.detached { }` creates an unstructured task with no inherited context, running independently of the enclosing scope.

15. In the Combine framework, what are a Publisher and a Subscriber?

    A Publisher emits a sequence of values over time along with a completion or failure. A Subscriber receives those values and the terminal event; `sink` and `assign` are common subscribers.

16. In Combine, what is the role of an operator, and give two examples.

    An operator transforms, filters, or combines values in a publisher chain, returning a new publisher. Examples: `map` (transform each value) and `filter` (drop values failing a predicate); others include `debounce` and `combineLatest`.

17. In Combine, why is `AnyCancellable` important?

    Subscribing (via `sink`/`assign`) returns an `AnyCancellable`; you must retain it (e.g. in a `Set<AnyCancellable>`) or the subscription is cancelled and deallocated immediately.

18. In Swift's Codable, what is the difference between Encodable and Decodable?

    `Encodable` lets a type serialize itself to an external format (e.g. JSON). `Decodable` lets a type be created from external data. `Codable` is the typealias `Encodable & Decodable`.

19. How do you decode a JSON payload into a Codable struct, and how do you map differing JSON key names?

    Use `try JSONDecoder().decode(MyType.self, from: data)`. Map differing names either with a `CodingKeys` enum or by setting `decoder.keyDecodingStrategy = .convertFromSnakeCase`.

20. In JSONDecoder, what does `dateDecodingStrategy` control and name a common value?

    It controls how JSON date values are parsed into `Date`. Common values include `.iso8601`, `.secondsSince1970`, `.millisecondsSince1970`, and `.formatted(_:)`.

21. What is UserDefaults appropriate for, and what should it NOT store?

    UserDefaults stores small amounts of lightweight user preferences and settings as a property list. It should not store large data or sensitive secrets (it is not encrypted).

22. Why use the Keychain instead of UserDefaults for storing passwords or tokens?

    The Keychain is an encrypted, access-controlled secure store backed by the Secure Enclave/hardware, whereas UserDefaults is stored in plaintext in the app container and is not secure for credentials.

23. In Core Data, what are the roles of NSManagedObjectContext and NSPersistentContainer?

    `NSManagedObjectContext` is the in-memory scratchpad where you create, fetch, modify, and delete managed objects and then `save()`. `NSPersistentContainer` sets up the whole Core Data stack (model, coordinator, store, and a main-thread viewContext).

24. In Core Data, what is an NSFetchRequest and how do you constrain and order its results?

    An `NSFetchRequest` describes a query for a given entity. You constrain results with an `NSPredicate` and order them with an array of `NSSortDescriptor` objects.

What this deck covers

Native iOS Development flashcards FAQ