Apple hiring compiler developers for improving Swift / C++ interoperability

Original Article ↗ Hacker News Discussion ↗

Apple’s new role for a compiler frontend engineer highlights its push to deepen interoperability between Swift and C++, enabling gradual migration of large existing C++ codebases (like WebKit and system components) to Swift rather than risky full rewrites. Commenters debate Apple’s long-term goal of replacing most C/C++ with Swift, including in performance‑critical and possibly kernel code, weighing Swift’s safety and evolving performance features (ARC, move‑only types) against C++’s maturity and ABI issues. The job also prompts talk about compensation, on‑site requirements in Cupertino, and how language and tooling choices intersect with Apple’s broader software quality and platform strategy.

Apple’s Strategy: Swift–C++ Interoperability and Migration

  • Many see this hiring as part of Apple’s long-term plan to migrate large C++ codebases (e.g., WebKit, possibly drivers and system components) to Swift incrementally rather than via big rewrites.
  • Interop is framed as a way to write new features in Swift inside existing C++ projects, with bidirectional calling and minimal data copying.
  • Some view it as continuing a trend: Apple once publicly downplayed C++, then embraced it (e.g., Metal C++ APIs), and is now building bridges so Swift can effectively succeed it.

Status of C++ and Other Languages on Apple Platforms

  • Debate over whether C++ is “first class”:
    • One side: C++ is heavily used inside Apple (CoreAudio, daemons, drivers), with stable ABIs and strong tool support via Clang/Xcode.
    • Other side: platform APIs, UI frameworks, and templates default to Swift/Objective‑C; you can’t build full UI apps purely in C++.
  • Objective‑C and Swift are described as “managed” in the sense of having runtimes, ARC, reflection, and dynamic loading, though there is disagreement on terminology.

Performance, Safety, and Language Trade-offs

  • Some criticize C++ for complexity (templates, UB) and argue investment should go to new safer languages (Swift, Rust, etc.).
  • Others argue experts can write safe, high‑performance C++ and that ergonomics and existing code justify it.
  • Concerns are raised about Swift matching C/C++ performance, especially around ARC and reference counting; replies point to ongoing work on move‑only types and value semantics to avoid ARC overhead in critical paths.
  • There is skepticism that language changes alone solve issues like deadlocks or poor algorithms.

Ecosystem and Alternatives (Rust, Kotlin, D)

  • Several suggest Rust for new system software due to safety, noting Apple already uses Rust server‑side (not clearly in shipped client OS binaries).
  • D and Kotlin are cited as examples of languages with existing C++/platform interop; Kotlin is praised for strong multiplatform support, with speculation it may outgrow Swift in general-purpose usage.

Software Quality and Legacy Code

  • Multiple commenters complain about macOS/iOS daemons and apps consuming high CPU, UI freezes, and sluggish operations, attributing problems variously to Objective‑C’s dynamism, Swift-era quality decline, and Apple’s yearly release cadence.
  • Others report few such issues and see quality as workload‑ or data‑size‑dependent (e.g., very large contact lists).

Job Location, Compensation, and Work Practices

  • Role is on-site in Cupertino with visa sponsorship.
  • Commenters note high Bay Area housing costs versus listed base salary; typical estimates for total compensation are ~1.5–2× base, still leaving buying local housing difficult without dual incomes or long commutes.
  • Some criticize Apple’s strict on-site policy and worry FAANG norms drive industry‑wide return‑to‑office trends; others say on‑site versus remote is a valid organizational choice.

Learning Compilers and Niche Skill Value

  • Several resources are recommended for aspiring compiler engineers: online compiler courses, “Crafting Interpreters,” “Modern Compiler Implementation,” LLVM’s Kaleidoscope tutorial, and small C compilers (8cc/chibicc) as study material.
  • There is disagreement about how “niche” and highly paid compiler roles actually are; some report only modest premiums over general software roles.