Netflix Junior Mobile Developer Interview Preparation Guide

import UIKit

final class FrameTimingInstrument {
    // fixed capacity to avoid reallocations on main thread
    private let capacity: Int
    private var timestamps: [Double]        // ring buffer
    private var writeIndex: Int32 = 0       // atomic-ish index
    private let displayLink: CADisplayLink
    private let backgroundQueue = DispatchQueue(label: "frame.timing.bg", qos: .utility)
    private var lastTimestamp: Double = 0

    // reporting
    private let reportInterval: TimeInterval
    private var lastReportTime: TimeInterval = 0
    var onReport: ((Double, Double, Double) -> Void)?

    init(capacity: Int = 3000, reportInterval: TimeInterval = 1.0) {
        self.capacity = capacity
        self.reportInterval = reportInterval
        self.timestamps = Array(repeating: 0, count: capacity)
        self.displayLink = CADisplayLink(target: Proxy(target: self), selector: #selector(Proxy.tick))
        self.displayLink.preferredFramesPerSecond = 0
    }

    func start() {
        self.lastTimestamp = 0
        self.lastReportTime = CACurrentMediaTime()
        displayLink.add(to: .main, forMode: .common)
    }

    func stop() {
        displayLink.invalidate()
    }

    private func pushTimestamp(_ t: Double) {
        // minimal work on main thread: single store and atomic index update
        let idx = Int(OSAtomicIncrement32(&writeIndex) - 1) % capacity
        timestamps[idx] = t
    }

    private func snapshotAndCompute() {
        // capture current write index and copy buffer on background
        let currentCount = Int(max(0, min(Int(atomicLoad(&writeIndex)), capacity)))
        guard currentCount > 1 else { return }

        // copy values out to avoid racing with main thread writes
        backgroundQueue.async {
            var copy = [Double]()
            copy.reserveCapacity(currentCount)
            // read buffer positions safely (some races acceptable; we accept slight inaccuracy)
            let idx = Int(atomicLoad(&self.writeIndex)) % self.capacity
            for i in 0..<currentCount {
                let pos = (idx + i) % self.capacity
                let v = self.timestamps[pos]
                if v > 0 { copy.append(v) }
            }
            // compute frame intervals
            var deltas = [Double]()
            deltas.reserveCapacity(copy.count - 1)
            for i in 1..<copy.count {
                deltas.append((copy[i] - copy[i-1]) * 1000.0) // ms
            }
            guard !deltas.isEmpty else { return }
            deltas.sort()
            func percentile(_ p: Double) -> Double {
                let rank = Int(Double(deltas.count - 1) * p)
                return deltas[max(0, min(deltas.count - 1, rank))]
            }
            let p50 = percentile(0.50)
            let p90 = percentile(0.90)
            let p99 = percentile(0.99)
            self.onReport?(p50, p90, p99)
        }
    }

    @objc private func handleDisplayLink(_ link: CADisplayLink) {
        let t = link.timestamp
        if lastTimestamp > 0 {
            pushTimestamp(t)
        }
        lastTimestamp = t
        let now = CACurrentMediaTime()
        if now - lastReportTime >= reportInterval {
            lastReportTime = now
            snapshotAndCompute()
        }
    }

    // Proxy to avoid CADisplayLink retain cycle
    private class Proxy {
        weak var target: FrameTimingInstrument?
        init(target: FrameTimingInstrument) { self.target = target }
        @objc func tick(_ link: CADisplayLink) { target?.handleDisplayLink(link) }
    }
}

// Simple helpers for atomic load (since Swift lacks direct atomics prior to new atomics)
@inline(__always) func atomicLoad(_ ptr: inout Int32) -> Int32 {
    return OSAtomicAdd32(0, &ptr)
}

POST /v1/orders HTTP/1.1
Host: api.example.com
Content-Type: application/json
Idempotency-Key: 3f9a1a2e-7b4c-4d2f-9a0b-1c2d3e4f5a6b
Authorization: Bearer <token>

{ "items": [...], "amount_cents": 1999, "currency": "USD" }

./gradlew ktlintFormat detekt

swiftformat .
  swiftlint --strict

import java.util.ArrayDeque
import java.util.Queue

class StackWithQueues {
    private val q1: ArrayDeque<Int> = ArrayDeque()
    private val q2: ArrayDeque<Int> = ArrayDeque()

    // push x: enqueue to q2, move all q1 -> q2, swap refs
    fun push(x: Int) {
        q2.add(x)
        while (q1.isNotEmpty()) {
            q2.add(q1.remove())
        }
        // swap q1 and q2
        val tmp = ArrayDeque<Int>()
        tmp.addAll(q1); q1.clear()
        q1.addAll(q2); q2.clear()
    }

    fun pop(): Int? = if (q1.isEmpty()) null else q1.remove()

    fun peek(): Int? = q1.peek()

    fun isEmpty(): Boolean = q1.isEmpty()
}

{
  "schema_version": 2,
  "event_type": "purchase_completed",
  "timestamp": "2026-02-01T12:34:56Z",
  "platform": "iOS",
  "app_version": "1.4.0",
  "pseudonymous_user_id": "user_XXXX_hash",
  "session_id": "sess_abc",
  "event_props": {"product_id":"sku_123","price":9.99}
}