1 Month Plan

How to plan your preparation for 1 week, 1 month or 3 months, and what to practise each week.

Structs are value types and get copied. Classes are reference types and are shared.

Value semantics means each copy is independent; copy-on-write makes copies cheap by sharing storage until someone mutates it.

An optional either holds a value or nil; unwrap it with if let, guard let, ?? or optional chaining instead of force unwrapping.

Associated values let each enum case carry its own extra data, which is great for modeling states where only valid combinations are possible.

An escaping closure can be called after the function that received it returns, so it must be marked @escaping and you must think about what it captures.

A capture list, like [weak self] or [count], controls how a closure captures values, either by making references weak or by copying a value at creation time.

Functions mark failure with throws, callers handle it with do/catch, try? or try!, and Swift 6 adds typed throws for a fixed error type.

A property wrapper is a type that wraps the get and set logic of a property so you can reuse it with an @Attribute, like @State or @Published.

Protocol-oriented programming means building behavior from small protocols with default implementations, instead of deep class inheritance.

some is an opaque type that stands for one specific concrete type the compiler knows; any is a box that can hold any conforming type at run time.

Generics let you write one function or type that works with many types, and constraints limit those types to ones that have the abilities you need.

Swift uses static dispatch when it knows the exact method, table dispatch for class overrides and protocol requirements, and message dispatch for @objc dynamic.

Equatable gives ==, Hashable lets a type be a Set element or Dictionary key, and Comparable gives <; Swift writes them for you when all stored properties already conform.

ARC counts strong references to each class instance and frees the instance as soon as the count reaches zero, with retain and release calls inserted by the compiler.

A strong reference keeps an object alive, a weak reference does not and becomes nil when the object dies, and an unowned reference does not and crashes if used after the object dies.

A retain cycle happens when objects hold strong references to each other so their counts never reach zero; you break it by making one link weak or unowned.

Check that deinit runs, use Xcode's Memory Graph Debugger to see who holds an object, use the Leaks and Allocations instruments, and add tests that assert objects are freed.

Find the two numbers in an array that add up to a target, in one pass.

Check that every bracket in a string is closed by the same type, in the right order.

Group words made of the same letters by using a dictionary with a smart key.

Write a @Clamped property wrapper that keeps a value inside a range, like a volume from 0 to 100.

Build a generic cache that drops the least recently used item when it is full. Every operation must be O(1).

GCD is a lightweight C-based API for running closures on queues, while OperationQueue is a higher-level Objective-C API built on GCD that adds dependencies, cancellation and concurrency limits.

A serial queue runs one task at a time in order while a concurrent queue can run many at once, and sync waits for the work to finish while async returns immediately.

An async function can pause at each await without blocking its thread, letting Swift run other work on that thread until the result is ready.

An actor is a reference type that protects its mutable state by running only one task at a time on it, and reentrancy means its state can change while one of its methods is suspended at an await.

@MainActor is a global actor that runs code on the main thread, and marking UI types and methods with it lets the compiler check that UI updates happen there.

Sendable marks types whose values can safely cross between concurrency domains, like tasks and actors, without causing data races.

A task group runs a dynamic number of child tasks in parallel and collects their results, while async let is for a fixed, small number of tasks known at compile time.

Cancellation in Swift is cooperative; cancel() only sets a flag, and your code must check Task.isCancelled or call try Task.checkCancellation() to stop.

A deadlock is when threads wait for each other forever, a data race is unsynchronized access to the same memory with at least one write, and a race condition is a logic bug that depends on timing.

The Swift 6 language mode turns data-race checks into compile errors, so shared mutable state must be isolated to an actor or be Sendable; you migrate module by module, starting with warnings.

Run an action only after the calls stop for a short time, like a search box that waits until the user stops typing.

Run an action at most once per time window. The first call runs right away, and the last call in the window runs when the window ends.

Retry a failing async operation, and double the wait time after each failure.

Build a bank account as an actor so many tasks can deposit, withdraw and transfer at the same time without data races.

Transform an array with async work in parallel, keep the input order, and never run more than N tasks at once.

Array, Dictionary, Set and tuples in Swift, sorting with closures, reduce, zip, enumerated, 2D arrays, and the Big-O of each operation.

Find the biggest profit from one buy and one later sell, in a single pass.

For each index, multiply every other number, without division, using prefix and suffix products.

Count how often each hashtag is used and return the k most popular ones.

Find the longest run of unique characters with a sliding window and a dictionary.

Merge overlapping calendar events into busy blocks by sorting first, then scanning once.

Use binary search to find the first broken CI build with as few checks as possible.

Reverse a singly linked list in place by turning every next pointer around.

A view controller creates its view, loads it once in viewDidLoad, then gets appear and disappear callbacks every time it shows or hides.

The frame is the view's rectangle in its superview's coordinates, while bounds is the same view described in its own coordinates.

Auto Layout solves a set of constraint equations to find each view's frame, and hugging and compression resistance priorities decide which view grows or shrinks first.

A table view keeps a small pool of cells and reuses them for new rows, so you must fully reset each cell or you will see old data.

A diffable data source takes snapshots of section and item identifiers and computes the inserts, deletes and moves for you, so the UI never gets out of sync with the data.

Hit-testing finds the deepest view under a touch, and the responder chain passes unhandled events and actions up from that view to its superviews, view controller, window and app.

The @State wrapper owns data inside a view, @Binding gives a child read-write access to someone else's data, @Bindable makes bindings to an @Observable object, and @Environment reads shared values from above.

The @Observable macro makes a class track reads and writes of each property, so SwiftUI only updates views that read the changed property, while ObservableObject updates every observer on any change.

SwiftUI uses identity to decide if a view is the same one as before, and identity controls how long state lives and whether changes animate or reset.

NavigationStack drives navigation from data, so you push by appending values to a path and map each value type to a screen with navigationDestination.

Wrap UIKit views with UIViewRepresentable or UIViewControllerRepresentable, and host SwiftUI inside UIKit with UIHostingController or UIHostingConfiguration.

MVC is simple but leads to huge view controllers, MVVM moves logic into a testable view model, VIPER splits a screen into many small roles, and TCA uses one state, actions and a reducer.

A coordinator owns navigation, so view controllers do not know about each other and screens become reusable and easy to test.

Dependency injection means an object gets its dependencies from outside instead of creating them, which makes code easy to test and change.

Delegation lets one object hand some decisions or events to another object through a protocol, and the delegate property is weak to avoid a retain cycle.

Build a small DI container that registers factories by type, supports singleton and transient scopes, and throws for missing types.

Parse custom-scheme deep links and universal links into a type-safe Route enum with URLComponents.

Walk a view tree level by level with breadth-first search and return the names of each level.

Count connected regions of filled pixels in a mask with flood fill (the "number of islands" problem).

How to build a screen live or as a take-home project, with a clean structure, MVVM, networking, tests and a README that reviewers like.

Build an email and password form with live validation, a loading state, server errors and good keyboard focus.

Build a list that loads the next page before the user reaches the end, with loading, error and empty states.

Build a search screen that waits 300 ms after typing, cancels old requests, and shows results, empty and error states.

Build a URLRequest, call try await session.data(for:), check the HTTP status code, then decode the data, and choose a session configuration for caching, timeouts or background transfers.

Codable lets the compiler generate encoding and decoding code, and you customize it with CodingKeys, decoder strategies or a hand-written init(from:).

Let URLCache handle HTTP caching with Cache-Control and ETag headers, and add your own memory and disk cache for decoded, downsampled images.

Use UserDefaults for small settings, the Keychain for secrets, files for documents and caches, and SwiftData, Core Data or SQLite for structured data you query.

Each managed object context belongs to one queue, so you work inside perform, use the view context only on the main thread, and pass NSManagedObjectID values between contexts instead of objects.

An app moves between not running, inactive, active, background and suspended states, with AppDelegate handling process-level events and SceneDelegate handling each window's UI lifecycle.

The app asks for permission, registers with APNs to get a device token, sends the token to its server, and the server sends a JSON payload to APNs, which delivers it to the device.

Swift Testing uses @Test functions with expect and require macros, parameterized tests and parallel runs by default, while XCTest uses XCTestCase subclasses and XCTAssert functions, and both can live in the same target.

Hide each dependency behind a protocol or closure, inject it, and in tests pass a test double such as a stub that returns fixed data or a spy that records calls.

Stutters are hitches where a frame misses its deadline, usually from main thread work in cell setup, image decoding, layout or offscreen rendering, so you measure with Instruments and move or remove that work.

Store small secrets like tokens in the Keychain with the right accessibility class, protect files with Data Protection, and use the Secure Enclave and biometrics for the most sensitive keys.

Decode a real-looking API response with snake_case keys, ISO 8601 dates, nested and optional fields, and an enum that survives new values.

Build an actor that loads pages for an infinite list, ignores duplicate loads while one is running, and stops at the last page.

A step-by-step plan for the round, with time boxes, what to say at each step, and a worked example.

Design a typed, testable networking layer with endpoints, a middleware chain, single-flight token refresh, safe retries and clear errors.

Build a Kingfisher-style library with a memory and disk cache, shared in-flight requests, downsampling, and safe cancellation in reused cells.

Design a social feed with cursor pagination, prefetching, optimistic likes and an offline cache that opens instantly.

Design 1:1 and group chat with a WebSocket, server-side ordering, delivery states, an offline outbox and push notifications.

Design a notes app that works fully offline and syncs across devices with a local database, a push/pull sync engine and safe conflict resolution.

How to write an iOS resume that gets interviews, with impact bullets, good and bad examples, links and ATS tips.

How to answer "Tell me about a time…" questions with the STAR method, with 10 common questions and short sample answers from iOS work.

How to compare iOS job offers, understand levels, and negotiate politely, with sample email lines.