Mobile App Development Native iOS Development Syllabus

Native iOS Development syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Native iOS Development in Mobile App Development, not a summary of it.

1. 1

   Xcode and Project Setup

   4 topics

   • Xcode IDE and Interface Builder
   • Project Structure and Targets
   • Simulators and Devices
   • Asset Catalogs and App Icons
2. 2

   SwiftUI

   4 topics

   • Views and Modifiers
   • State and Data Flow
   • Navigation and Presentation
   • Animations and Transitions
3. 3

   UIKit

   4 topics

   • View Controllers and Lifecycle
   • Auto Layout and Constraints
   • Table and Collection Views
   • UIKit and SwiftUI Interoperability
4. 4

   Concurrency and Networking

   4 topics

   • URLSession and REST Calls
   • Async/Await and Structured Concurrency
   • Combine Framework
   • Codable and JSON Parsing
5. 5

   Data Persistence on iOS

   4 topics

   • UserDefaults and Keychain
   • Core Data
   • SwiftData
   • File System and Caching
6. 6

   Apple Platform Services

   4 topics

   • Push Notifications (APNs)
   • Core Location and MapKit
   • Sign in with Apple
   • In-App Purchases and StoreKit

Native iOS Development flashcards for Mobile App Development

24 of 51 cards from the Native iOS Development deck — real questions with worked answers.

1. In Xcode, what is the difference between Interface Builder's Storyboard and a XIB (NIB) file?

   A Storyboard describes multiple view controllers and the segues (transitions) between them in one file, capturing app flow. A XIB/NIB describes a single, standalone view or view-controller hierarchy with no flow information.

2. What Xcode file bundles the settings that tell the compiler and linker how to build a product, and how does it relate to a target?

   Build settings (the Build Settings tab / .xcconfig files) define compiler/linker flags. Each target owns its own build settings, and a target defines one product (app, framework, test bundle) built from a chosen set of source files and resources.

3. In an Xcode project, what is the distinction between a Project, a Target, and a Scheme?

   A Project is the container of files and settings. A Target produces a single build product from a subset of those files. A Scheme defines which targets to build and how (Run, Test, Profile, Archive configurations).

4. What is a Build Configuration in Xcode, and name the two default ones.

   A named collection of build settings applied during a build. The two defaults are Debug (unoptimized, with debug symbols) and Release (optimized, for distribution).

5. What is the purpose of the Info.plist file in an iOS target?

   It is a property-list dictionary of runtime configuration metadata: bundle identifier, version, display name, supported orientations, required device capabilities, and usage-permission strings.

6. What is the difference between the iOS Simulator and a physical device for testing?

   The Simulator runs the app in a macOS process using host CPU/RAM, so it is fast but cannot test hardware-only features (camera, GPS accuracy, real performance, Bluetooth) or true ARM performance. A physical device gives real hardware behavior and requires code signing / provisioning.

7. Why can't the iOS Simulator reliably test app performance and memory pressure?

   The Simulator uses the Mac's (typically far more powerful) CPU, GPU, and memory, so timings and resource limits do not reflect the constrained ARM device environment.

8. In an Asset Catalog (.xcassets), what is an Image Set and why does it contain multiple slots (1x, 2x, 3x)?

   An Image Set groups the resolution variants of a single image asset. The 1x/2x/3x slots hold the same image at different pixel densities so iOS automatically picks the correct one for each device's screen scale.

9. What is the recommended way to provide app icons in modern Xcode, and what format allows a single image?

   Use the App Icon set in the Asset Catalog. Modern Xcode supports supplying a single 1024x1024 image and letting Xcode generate all required sizes.

10. In SwiftUI, what is a View and what single requirement does the View protocol impose?

    A View is a lightweight, value-type description of a piece of UI. The View protocol requires a computed property `var body: some View` that returns the view's content.

11. In SwiftUI, what is a modifier and how does chaining order affect the result?

    A modifier is a method that returns a new view wrapping the original with an added behavior or style. Order matters because each modifier wraps the previous result; e.g. applying `.padding()` before vs after `.background()` changes whether the background includes the padding.

12. In SwiftUI, distinguish `@State`, `@Binding`, and `@StateObject`.

    `@State` is source-of-truth value state owned locally by a view. `@Binding` is a read/write reference to state owned elsewhere. `@StateObject` creates and owns an observable reference-type model instance for the view's lifetime.

13. In SwiftUI, what is the difference between `@StateObject` and `@ObservedObject`?

    `@StateObject` instantiates and owns the object, guaranteeing it survives view re-creation. `@ObservedObject` merely observes an object owned elsewhere and is re-subscribed each time the view is recreated (so creating one here risks it being deallocated).

14. In SwiftUI, what does `@EnvironmentObject` provide over `@ObservedObject`?

    `@EnvironmentObject` reads a shared observable object injected into the environment by an ancestor view, so it doesn't need to be passed explicitly through every intermediate view's initializer.

15. What protocol must a SwiftUI reference-type model conform to so views update when its properties change, and what marks the observable properties (pre-iOS 17)?

    It must conform to `ObservableObject`, and properties that should trigger updates are marked with `@Published`.

16. What does the iOS 17 `@Observable` macro replace, and what is one advantage?

    It replaces the `ObservableObject` + `@Published` pattern. An advantage is fine-grained tracking: a view only re-renders when a property it actually reads changes, rather than on any published change.

17. In SwiftUI, what is the difference between `NavigationStack` and `.sheet`?

    `NavigationStack` pushes destinations onto a hierarchical stack with a back-button drill-down. `.sheet` modally presents a view sliding up over the current context, dismissed independently of the navigation hierarchy.

18. In SwiftUI's `NavigationStack`, what is value-based navigation using `navigationDestination`?

    You push data values (e.g. via `NavigationLink(value:)` or by appending to a bound path), and `.navigationDestination(for:)` maps each value type to the view to display, decoupling navigation from view construction.

19. In SwiftUI, what does `withAnimation` do and how does it differ from attaching `.animation(_:value:)`?

    `withAnimation { ... }` animates all view changes caused by the state mutation inside the closure (explicit animation). `.animation(_:value:)` implicitly animates a view whenever the specified value changes.

20. In SwiftUI, what is a `matchedGeometryEffect` used for?

    It links two views across a state transition so SwiftUI interpolates their frames, creating a seamless hero-style animation as one element appears to morph or move into another.

21. In SwiftUI, what is a `transition` and give an example.

    A transition describes how a view animates in and out when it is inserted or removed from the hierarchy, e.g. `.transition(.opacity)`, `.slide`, or `.scale`, applied within an animated state change.

22. List the ordered UIViewController lifecycle callbacks from creation through appearance.

    `loadView` → `viewDidLoad` → `viewWillAppear` → `viewWillLayoutSubviews` → `viewDidLayoutSubviews` → `viewDidAppear`.

23. In UIKit, what is the key difference between `viewDidLoad` and `viewWillAppear`?

    `viewDidLoad` runs once when the view hierarchy is first loaded into memory (good for one-time setup). `viewWillAppear` runs every time the view is about to become visible (good for refreshing data on each appearance).

24. In UIKit Auto Layout, what does the equation of a constraint express?

    Each constraint expresses a linear relationship of the form $item_1.attribute_1 = multiplier \times item_2.attribute_2 + constant$, with a relation of $=$, $\leq$, or $\geq$.

See more Native iOS Development flashcards →

Planning Native iOS Development for Mobile App Development

Native iOS Development (Mobile App Development) FAQ