...
Pregătire interviuri

100 de întrebări de interviu pentru iOS Developer, cu răspunsuri

Întrebările care apar des la interviurile de iOS Developer, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 147 minde citit
Întrebări de interviu iOS Developer cu răspunsuri

Un interviu pentru un post de iOS Developer are de obicei câteva etape: o discuție inițială cu cineva din HR sau cu un recrutor, în care se verifică motivația, disponibilitatea și nivelul de engleză, apoi unul sau două interviuri tehnice. În partea tehnică vei primi întrebări despre Swift (optionals, struct vs class, protocoale, ARC, closures), despre construirea interfeței în SwiftUI și UIKit și despre concurență. Multe companii adaugă o temă de casă (o aplicație mică ce încarcă date dintr-un API și le afișează într-o listă) sau un exercițiu de live coding, urmat de o discuție despre codul tău.

La nivel de junior se urmărește dacă înțelegi bine fundamentele limbajului, dacă știi să construiești un ecran funcțional și dacă poți explica de ce ai ales o soluție. La nivel de mid se așteaptă să stăpânești concurența modernă (async/await, actors), gestionarea memoriei, arhitectura unei aplicații (MVVM, injectarea dependențelor), testarea și procesul de publicare în App Store. Întrebările de senior verifică decizii de design, performanță și capacitatea de a ghida o echipă.

Folosește pagina așa: citește întâi răspunsul scurt și încearcă să formulezi singur explicația cu voce tare, apoi compară cu răspunsul detaliat. Scrie codul din exemple în Xcode sau într-un Playground și modifică-l până înțelegi de ce se comportă așa. Notează-ți întrebările la care te-ai blocat și revino la ele după câteva zile.

Limbajul Swift

1 Junior

Care este diferența dintre let și var în Swift?

Răspuns scurt: let declară o constantă, a cărei valoare nu mai poate fi reasignată după inițializare, iar var declară o variabilă care poate primi alte valori. Recomandarea este să folosești let implicit și var doar când chiar ai nevoie.

let leagă un nume de o valoare o singură dată. Compilatorul refuză orice reasignare, ceea ce face codul mai ușor de urmărit: când vezi let, știi că valoarea nu se schimbă mai jos în funcție. Xcode chiar îți dă un avertisment dacă ai declarat o var pe care nu o modifici niciodată.

Diferența are un efect important asupra tipurilor valoare (struct, enum) și asupra celor referință (class):

SWIFT
struct Point { var x: Int }
final class Box { var value = 0 }

let p = Point(x: 1)
// p.x = 2   // eroare: p este constantă, iar struct-ul e copiat ca întreg

let b = Box()
b.value = 5   // permis: constantă este referința, nu obiectul

La un struct declarat cu let, nici proprietățile lui nu pot fi modificate, pentru că întreaga valoare este imuabilă. La o clasă, let înseamnă doar că variabila nu poate indica spre alt obiect; obiectul în sine poate fi modificat dacă are proprietăți var.

Folosirea predominantă a lui let reduce bugurile cauzate de stare schimbată din greșeală și ajută compilatorul să optimizeze. Este și o premisă pentru cod sigur în concurență, unde datele imuabile pot fi partajate între thread-uri fără riscuri.

Ce urmărește intervievatorul: Verifică dacă știi diferența de comportament dintre let aplicat unui struct și let aplicat unei clase; mulți candidați cred că let face orice obiect complet imuabil.

2 Junior

Ce este un optional în Swift și de ce există?

Răspuns scurt: Un optional (T?) este un tip care poate conține fie o valoare de tipul T, fie nil. Există ca lipsa unei valori să fie explicită în sistemul de tipuri, iar compilatorul să te oblige să tratezi cazul nil.

În multe limbaje, orice referință poate fi null, iar eroarea apare abia la rulare. Swift separă clar tipurile: un String conține mereu un text, iar un String? poate conține un text sau nimic. Nu poți folosi un String? acolo unde se așteaptă String fără să-l despachetezi (unwrap), adică să verifici că are valoare.

Intern, un optional este un enum generic din biblioteca standard:

SWIFT
enum Optional<Wrapped> {
    case none
    case some(Wrapped)
}

let age: Int? = Int("42")     // conversia poate eșua, deci rezultatul e Int?
let missing: Int? = Int("abc") // nil

Funcțiile care pot să nu găsească un rezultat întorc optionals: Int("abc"), array.first, dictionary["cheie"]. Astfel, semnătura funcției îți spune deja că trebuie să tratezi absența valorii.

Beneficiul principal este siguranța: o mare parte din erorile de tip „null pointer” sunt prinse la compilare. Costul este că trebuie să scrii cod de despachetare, dar Swift oferă unelte comode pentru asta: if let, guard let, operatorul ?? și optional chaining (user?.address?.city). Un optional bine folosit documentează intenția: „aici e normal să lipsească o valoare”.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi motivul de design, nu doar sintaxa cu semnul întrebării; un plus este să știi că optional este un enum cu none și some.

3 Junior

Care sunt modurile de a despacheta un optional și când îl folosești pe fiecare?

Răspuns scurt: Poți folosi if let, guard let, operatorul ?? (nil-coalescing), optional chaining (?.) și force unwrap (!). Force unwrap se folosește doar când ești absolut sigur că valoarea există, pentru că pe nil aplicația se oprește cu crash.

Fiecare variantă are un scop diferit:

  • if let execută un bloc doar dacă valoarea există; în Swift 5.7+ poți scrie scurt if let name { ... }.
  • guard let iese devreme din funcție dacă valoarea lipsește, iar variabila despachetată rămâne disponibilă în restul funcției.
  • ?? oferă o valoare implicită: let title = name ?? "Anonim".
  • optional chaining (user?.profile?.avatarURL) continuă un lanț de apeluri doar dacă fiecare pas are valoare; rezultatul final este tot optional.
  • force unwrap (name!) presupune că valoarea există și oprește aplicația dacă nu există.
SWIFT
func greet(_ name: String?) -> String {
    guard let name, !name.isEmpty else { return "Salut, vizitatorule" }
    return "Salut, \(name)"
}

let city = user?.address?.city ?? "Necunoscut"

Regula practică: folosește guard let pentru precondiții la începutul funcției, if let pentru ramuri opționale de logică și ?? pentru valori implicite. Force unwrap este acceptabil în puține situații, de exemplu pentru un URL constant scris de tine, unde un crash ar indica o greșeală de programare. În cod care procesează date din rețea sau de la utilizator, ! este aproape întotdeauna o greșeală. Mai există și implicitly unwrapped optionals (String!), întâlnite la @IBOutlet, care se comportă ca force unwrap la fiecare acces.

Ce urmărește intervievatorul: Se verifică dacă știi alege unealta potrivită și dacă eviți force unwrap; răspunsul „pun ! și merge” este un semnal negativ.

4 Junior

Prin ce diferă guard de if?

Răspuns scurt: guard verifică o condiție și obligă blocul else să iasă din scope (return, throw, break, continue). Variabilele legate cu guard let rămân disponibile după instrucțiune, pe când cele din if let există doar în interiorul blocului.

guard a fost introdus pentru stilul „early exit”: tratezi întâi cazurile invalide, apoi scrii logica principală fără să o îngropi în niveluri de indentare.

SWIFT
func loadProfile(id: String?, token: String?) throws -> Profile {
    guard let id else { throw AppError.missingId }
    guard let token, !token.isEmpty else { throw AppError.notAuthenticated }

    // aici id și token sunt String, nu String?
    return try api.profile(id: id, token: token)
}

Cu if let, același cod ar arăta ca o piramidă de blocuri imbricate, iar valorile despachetate ar fi accesibile doar înăuntrul fiecărui bloc.

Diferențe concrete:

  • blocul else al unui guard este obligatoriu și trebuie să transfere controlul în afara scope-ului; altfel codul nu compilează. Asta garantează că, după guard, condiția este adevărată.
  • variabilele introduse de guard let au scope-ul funcției (sau al buclei) din care face parte.
  • if permite ramuri else if și cod care continuă normal după ambele ramuri.

Folosește guard pentru precondiții și validări la începutul funcției, iar if când ambele ramuri sunt cazuri normale de execuție. În bucle, guard ... else { continue } este o formă clară de a sări peste elemente invalide.

Ce urmărește intervievatorul: Verifică dacă scrii cod lizibil, fără piramide de if-uri, și dacă știi că else-ul unui guard trebuie să iasă din scope.

5 Junior

Ce sunt enum-urile cu associated values și unde le-ai folosi?

Răspuns scurt: Sunt enum-uri în care fiecare caz poate purta date proprii, de tipuri diferite. Sunt ideale pentru a modela stări care se exclud reciproc, de exemplu starea unui ecran: încărcare, conținut sau eroare.

Un enum simplu enumeră valori fixe. Cu associated values, fiecare caz poate avea atașate date, iar compilatorul se asigură că le citești doar când cazul se potrivește:

SWIFT
enum ScreenState {
    case loading
    case loaded([Article])
    case failed(message: String)
}

func render(_ state: ScreenState) {
    switch state {
    case .loading:
        print("Se încarcă...")
    case .loaded(let articles):
        print("\(articles.count) articole")
    case .failed(let message):
        print("Eroare: \(message)")
    }
}

Avantajul față de mai multe proprietăți separate (isLoading: Bool, articles: [Article]?, error: String?) este că stările imposibile nu pot fi reprezentate. Cu proprietăți separate poți ajunge accidental la isLoading == true și error != nil în același timp; cu enum-ul, starea este exact una.

switch în Swift trebuie să fie exhaustiv. Dacă adaugi un caz nou, de exemplu .empty, compilatorul îți arată toate locurile unde trebuie tratat, ceea ce face refactorizarea sigură. Din acest motiv e bine să eviți default: la enum-urile tale.

Alte utilizări frecvente: rezultatul unei operații (Result<Success, Failure> este un astfel de enum), acțiunile dintr-un reducer, rutele de navigare (case detail(id: UUID)) sau tipurile de erori cu context.

Ce urmărește intervievatorul: Intervievatorul caută capacitatea de a modela starea corect; un candidat bun menționează stările imposibile și switch-ul exhaustiv.

6 Junior

Când folosești Array, Set sau Dictionary?

Răspuns scurt: Array păstrează ordinea și permite duplicate, Set stochează elemente unice fără ordine garantată, cu căutare rapidă, iar Dictionary asociază chei unice cu valori. Alegerea depinde de operația cea mai frecventă: parcurgere ordonată, test de apartenență sau acces după cheie.

Toate trei sunt tipuri valoare generice din biblioteca standard, cu semantică de copiere (și copy-on-write, deci copierea efectivă are loc doar la modificare).

  • Array<Element>: elemente ordonate, accesibile prin index. contains are complexitate O(n), pentru că parcurge elementele. Bun pentru liste afișate în UI, unde ordinea contează.
  • Set<Element>: elemente unice, cerința fiind ca Element să fie Hashable. contains, inserarea și ștergerea sunt O(1) în medie. Bun pentru „id-uri deja văzute”, filtre selectate, operații de mulțime (union, intersection, subtracting).
  • Dictionary<Key, Value>: acces după cheie în O(1) mediu; cheia trebuie să fie Hashable. Subscriptul întoarce un optional, pentru că cheia poate lipsi.
SWIFT
let ids = [3, 1, 3, 2]
let unique = Set(ids)                      // {1, 2, 3}, ordinea nu e garantată
var cache: [Int: String] = [:]
cache[1] = "Ana"
let name = cache[7, default: "necunoscut"]
let grouped = Dictionary(grouping: ["ana", "alin", "bogdan"], by: { $0.first! })

O greșeală frecventă este verificarea repetată cu array.contains într-o buclă mare, ceea ce duce la O(n²); transformarea într-un Set rezolvă problema. Altă greșeală este să te bazezi pe ordinea de iterare a unui Set sau Dictionary: aceasta nu este garantată și poate diferi între rulări.

Ce urmărește intervievatorul: Se verifică dacă te gândești la complexitate și la cerința Hashable, nu doar la sintaxă.

7 Junior

Cum funcționează tratarea erorilor în Swift: throws, do/try/catch, try? și try!?

Răspuns scurt: O funcție marcată throws poate arunca o eroare care respectă protocolul Error; apelul se face cu try într-un bloc do/catch. try? transformă rezultatul în optional (nil la eroare), iar try! oprește aplicația dacă apare o eroare.

Erorile în Swift sunt valori care respectă protocolul Error, de obicei enum-uri. O funcție care poate eșua o declari cu throws, iar apelantul este obligat să marcheze apelul cu try, ceea ce face vizibil fiecare punct în care execuția poate fi întreruptă.

SWIFT
enum LoginError: Error {
    case emptyPassword
    case tooShort(min: Int)
}

func validate(_ password: String) throws -> String {
    if password.isEmpty { throw LoginError.emptyPassword }
    if password.count < 8 { throw LoginError.tooShort(min: 8) }
    return password
}

do {
    let ok = try validate("abc")
    print(ok)
} catch LoginError.tooShort(let min) {
    print("Minim \(min) caractere")
} catch {
    print("Altă eroare: \(error)")
}

Variantele scurte:

  • try? întoarce un optional și ignoră detaliile erorii; util când nu te interesează motivul, de exemplu la încercarea de a citi un cache.
  • try! este echivalentul force unwrap: dacă se aruncă eroare, aplicația se oprește. Acceptabil doar unde eroarea este imposibilă în practică, de exemplu la decodarea unui fișier inclus în bundle.

Spre deosebire de excepțiile din alte limbaje, aruncarea unei erori în Swift este un mecanism ieftin, similar cu un return. O funcție poate și să propage eroarea mai departe dacă e la rândul ei throws. Din Swift 6 există și typed throws: throws(LoginError), care precizează exact tipul erorii.

Ce urmărește intervievatorul: Intervievatorul urmărește dacă tratezi erorile explicit și dacă știi riscul lui try!; candidații slabi folosesc try? peste tot și pierd informația despre eroare.

8 Junior

Scrie o funcție care primește o listă de șiruri și întoarce suma numerelor valide din ea, ignorând valorile care nu sunt numere.

Răspuns scurt: Folosești compactMap cu Int.init pentru a converti și a elimina conversiile eșuate, apoi reduce(0, +) pentru sumă. Varianta este scurtă, fără variabile mutabile și ușor de testat.

Soluția idiomatică folosește funcțiile de ordin superior din biblioteca standard:

SWIFT
func sumOfNumbers(_ values: [String]) -> Int {
    values
        .compactMap { Int($0.trimmingCharacters(in: .whitespaces)) }
        .reduce(0, +)
}

print(sumOfNumbers(["10", "abc", " 5", "-3", ""]))   // 12

Ce face fiecare pas:

  • compactMap aplică o transformare care întoarce optional și păstrează doar rezultatele non-nil. Int("abc") este nil, deci elementul dispare.
  • reduce(0, +) pornește de la 0 și adună fiecare element; + este pasat direct ca funcție.

Diferențele dintre funcțiile înrudite sunt des întrebate:

  • map transformă fiecare element și păstrează numărul de elemente (aici ar da [Int?]).
  • compactMap transformă și elimină nil-urile.
  • flatMap aplatizează o colecție de colecții: [[1, 2], [3]] devine [1, 2, 3].
  • filter păstrează elementele care respectă o condiție.

La interviu merită să discuți cazurile limită: lista goală (rezultat 0), spații albe, numere negative, depășirea capacității lui Int (adunarea în Swift oprește aplicația la overflow; pentru valori mari poți folosi addingReportingOverflow). Poți menționa și varianta cu buclă for, perfect validă, dar mai lungă. Pentru colecții foarte mari, values.lazy.compactMap evită crearea unui array intermediar.

Ce urmărește intervievatorul: Se verifică familiaritatea cu map/compactMap/reduce și atenția la cazuri limită; un plus este să explici diferența dintre map, compactMap și flatMap.

9 Junior

Ce afișează codul următor și de ce?

SWIFT
var a = [1, 2, 3]
var b = a
b.append(4)
print(a.count, b.count)

Răspuns scurt: Afișează 3 4. Array este un tip valoare, deci b este o copie independentă a lui a; modificarea lui b nu afectează a.

În Swift, Array, Dictionary, Set și String sunt struct-uri, adică tipuri valoare. Atribuirea var b = a creează, din punct de vedere logic, o copie separată. Când adaugi elementul 4 în b, a rămâne [1, 2, 3].

Dacă ar fi fost o clasă, comportamentul era altul:

SWIFT
final class Bag { var items = [1, 2, 3] }

let x = Bag()
let y = x            // aceeași instanță, două referințe
y.items.append(4)
print(x.items.count) // 4

Întrebarea suplimentară care urmează de obicei: „Nu e scump să copiezi un array mare la fiecare atribuire?”. Răspunsul este copy-on-write: după var b = a, ambele variabile împart același buffer de memorie. Abia când una dintre ele este modificată (append), Swift verifică dacă buffer-ul are mai mulți proprietari și, dacă da, face copia efectivă. Atribuirea în sine este deci ieftină.

Acest comportament face codul mai predictibil: o funcție care primește un array nu poate modifica array-ul apelantului, iar o proprietate expusă ca array nu poate fi modificată din afară prin aliasing. Este unul dintre motivele pentru care Swift încurajează struct-urile pentru modele de date.

Ce urmărește intervievatorul: Verifică înțelegerea semanticii de valoare a colecțiilor; candidații veniți din Java sau JavaScript răspund adesea greșit 4 4.

10 Mid

Ce sunt computed properties, property observers și lazy și când le folosești?

Răspuns scurt: O computed property calculează valoarea la fiecare acces, fără să o stocheze. Property observers (willSet, didSet) rulează cod la schimbarea unei proprietăți stocate, iar lazy amână inițializarea până la primul acces.

Sunt trei mecanisme diferite pentru proprietăți:

SWIFT
struct Cart {
    var items: [Item] = [] {
        didSet { print("Coș modificat: \(oldValue.count) -> \(items.count)") }
    }
    var total: Decimal {                // computed, fără stocare
        items.reduce(0) { $0 + $1.price }
    }
}

final class ReportViewController: UIViewController {
    lazy var formatter: DateFormatter = {
        let f = DateFormatter()
        f.dateStyle = .medium
        return f
    }()
}

Computed properties sunt potrivite pentru valori derivate din alte date. Avantajul este că nu pot ajunge desincronizate. Dezavantajul este că se recalculează la fiecare acces, deci nu pune acolo operații costisitoare apelate des.

willSet și didSet sunt utile pentru efecte secundare mici: actualizarea unui label, salvarea într-un cache, validări. Nu se declanșează în inițializatorul tipului care le declară. Un efect neașteptat: la struct-uri, modificarea unei proprietăți interioare (de exemplu items[0].price = 5) declanșează didSet pentru întreaga proprietate.

lazy este util pentru obiecte costisitoare care s-ar putea să nu fie folosite deloc sau care au nevoie de self la inițializare. Trebuie să fie var. Atenție: inițializarea lazy nu este thread-safe; dacă două thread-uri accesează proprietatea simultan la prima utilizare, inițializatorul poate rula de două ori. Proprietățile static let sunt, în schimb, inițializate leneș și în mod thread-safe.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi mecanismul potrivit și dacă știi capcanele: recalcularea computed properties și lipsa de thread-safety la lazy.

11 Mid

La ce folosesc extensions și ce limitări au?

Răspuns scurt: Extensions adaugă funcționalitate unui tip existent (metode, computed properties, inițializatori, conformări la protocoale), inclusiv tipurilor pe care nu le deții. Nu pot adăuga proprietăți stocate și nu pot suprascrie metode existente.

Prin extension poți extinde orice tip: al tău, din biblioteca standard sau din framework-urile Apple.

SWIFT
extension Date {
    var isWeekend: Bool { Calendar.current.isDateInWeekend(self) }
}

extension Array where Element: Numeric {
    func sum() -> Element { reduce(0, +) }
}

struct User { let name: String; let email: String }

extension User: CustomStringConvertible {
    var description: String { "\(name) <\(email)>" }
}

Utilizări bune:

  • organizarea codului: o extensie separată pentru fiecare protocol implementat (extension ProfileViewController: UITableViewDataSource), ceea ce face fișierul mai ușor de citit.
  • conformări retroactive: faci un tip existent să respecte un protocol al tău.
  • constrângeri generice: metode disponibile doar pentru anumite tipuri de elemente, ca în exemplul sum().
  • inițializatori suplimentari pentru struct-uri, păstrând memberwise initializer-ul generat automat (dacă inițializatorul e definit în extensie, nu în corpul struct-ului).

Limitări:

  • nu poți adăuga proprietăți stocate, pentru că extensia nu poate schimba structura de memorie a tipului. Pentru clase Objective-C existau associated objects, dar sunt rareori o idee bună.
  • nu poți suprascrie metode existente ale tipului.
  • metodele din extensii ale claselor nu pot fi suprascrise în subclase decât dacă sunt @objc.

Un risc este abuzul: extensii pe String sau View cu zeci de metode globale devin greu de descoperit și pot intra în conflict cu nume din alte module.

Ce urmărește intervievatorul: Se verifică dacă știi folosi extensions pentru organizare și cunoști limitarea proprietăților stocate.

12 Mid

Ce este tipul Result și când îl preferi față de throws?

Răspuns scurt: Result<Success, Failure> este un enum cu cazurile .success și .failure, care reprezintă rezultatul unei operații ca valoare. Este util când rezultatul trebuie stocat, transmis sau trimis printr-un callback; în codul sincron sau cu async/await, throws este de obicei mai simplu.

Result a fost adăugat în Swift 5, într-o perioadă în care codul asincron se scria în principal cu completion handlers. Un callback nu poate „arunca” o eroare către apelant, așa că rezultatul trebuia transmis ca valoare:

SWIFT
func fetchUser(id: Int, completion: @escaping (Result<User, NetworkError>) -> Void) {
    // ...
    completion(.failure(.notFound))
}

fetchUser(id: 1) { result in
    switch result {
    case .success(let user): print(user.name)
    case .failure(let error): print(error)
    }
}

Result oferă și transformări: map, flatMap, mapError și get(), care convertește înapoi la stilul throws: let user = try result.get().

Când îl folosești azi:

  • când trebuie să păstrezi rezultatul pentru mai târziu, de exemplu într-o stare de ecran sau într-un cache;
  • când colectezi rezultate multiple, unele reușite, altele nu, fără să te oprești la prima eroare;
  • în API-uri bazate încă pe callback-uri.

Cu Swift Concurrency, o funcție async throws este mai clară decât un callback cu Result, pentru că fluxul de control se citește linear și erorile se propagă automat. Un avantaj istoric al lui Result era tipul precis al erorii; din Swift 6, typed throws (throws(NetworkError)) oferă și el această precizie, deci motivul acesta contează mai puțin.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi contextul istoric și alegi între Result și throws în funcție de caz, nu din obișnuință.

13 Mid

Explică nivelurile de acces din Swift: private, fileprivate, internal, public și open.

Răspuns scurt: private limitează accesul la declarația curentă și extensiile ei din același fișier, fileprivate la fișier, internal (implicit) la modul, public permite folosirea din alte module, iar open permite în plus moștenirea și suprascrierea din alte module.

Controlul accesului în Swift se raportează la două unități: fișierul sursă și modulul (un target din Xcode sau un pachet Swift Package Manager).

  • private: vizibil doar în declarația care îl conține și în extensiile acelei declarații din același fișier (de la Swift 4).
  • fileprivate: vizibil oriunde în același fișier.
  • internal: nivelul implicit, vizibil în tot modulul. Pentru o aplicație cu un singur target, practic totul este vizibil peste tot.
  • public: vizibil din alte module, dar clasele nu pot fi moștenite și metodele nu pot fi suprascrise în afara modulului.
  • open: ca public, plus moștenire și suprascriere din alte module. Se aplică doar claselor și membrilor lor.
SWIFT
public final class APIClient {
    public init(session: URLSession = .shared) { self.session = session }
    private let session: URLSession
    public private(set) var lastRequestDate: Date?
}

private(set) este un model des folosit: proprietatea poate fi citită din afară, dar modificată doar în interior. Este o formă simplă de încapsulare.

De ce contează: când aplicația este împărțită în module (de exemplu pachete SPM pentru networking, design system, feature-uri), nivelurile de acces definesc API-ul public al fiecărui modul. Tot ce nu este public poate fi schimbat fără să afecteze alte module. În plus, private și final ajută compilatorul: știind că o metodă nu poate fi suprascrisă, poate folosi dispatch static în locul celui dinamic. Testele cu @testable import pot accesa membrii internal ai modulului testat, dar nu pe cei private.

Ce urmărește intervievatorul: Se verifică înțelegerea încapsulării și a modulelor; diferența public vs open și private(set) sunt detaliile care deosebesc un candidat atent.

14 Senior

Ce sunt property wrappers și cum ai implementa unul?

Răspuns scurt: Un property wrapper este un tip marcat cu @propertyWrapper care încapsulează logica de stocare a unei proprietăți prin wrappedValue. Îl aplici cu sintaxa @NumeWrapper, iar SwiftUI se bazează pe el pentru @State, @Binding sau @AppStorage.

Property wrappers (Swift 5.1) elimină codul repetitiv din getter-e și setter-e. Compilatorul transformă o proprietate adnotată într-o proprietate stocată ascunsă de tipul wrapper-ului și redirecționează accesul prin wrappedValue.

Exemplu: o valoare care este mereu limitată la un interval.

SWIFT
@propertyWrapper
struct Clamped<Value: Comparable> {
    private var value: Value
    private let range: ClosedRange<Value>

    init(wrappedValue: Value, _ range: ClosedRange<Value>) {
        self.range = range
        self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }

    var wrappedValue: Value {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }
}

struct Player {
    @Clamped(0...100) var health = 120
}

var p = Player()
print(p.health)   // 100

Un wrapper poate expune și projectedValue, accesibil cu prefixul $. Așa obții în SwiftUI un Binding din @State var name scriind $name.

Discuția de nivel senior include limitele: wrapper-ele nu pot fi aplicate oricărei proprietăți (de exemplu nu pe proprietăți computed), compunerea mai multor wrapper-e devine greu de citit, iar un wrapper care ascunde operații costisitoare (scriere pe disc, sincronizare cu lock-uri) face codul mai puțin transparent. Un exemplu clasic de capcană este un wrapper „thread-safe” cu lock: protejează citirea și scrierea individual, dar o operație compusă precum count += 1 rămâne o cursă de date (data race), pentru că citirea și scrierea sunt două accesuri separate.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi mecanismul din spatele SwiftUI și dacă ai simț critic; capcana cu += pe un wrapper cu lock este un detaliu de senior.

Struct, class, protocoale și generics

15 Junior

Care este diferența dintre struct și class în Swift?

Răspuns scurt: Struct-ul este un tip valoare, copiat la atribuire, fără moștenire și fără deinit. Clasa este un tip referință, partajat între variabile, cu moștenire, identitate (===) și memorie gestionată prin ARC.

Diferențele principale:

  • Semantică: un struct se copiază la atribuire sau la transmiterea ca parametru; o clasă transmite o referință spre aceeași instanță.
  • Moștenire: doar clasele pot moșteni. Struct-urile pot în schimb respecta protocoale.
  • Identitate: două referințe la clase pot fi comparate cu === (aceeași instanță). Struct-urile nu au identitate, doar valoare.
  • Memorie: instanțele claselor trăiesc pe heap și sunt gestionate prin ARC (contorizarea referințelor). Struct-urile sunt de obicei stocate direct unde sunt declarate, fără contorizare.
  • Mutabilitate: metodele unui struct care îl modifică trebuie marcate mutating, iar un struct declarat cu let este complet imuabil.
  • Inițializare: struct-urile primesc automat un memberwise initializer; clasele nu.
  • deinit: există doar la clase.
SWIFT
struct Money { var amount: Decimal }
final class Session { var token: String?; deinit { print("închis") } }

Apple recomandă struct-urile ca alegere implicită, iar clasele când ai nevoie de identitate partajată (un obiect care reprezintă o resursă unică: o conexiune, un cache, un view model observat de mai multe ecrane), de moștenire sau de interoperabilitate cu Objective-C și UIKit (UIViewController este clasă).

Struct-urile reduc bugurile cauzate de modificări neașteptate din alt loc al aplicației și sunt mai ușor de folosit sigur între thread-uri.

Ce urmărește intervievatorul: Este întrebarea clasică de deschidere; se urmărește să explici consecințele (copiere, identitate, ARC), nu doar „unul e valoare, celălalt referință”.

16 Junior

De ce trebuie marcate unele metode ale unui struct cu mutating?

Răspuns scurt: Metodele unui struct primesc implicit un self imuabil. Cuvântul mutating anunță că metoda modifică instanța, astfel încât compilatorul să permită apelul doar pe variabile var, nu pe constante let.

Pentru că struct-urile sunt tipuri valoare, modificarea unei proprietăți înseamnă, conceptual, înlocuirea întregii valori. Swift face această modificare explicită:

SWIFT
struct Counter {
    private(set) var value = 0

    mutating func increment() {
        value += 1
    }

    func doubled() -> Counter {       // nu modifică, întoarce o valoare nouă
        Counter(value: value * 2)
    }
}

var c = Counter()
c.increment()          // OK

let fixed = Counter()
// fixed.increment()   // eroare: fixed este constantă

Într-o metodă mutating, self este tratat ca un parametru inout: poți modifica proprietățile sau chiar atribui self = Counter().

De ce e util: semnătura metodei îți spune dacă apelul schimbă valoarea, iar compilatorul împiedică modificarea constantelor. La clase nu există mutating, pentru că o metodă poate modifica obiectul chiar dacă referința e let.

Biblioteca standard folosește adesea perechi de metode: o variantă mutating la imperativ și una nemutantă la participiu, de exemplu sort() și sorted(), append(_:) și appending(_:) la unele tipuri, reverse() și reversed(). Același stil de denumire este recomandat de API Design Guidelines pentru codul tău.

Protocolul care trebuie să poată fi implementat de struct-uri și declară o metodă ce modifică starea o marchează tot cu mutating; o clasă care implementează protocolul nu scrie mutating.

Ce urmărește intervievatorul: Verifică înțelegerea semanticii de valoare; o întrebare-capcană ulterioară este de ce mutating nu există la clase.

17 Junior

Ce este un protocol în Swift și cum diferă de o clasă de bază?

Răspuns scurt: Un protocol definește un contract: metode, proprietăți și cerințe pe care un tip promite să le implementeze. Spre deosebire de o clasă de bază, poate fi adoptat de struct-uri, enum-uri și clase, iar un tip poate adopta oricâte protocoale.

Un protocol descrie ce trebuie să poată face un tip, fără să impună cum:

SWIFT
protocol Shape {
    var area: Double { get }
    func describe() -> String
}

struct Circle: Shape {
    let radius: Double
    var area: Double { .pi * radius * radius }
    func describe() -> String { "Cerc cu aria \(area)" }
}

struct Square: Shape {
    let side: Double
    var area: Double { side * side }
    func describe() -> String { "Pătrat cu aria \(area)" }
}

let shapes: [any Shape] = [Circle(radius: 1), Square(side: 2)]
shapes.forEach { print($0.describe()) }

Diferențe față de moștenirea dintr-o clasă:

  • o clasă poate avea o singură superclasă, dar un tip poate adopta multe protocoale (Codable, Hashable, Identifiable simultan).
  • protocoalele funcționează și pentru tipuri valoare.
  • protocolul nu impune stare stocată; fiecare tip decide cum stochează datele.
  • prin extensii de protocol poți oferi implementări implicite, deci obții reutilizare fără ierarhii adânci.

Apple descrie această abordare drept Protocol-Oriented Programming. În practică, protocoalele sunt fundamentul testabilității: dacă un view model depinde de protocol UserService în loc de o clasă concretă, în teste îi poți da o implementare falsă. Tot pe protocoale se bazează și pattern-ul delegate din UIKit (UITableViewDelegate).

{ get } cere doar citire (poate fi implementată ca let sau computed), iar { get set } cere și scriere.

Ce urmărește intervievatorul: Se urmărește dacă înțelegi protocoalele ca alternativă la moștenire și legătura lor cu testarea.

18 Junior

Ce sunt extensiile de protocol și implementările implicite?

Răspuns scurt: Printr-o extensie de protocol poți scrie implementarea unei metode o singură dată, iar toate tipurile care adoptă protocolul o primesc automat. Un tip poate înlocui implementarea implicită cu una proprie dacă metoda este o cerință a protocolului.

Extensiile de protocol permit reutilizarea codului fără moștenire:

SWIFT
protocol Greeter {
    var name: String { get }
    func greet() -> String
}

extension Greeter {
    func greet() -> String { "Salut, \(name)!" }
}

struct Student: Greeter { let name: String }
struct Robot: Greeter {
    let name: String
    func greet() -> String { "BIP. \(name) activ." }
}

print(Student(name: "Ana").greet())   // Salut, Ana!
print(Robot(name: "R2").greet())      // BIP. R2 activ.

Student nu scrie nimic în plus și primește comportamentul implicit; Robot îl personalizează.

Poți restrânge extensia cu where, astfel încât metoda să existe doar pentru anumite tipuri:

SWIFT
extension Collection where Element: Equatable {
    func countOccurrences(of item: Element) -> Int {
        filter { $0 == item }.count
    }
}

Biblioteca standard este construită masiv astfel: metode precum map, filter sau contains sunt implementate o singură dată în extensii ale lui Sequence și Collection și sunt disponibile pentru Array, Set, String și orice colecție proprie.

O nuanță importantă (des întrebată la mid/senior): dacă o metodă există doar în extensie, fără să fie declarată în protocol, ea este apelată prin dispatch static. Asta înseamnă că implementarea proprie a unui tip poate fi ignorată când valoarea este folosită prin tipul protocolului. Pentru comportament polimorfic, declară metoda în corpul protocolului.

Ce urmărește intervievatorul: Verifică înțelegerea reutilizării prin protocoale; menționarea capcanei de dispatch static arată experiență.

19 Junior

Ce fac protocoalele Equatable, Hashable și Codable?

Răspuns scurt: Equatable permite compararea cu ==, Hashable permite folosirea în Set și ca cheie de Dictionary, iar Codable (Encodable și Decodable) permite conversia în și din formate precum JSON. Pentru struct-uri, compilatorul le poate genera automat.

Sunt trei protocoale pe care le vei adopta aproape în fiecare model:

SWIFT
struct Product: Codable, Hashable, Identifiable {
    let id: Int
    let title: String
    let price: Double
    let imageURL: URL?

    enum CodingKeys: String, CodingKey {
        case id, title, price
        case imageURL = "image_url"
    }
}

let json = #"{"id":1,"title":"Cană","price":29.9,"image_url":null}"#.data(using: .utf8)!
let product = try JSONDecoder().decode(Product.self, from: json)
  • Equatable: compilatorul sintetizează == dacă toate proprietățile sunt Equatable. SwiftUI și testele se bazează pe el (XCTAssertEqual).
  • Hashable: extinde Equatable cu hash(into:). Regula obligatorie: două valori egale trebuie să aibă același hash. Dacă scrii manual == comparând doar id, trebuie să faci același lucru în hash(into:).
  • Codable: compilatorul generează codul de serializare dacă toate proprietățile sunt Codable. CodingKeys permite redenumirea câmpurilor; alternativ, decoder.keyDecodingStrategy = .convertFromSnakeCase. Pentru date, setezi dateDecodingStrategy (de exemplu .iso8601).

Detalii utile la interviu: proprietățile optionale lipsă din JSON devin nil fără eroare, dar o proprietate non-optional lipsă aruncă DecodingError.keyNotFound. Pentru structuri neobișnuite (un câmp care poate fi uneori text, alteori număr) implementezi manual init(from decoder:). Erorile de decodare conțin codingPath, foarte util la depanare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți lucra zilnic cu date din API-uri; regula hash/egalitate și CodingKeys sunt detaliile importante.

20 Junior

Care este diferența dintre un designated initializer și un convenience initializer la clase?

Răspuns scurt: Un designated initializer inițializează complet toate proprietățile clasei și apelează inițializatorul superclasei. Un convenience initializer este secundar și trebuie să delege, în final, către un designated initializer din aceeași clasă.

Clasele au reguli stricte de inițializare, pentru că trebuie să garanteze că și proprietățile moștenite sunt inițializate. Swift folosește un proces în două faze: întâi toate proprietățile primesc valori (de jos în sus, din subclasă spre superclasă), apoi se poate folosi self liber.

SWIFT
class Vehicle {
    let wheels: Int
    init(wheels: Int) { self.wheels = wheels }        // designated
}

class Car: Vehicle {
    let brand: String

    init(brand: String) {                             // designated
        self.brand = brand          // 1. propriile proprietăți
        super.init(wheels: 4)       // 2. apoi superclasa
    }

    convenience init() {                              // convenience
        self.init(brand: "Necunoscut")
    }
}

Regulile pe scurt:

  • un designated initializer trebuie să apeleze un designated initializer al superclasei directe;
  • un convenience initializer trebuie să apeleze alt inițializator al aceleiași clase;
  • nu poți accesa self (metode, proprietăți) înainte ca toate proprietățile stocate să fie inițializate.

Alte variante: required init obligă subclasele să implementeze inițializatorul (de aici vine required init?(coder:) în subclasele de UIView), iar init? este un failable initializer care poate întoarce nil.

Struct-urile sunt mai simple: nu au moștenire, deci nici distincția designated/convenience. Primesc automat un memberwise initializer, care dispare dacă scrii propriul init în corpul struct-ului (dar rămâne dacă îl scrii într-o extensie).

Ce urmărește intervievatorul: Verifică înțelegerea inițializării în două faze; întrebarea apare des legată de required init?(coder:) din UIKit.

21 Junior

Care este diferența dintre as, as?, as! și is?

Răspuns scurt: is verifică dacă o valoare este de un anumit tip, as? încearcă o conversie și întoarce optional, as! forțează conversia și oprește aplicația dacă eșuează, iar as simplu face conversii garantate la compilare, de exemplu spre o superclasă sau un protocol.

Type casting apare des când lucrezi cu tipuri generale (Any, superclase, protocoale) și vrei tipul concret înapoi.

SWIFT
class Animal {}
class Dog: Animal { func bark() { print("Ham") } }

let pets: [Animal] = [Dog(), Animal()]

for pet in pets {
    if pet is Dog { print("e câine") }

    if let dog = pet as? Dog {      // downcast sigur
        dog.bark()
    }
}

let general = Dog() as Animal        // upcast, mereu reușește
let value: Any = 42
let number = value as! Int           // merge, dar ar da crash dacă nu era Int

Pe scurt:

  • as (upcast sau conversie garantată): compilatorul știe că reușește. Se folosește și pentru conversii între tipuri bridged, de exemplu String spre NSString.
  • as? (downcast condițional): rezultatul este optional, se combină natural cu if let și guard let.
  • as! (downcast forțat): echivalent cu force unwrap; la eșec, aplicația se oprește.
  • is: întoarce Bool, fără să convertească.

În UIKit vei vedea des as! la reutilizarea celulelor: tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath) as! ProductCell. Aici crash-ul ar semnala o greșeală de configurare (identificator sau clasă greșită), deci mulți îl acceptă, deși o variantă cu guard let ... as? ... else { fatalError("mesaj clar") } produce un mesaj mai util.

Dacă ai nevoie de multe cast-uri, este adesea un semn că designul ar beneficia de generics sau de un protocol cu metoda comună, astfel încât să nu mai fie nevoie să afli tipul concret.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre conversia sigură și cea forțată și dacă recunoști că multe cast-uri indică o problemă de design.

22 Mid

Scrie o funcție generică ce întoarce elementul maxim după o anumită proprietate și explică constrângerile generice.

Răspuns scurt: Folosești un parametru generic de colecție și un key path spre o proprietate Comparable. Constrângerile (where, T: Protocol) spun compilatorului ce operații sunt permise pe tipul generic, fără să pierzi siguranța tipurilor.

Generics permit scrierea unui singur cod pentru mai multe tipuri, cu verificare la compilare:

SWIFT
func maxElement<C: Collection, V: Comparable>(
    in items: C,
    by keyPath: KeyPath<C.Element, V>
) -> C.Element? {
    items.max { $0[keyPath: keyPath] < $1[keyPath: keyPath] }
}

struct Employee { let name: String; let salary: Int }

let team = [Employee(name: "Ana", salary: 7000), Employee(name: "Dan", salary: 9000)]
print(maxElement(in: team, by: \.salary)?.name ?? "-")   // Dan

Ce înseamnă constrângerile:

  • C: Collection permite să apelezi max și să folosești C.Element;
  • V: Comparable permite operatorul <;
  • fără ele, compilatorul nu ar ști că tipurile suportă aceste operații.

Constrângerile pot fi scrise și cu where, util când sunt multe sau implică tipuri asociate: func merge<A: Sequence, B: Sequence>(_ a: A, _ b: B) -> [A.Element] where A.Element == B.Element.

De ce generics în loc de Any sau protocoale existențiale: tipul concret este păstrat, nu ai nevoie de cast-uri, iar compilatorul poate genera cod specializat pentru fiecare tip folosit, deci performanța este bună.

Rezultatul este optional pentru că o colecție goală nu are maxim. Ca discuție suplimentară: pentru egalitate, max(by:) întoarce ultimul element maxim găsit, comportament care contează dacă ai mai mulți angajați cu același salariu.

Ce urmărește intervievatorul: Se verifică dacă știi scrie cod generic cu constrângeri corecte; folosirea key path-urilor arată familiaritate cu Swift modern.

23 Mid

Ce este copy-on-write și cum l-ai implementa pentru un tip propriu?

Răspuns scurt: Copy-on-write înseamnă că mai multe copii ale unei valori împart același buffer până când una dintre ele este modificată; abia atunci se face copia reală. Colecțiile standard îl au deja, iar pentru tipurile proprii îl implementezi cu o clasă internă și isKnownUniquelyReferenced.

Fără copy-on-write, transmiterea unui array mare ca parametru ar însemna copierea tuturor elementelor. Cu copy-on-write, copierea efectivă are loc doar dacă o copie partajată este modificată.

Pentru un struct propriu care conține date mari, mecanismul nu apare automat. Dacă struct-ul conține o clasă, copiile struct-ului vor împărți aceeași instanță, ceea ce strică semantica de valoare. Soluția:

SWIFT
final class Storage {
    var pixels: [UInt8]
    init(pixels: [UInt8]) { self.pixels = pixels }
}

struct Image {
    private var storage: Storage

    init(pixels: [UInt8]) { storage = Storage(pixels: pixels) }

    var pixels: [UInt8] { storage.pixels }

    mutating func setPixel(_ value: UInt8, at index: Int) {
        if !isKnownUniquelyReferenced(&storage) {
            storage = Storage(pixels: storage.pixels)   // copie doar la nevoie
        }
        storage.pixels[index] = value
    }
}

isKnownUniquelyReferenced întoarce true dacă există o singură referință puternică la obiect; în acest caz modificarea este sigură, pentru că nimeni altcineva nu o vede.

Nuanțe utile la interviu:

  • exemplul de mai sus are deja un [UInt8] care face el însuși copy-on-write; tehnica merită când stocarea internă nu este o colecție standard sau când grupezi multe proprietăți.
  • copy-on-write nu face tipul thread-safe; dacă aceeași variabilă este modificată din două thread-uri, ai tot o cursă de date.
  • capcană de performanță: dacă păstrezi o copie suplimentară a array-ului (de exemplu într-o variabilă temporară) înainte de o buclă de modificări, fiecare modificare poate declanșa copii complete.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi cum sunt implementate tipurile valoare eficiente și dacă știi pericolul unei clase ascunse într-un struct.

24 Mid

Ce este un associatedtype într-un protocol și ce problemă creează?

Răspuns scurt: Un associatedtype este un tip substituent pe care fiecare tip ce adoptă protocolul îl precizează, similar unui parametru generic. Protocolul devine astfel mai flexibil, dar folosirea lui ca tip al unei variabile necesită any sau some, iar colecțiile eterogene devin mai greu de construit.

Protocoalele nu pot avea parametri generici în stilul Protocol<T> la declarare. În schimb declară tipuri asociate:

SWIFT
protocol Repository {
    associatedtype Item: Identifiable
    func fetchAll() async throws -> [Item]
    func save(_ item: Item) async throws
}

struct Note: Identifiable { let id: UUID; var text: String }

struct NoteRepository: Repository {
    func fetchAll() async throws -> [Note] { [] }
    func save(_ item: Note) async throws { }
}

Compilatorul deduce Item == Note din semnături. Biblioteca standard folosește peste tot acest mecanism: Sequence are Element și Iterator, Collection are Index.

Problema: o variabilă de tipul protocolului nu știe ce Item conține. Până la Swift 5.7, un protocol cu associatedtype nu putea fi folosit deloc ca tip („can only be used as a generic constraint”). Azi ai opțiuni:

  • generics: func sync<R: Repository>(_ repo: R), cu tipul concret cunoscut la compilare;
  • some Repository: tip opac, concret dar ascuns;
  • any Repository: existențial, dar metodele care folosesc Item în poziții de parametru sunt greu de apelat;
  • primary associated types (Swift 5.7): protocol Repository<Item>, care permite scrierea any Repository<Note>.

Alegerea corectă depinde de context. Pentru dependențe injectate într-un view model, de multe ori un protocol simplu, fără associatedtype, este mai practic decât unul generic foarte abstract.

Ce urmărește intervievatorul: Se verifică experiența reală cu protocoale generice și cu eroarea clasică de compilare; menționarea primary associated types arată cunoștințe la zi.

25 Mid

Care este diferența dintre some Protocol și any Protocol?

Răspuns scurt: some reprezintă un tip opac: un singur tip concret, cunoscut de compilator dar ascuns apelantului. any reprezintă un existențial: o „cutie” care poate conține orice tip ce respectă protocolul, cu cost de indirectare și cu dispatch dinamic.

Ambele cuvinte cheie spun „un tip care respectă protocolul”, dar cu garanții diferite.

some (Swift 5.1 pentru tipuri de return, 5.7 și pentru parametri):

SWIFT
var body: some View {
    VStack { Text("Salut") }
}

Funcția întoarce întotdeauna același tip concret, doar că nu îl scrii explicit. Compilatorul îl cunoaște, deci poate optimiza și poate păstra informația de tip. Asta explică eroarea din SwiftUI când întorci Text pe o ramură și Image pe alta: sunt două tipuri diferite. Soluțiile sunt @ViewBuilder sau Group, care produc un tip comun.

any (obligatoriu explicit din Swift 6 pentru protocoale cu associatedtype):

SWIFT
let shapes: [any Shape] = [Circle(radius: 1), Square(side: 2)]

Aici fiecare element poate avea alt tip concret. Valoarea este stocată într-un container existențial: valorile mici încap direct, cele mari sunt alocate pe heap, iar apelurile trec printr-un tabel de metode (witness table).

Când alegi:

  • some sau generics când ai un singur tip concret pe apel și vrei performanță și informație de tip completă;
  • any când chiar ai nevoie de eterogenitate: colecții mixte, dependențe care se schimbă la rulare.

Un parametru some Shape este echivalent cu o funcție generică <S: Shape>(_ s: S). Introducerea lui any explicit a avut scopul de a face vizibil costul existențialelor, pe care înainte îl plăteai implicit.

Ce urmărește intervievatorul: Întrebare frecventă după apariția SwiftUI; se verifică dacă înțelegi diferența de tip, nu doar sintaxa, și eroarea clasică cu ramuri diferite în body.

26 Senior

Ce afișează codul și de ce?

SWIFT
protocol Speaker { func intro() -> String }
extension Speaker {
    func intro() -> String { "protocol" }
    func outro() -> String { "protocol" }
}
struct Bot: Speaker {
    func intro() -> String { "bot" }
    func outro() -> String { "bot" }
}
let s: any Speaker = Bot()
print(s.intro(), s.outro())

Răspuns scurt: Afișează bot protocol. intro() este cerință a protocolului, deci se apelează dinamic implementarea lui Bot; outro() există doar în extensie, așa că, prin tipul Speaker, se apelează static implementarea din extensie.

Diferența ține de modul în care Swift alege implementarea (dispatch).

Metodele declarate în corpul protocolului sunt cerințe. Fiecare tip care adoptă protocolul are un witness table, un tabel care indică implementarea concretă. Când apelezi s.intro() pe o valoare de tip any Speaker, Swift caută în tabel și găsește versiunea lui Bot.

Metodele care apar doar în extensia protocolului nu sunt în witness table. Compilatorul decide la compilare, după tipul static al expresiei. Tipul static al lui s este any Speaker, deci se apelează outro() din extensie, chiar dacă Bot are propria metodă cu același nume.

SWIFT
let b = Bot()
print(b.outro())          // "bot": tipul static este Bot
print((b as any Speaker).outro())  // "protocol"

De ce contează în proiecte reale: poți scrie un tip care „suprascrie” o metodă de protocol, iar în teste totul pare corect când lucrezi cu tipul concret; în producție, când obiectul ajunge într-o colecție [any Speaker] sau într-o funcție generică, comportamentul se schimbă fără niciun avertisment.

Regula de design: dacă vrei ca tipurile să poată personaliza comportamentul, declară metoda în protocol și oferă implementarea implicită în extensie. Metodele care sunt doar utilitare, fără intenție de personalizare, pot rămâne numai în extensie. Același fenomen apare și în funcțiile generice <T: Speaker>, unde metoda din extensie este aleasă după constrângere, nu după tipul concret.

Ce urmărește intervievatorul: Este o întrebare de senior despre static vs dynamic dispatch; se verifică dacă înțelegi witness tables, nu doar dacă ai ghicit rezultatul.

27 Senior

Ce este type erasure și când ai nevoie de el?

Răspuns scurt: Type erasure ascunde tipul concret al unei valori în spatele unui tip înfășurător (de exemplu AnyPublisher, AnyView, AnyHashable), ca valori de tipuri diferite cu același protocol să fie tratate uniform. Azi, any cu primary associated types acoperă multe din aceste cazuri.

Problema apare la protocoalele cu associatedtype sau cu cerințe Self. Înainte de Swift 5.7, nu puteai scrie var publisher: Publisher și nici [Hashable]. Soluția era un tip concret care înfășoară orice implementare:

SWIFT
protocol DataLoader<Output> {
    associatedtype Output
    func load() async throws -> Output
}

struct AnyDataLoader<Output>: DataLoader {
    private let _load: () async throws -> Output

    init<L: DataLoader>(_ loader: L) where L.Output == Output {
        _load = loader.load
    }

    func load() async throws -> Output { try await _load() }
}

struct RemoteUsers: DataLoader { func load() async throws -> [String] { ["Ana"] } }
struct CachedUsers: DataLoader { func load() async throws -> [String] { [] } }

let loaders = [AnyDataLoader(RemoteUsers()), AnyDataLoader(CachedUsers())]

Tehnica stochează închiderile (closures) care apelează metodele tipului original; tipul concret dispare din semnătură.

Unde îl întâlnești: AnyPublisher în Combine (prin eraseToAnyPublisher(), ca să nu expui lanțuri lungi de tipuri), AnyView în SwiftUI, AnyHashable, AnySequence.

Ca senior, merită discutat costul. AnyView în SwiftUI ascunde structura ierarhiei de view-uri, iar sistemul de diferențiere poate trata conținutul ca fiind complet nou, cu impact asupra animațiilor și performanței; @ViewBuilder sau Group sunt de obicei preferabile. În cod nou, any DataLoader<[String]> (Swift 5.7+) elimină nevoia unui înfășurător scris de mână. Type erasure manual rămâne util când vrei să adaugi comportament (logging, caching) sau când suporți versiuni mai vechi de compilator.

Ce urmărește intervievatorul: Verifică dacă înțelegi limitele sistemului de tipuri și costul abstracțiilor; un candidat bun menționează AnyView ca exemplu de folosire riscantă.

Memorie, ARC și closures

28 Junior

Ce este ARC și cum gestionează Swift memoria?

Răspuns scurt: ARC (Automatic Reference Counting) numără câte referințe puternice indică spre fiecare instanță de clasă. Când numărul ajunge la zero, instanța este eliberată imediat și se apelează deinit. Spre deosebire de un garbage collector, nu există o etapă separată de colectare.

ARC se aplică doar tipurilor referință (clase, actori, closures). Struct-urile și enum-urile nu sunt contorizate, pentru că sunt copiate.

Compilatorul inserează automat operații de incrementare (retain) și decrementare (release) a contorului acolo unde o referință este creată sau dispare:

SWIFT
final class Session {
    let user: String
    init(user: String) { self.user = user; print("creat") }
    deinit { print("eliberat \(user)") }
}

var a: Session? = Session(user: "ana")  // contor 1
var b = a                               // contor 2
a = nil                                 // contor 1
b = nil                                 // contor 0 -> "eliberat ana"

Diferențe față de garbage collection (Java, C#):

  • eliberarea este deterministă: se întâmplă exact când dispare ultima referință, nu la un moment ales de runtime;
  • nu există pauze de colectare, ceea ce ajută la fluiditatea interfeței;
  • în schimb, ARC nu detectează ciclurile: dacă două obiecte se referă reciproc puternic, contoarele nu ajung niciodată la zero și obiectele rămân în memorie (memory leak).

Din cauza ciclurilor există referințele weak și unowned, care nu cresc contorul. Responsabilitatea de a le folosi corect îi revine programatorului.

Operațiile de retain/release sunt atomice, deci au un cost mic, dar real. Acesta este unul dintre motivele pentru care struct-urile și final class pot fi mai rapide. Contorul de referințe nu trebuie consultat manual și nu există un API public potrivit pentru logica aplicației.

Ce urmărește intervievatorul: Întrebare de bază pentru orice iOS developer; se urmărește diferența față de garbage collection și faptul că ARC nu rezolvă ciclurile.

29 Junior

Care este diferența dintre referințele strong, weak și unowned?

Răspuns scurt: O referință strong (implicită) crește contorul ARC și ține obiectul în viață. weak nu îl ține în viață, este mereu optional și devine nil automat la eliberarea obiectului. unowned nu îl ține în viață, dar presupune că obiectul există; accesul după eliberare oprește aplicația.

Alegerea tipului de referință descrie relația de proprietate dintre obiecte.

  • strong: „eu dețin acest obiect”. Orice var sau let obișnuită de tip clasă este strong.
  • weak: „am nevoie de obiect, dar nu îl dețin, iar el poate dispărea înaintea mea”. Trebuie să fie var și optional. Exemplul clasic este delegate-ul: weak var delegate: ListDelegate?.
  • unowned: „nu dețin obiectul, dar el trăiește garantat cel puțin cât mine”. Nu este optional, deci codul e mai simplu, dar o greșeală de presupunere produce crash.
SWIFT
final class Customer {
    var card: CreditCard?
    deinit { print("client eliberat") }
}

final class CreditCard {
    unowned let owner: Customer       // un card nu există fără client
    init(owner: Customer) { self.owner = owner }
    deinit { print("card eliberat") }
}

var c: Customer? = Customer()
c!.card = CreditCard(owner: c!)
c = nil   // ambele sunt eliberate, nu există ciclu

Dacă owner ar fi fost strong, clientul ar ține cardul și cardul ar ține clientul: ciclu de referințe, deci niciunul nu ar mai fi eliberat.

Regula practică: folosește weak ori de câte ori nu ești sigur de durata de viață. unowned merită doar când relația este clară și stabilă (copilul nu poate exista fără părinte). Atenție și la IBOutlet: Xcode le generează adesea weak, pentru că view-urile sunt deja deținute de ierarhia de view-uri.

Ce urmărește intervievatorul: Se verifică înțelegerea relațiilor de proprietate; un răspuns bun explică riscul de crash la unowned și de ce delegate-ul este weak.

30 Junior

Ce este un retain cycle? Dă un exemplu și arată cum îl rezolvi.

Răspuns scurt: Un retain cycle apare când două sau mai multe obiecte se țin reciproc prin referințe puternice, astfel încât contoarele ARC nu ajung niciodată la zero. Obiectele rămân în memorie chiar dacă nu mai sunt folosite. Se rezolvă făcând una dintre referințe weak sau unowned.

Cel mai simplu exemplu este o relație părinte-copil în care ambele părți folosesc referințe puternice:

SWIFT
final class Teacher {
    var students: [Student] = []
    deinit { print("profesor eliberat") }
}

final class Student {
    var teacher: Teacher?          // strong: problema
    deinit { print("student eliberat") }
}

var t: Teacher? = Teacher()
var s: Student? = Student()
t!.students.append(s!)
s!.teacher = t
t = nil
s = nil      // nu se afișează nimic: obiectele au rămas în memorie

După t = nil și s = nil, nu mai există nicio variabilă care să indice spre obiecte, dar ele se țin unul pe altul. Rezolvarea este să declari weak var teacher: Teacher? în Student. Copilul nu deține părintele, deci referința lui nu contează pentru ARC.

Cele mai frecvente surse de cicluri într-o aplicație iOS:

  • delegate declarat strong;
  • closures stocate ca proprietate, care capturează self (de exemplu un callback onTap sau un handler de rețea păstrat de obiect);
  • Timer programat cu target self;
  • observatori NotificationCenter bazați pe closures, păstrați de obiectul care este capturat.

Simptomul tipic: deinit nu se apelează când închizi un ecran, iar memoria aplicației crește la fiecare deschidere a ecranului. Un truc simplu de depanare este să pui un print în deinit la view controllers și view models și să verifici că apare la ieșirea din ecran.

Ce urmărește intervievatorul: Intervievatorul vrea un exemplu concret și sursele reale de cicluri din aplicații, nu doar definiția.

31 Junior

Ce este un closure și cum arată sintaxa trailing closure?

Răspuns scurt: Un closure este un bloc de cod care poate fi stocat într-o variabilă și transmis ca parametru, și care capturează valorile din contextul în care a fost creat. Dacă ultimul parametru al unei funcții este un closure, îl poți scrie după paranteze (trailing closure).

Funcțiile sunt în Swift tot closures, cu nume. Closure-urile anonime se scriu între acolade:

SWIFT
let square: (Int) -> Int = { number in
    number * number
}
print(square(4))   // 16

let names = ["Radu", "ana", "Bogdan"]

// forma completă
let sorted1 = names.sorted(by: { (a: String, b: String) -> Bool in
    return a.lowercased() < b.lowercased()
})

// trailing closure, tipuri deduse, parametri prescurtați, return implicit
let sorted2 = names.sorted { $0.lowercased() < $1.lowercased() }

Simplificările permise:

  • tipurile parametrilor și al rezultatului sunt deduse din context;
  • un closure cu o singură expresie întoarce implicit valoarea ei;
  • $0, $1 sunt nume prescurtate pentru parametri;
  • trailing closure: dacă e ultimul argument, îl scrii după paranteze; dacă e singurul, parantezele pot lipsi complet. Swift 5.3 a adăugat multiple trailing closures, folosite des în SwiftUI: Button { save() } label: { Text("Salvează") }.

Capturarea este proprietatea esențială: un closure poate folosi variabile din jur chiar după ce funcția care le-a definit s-a terminat.

SWIFT
func makeCounter() -> () -> Int {
    var count = 0
    return { count += 1; return count }
}
let next = makeCounter()
print(next(), next())   // 1 2

Closure-urile sunt tipuri referință, deci capturarea lui self într-un closure stocat poate crea retain cycle-uri. Pentru claritate, evită $0 în closure-uri lungi și numește parametrii.

Ce urmărește intervievatorul: Se verifică familiaritatea cu sintaxa, folosită peste tot în SwiftUI și în API-urile Apple, și înțelegerea capturării.

32 Junior

Care este diferența dintre un closure @escaping și unul non-escaping?

Răspuns scurt: Un closure non-escaping (implicit pentru parametri) este folosit doar în timpul execuției funcției și nu poate fi păstrat după ce aceasta se termină. Unul @escaping poate fi stocat sau apelat mai târziu, de exemplu după terminarea unei cereri de rețea.

Din Swift 3, parametrii de tip closure sunt non-escaping implicit. Compilatorul garantează că acel closure nu iese din funcție, ceea ce permite optimizări și te scutește de grija ciclurilor de referință.

SWIFT
// non-escaping: closure-ul rulează imediat, în timpul funcției
func repeatTwice(_ action: () -> Void) {
    action()
    action()
}

final class Downloader {
    private var handlers: [(Data) -> Void] = []

    // escaping: closure-ul este stocat și apelat mai târziu
    func onFinish(_ handler: @escaping (Data) -> Void) {
        handlers.append(handler)
    }

    func load(url: URL, completion: @escaping (Result<Data, Error>) -> Void) {
        URLSession.shared.dataTask(with: url) { data, _, error in
            if let data { completion(.success(data)) }
            else { completion(.failure(error ?? URLError(.unknown))) }
        }.resume()
    }
}

Consecințe practice:

  • într-un closure @escaping care face parte dintr-o clasă, compilatorul cere să scrii explicit self. (sau să folosești o listă de captură). Este un semnal vizual că self este capturat și ar putea apărea un ciclu.
  • closure-urile non-escaping nu au nevoie de [weak self], pentru că dispar odată cu funcția: array.map { self.format($0) } este în regulă.
  • un closure optional ((() -> Void)?) este considerat implicit escaping, pentru că este înfășurat într-un optional.

Dacă încerci să stochezi un closure non-escaping într-o proprietate, primești eroare de compilare, ceea ce te forțează să decizi conștient.

Ce urmărește intervievatorul: Intervievatorul verifică legătura dintre escaping și gestionarea memoriei; o greșeală tipică este adăugarea [weak self] peste tot, inclusiv în map.

33 Mid

Când este necesar [weak self] într-un closure și când nu?

Răspuns scurt: Este necesar când closure-ul este păstrat, direct sau indirect, de obiectul capturat (ciclu) sau când o operație lungă nu trebuie să țină obiectul în viață. Nu este necesar în closures non-escaping sau în cele care se termină rapid și nu sunt stocate de self.

O listă de captură controlează cum închiderea reține variabilele. [weak self] reține self slab, deci self devine optional în interior.

Cazuri în care e nevoie:

SWIFT
final class ProfileViewModel {
    var onUpdate: (() -> Void)?
    private var timer: Timer?

    func start() {
        // self deține timer-ul, timer-ul deține closure-ul, closure-ul ar deține self
        timer = Timer.scheduledTimer(withTimeInterval: 5, repeats: true) { [weak self] _ in
            guard let self else { return }
            self.refresh()
        }
    }

    func refresh() { onUpdate?() }
}

Fără [weak self], view model-ul nu ar fi eliberat niciodată, iar timer-ul ar rula la nesfârșit.

Cazuri în care nu e nevoie:

  • closures non-escaping: map, filter, forEach, UIView.animate (animațiile se termină și eliberează closure-ul);
  • DispatchQueue.main.async { self.update() }: nu există ciclu, closure-ul este eliberat după execuție; doar prelungește puțin viața lui self;
  • struct-uri: nu poți avea weak la tipuri valoare.

A doua motivație, diferită de ciclu, este durata de viață: o cerere de rețea de 30 de secunde cu self capturat puternic ține ecranul în memorie după ce utilizatorul l-a închis și poate actualiza UI inutil. [weak self] permite eliberarea mai devreme.

guard let self (Swift 5.7 sintaxa scurtă) creează o referință puternică temporară pentru restul closure-ului, ceea ce evită ca self să dispară la jumătatea execuției. Varianta [unowned self] e mai scurtă, dar dă crash dacă obiectul a fost eliberat între timp.

Ce urmărește intervievatorul: Se verifică dacă știi să raționezi despre proprietate în loc să aplici [weak self] mecanic; diferența dintre ciclu și prelungirea duratei de viață este un plus.

34 Mid

De ce delegate-ul se declară weak și de ce protocolul trebuie să fie AnyObject?

Răspuns scurt: Delegate-ul se declară weak pentru că obiectul care deține componenta este, de obicei, chiar delegate-ul ei; o referință puternică în sens invers ar crea un ciclu. Protocolul trebuie restrâns la AnyObject pentru că weak se poate aplica doar tipurilor referință.

Pattern-ul delegate este fundamental în UIKit: un obiect își comunică evenimentele către alt obiect printr-un protocol.

SWIFT
protocol PaymentFormDelegate: AnyObject {
    func paymentForm(_ form: PaymentFormView, didSubmit amount: Decimal)
}

final class PaymentFormView: UIView {
    weak var delegate: PaymentFormDelegate?

    @objc private func submitTapped() {
        delegate?.paymentForm(self, didSubmit: 100)
    }
}

final class CheckoutViewController: UIViewController, PaymentFormDelegate {
    private let form = PaymentFormView()        // VC deține form-ul (strong)

    override func viewDidLoad() {
        super.viewDidLoad()
        form.delegate = self                     // form-ul indică slab spre VC
        view.addSubview(form)
    }

    func paymentForm(_ form: PaymentFormView, didSubmit amount: Decimal) {
        print("Plată de \(amount)")
    }
}

Relația de proprietate: view controller-ul deține form-ul. Dacă form-ul ar ține și el puternic view controller-ul, ar exista un ciclu, iar ecranul nu ar fi eliberat niciodată după închidere.

De ce AnyObject: un protocol obișnuit poate fi adoptat și de struct-uri. Compilatorul nu poate permite weak pentru un tip care poate fi valoare, deci restricția : AnyObject (înainte se scria : class) garantează că doar clasele pot adopta protocolul.

Convenții UIKit utile: primul parametru al metodelor delegate este obiectul care trimite evenimentul (tableView(_:didSelectRowAt:)), ca un delegate să poată deservi mai multe surse. Componentele moderne folosesc adesea closures sau async/await în loc de delegați, dar regulile de memorie rămân aceleași.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce, nu doar că ai memorat regula; mulți candidați nu știu explica restricția AnyObject.

35 Mid

Cum ai depista un memory leak într-o aplicație iOS?

Răspuns scurt: Verifici întâi dacă deinit se apelează la închiderea ecranelor, apoi folosești Memory Graph Debugger din Xcode pentru a vedea cine ține obiectele și instrumentele Leaks și Allocations din Instruments pentru a găsi creșteri de memorie la acțiuni repetate.

Un proces sistematic:

1. Reproduci simptomul. Deschizi și închizi același ecran de mai multe ori și urmărești memoria în Debug Navigator din Xcode. Dacă memoria crește la fiecare iterație și nu scade, ai un indiciu.

2. Verifici deinit. Un print sau un breakpoint în deinit pentru view controller și view model arată imediat dacă obiectul este eliberat.

3. Memory Graph Debugger. Butonul „Debug Memory Graph” din bara de debug oprește aplicația și afișează toate obiectele vii. Cauți instanțe care nu ar trebui să existe (de exemplu cinci ProfileViewController după ce ai închis ecranul de cinci ori). Graful arată lanțul de referințe care le ține; ciclurile detectate sunt marcate cu un simbol de avertizare. Activarea „Malloc Stack Logging” din schema de rulare arată și locul unde a fost alocat obiectul.

4. Instruments. Template-ul Leaks detectează memoria inaccesibilă, iar Allocations, cu funcția de „Mark Generation”, arată exact ce obiecte noi au rămas între două momente.

SWIFT
deinit {
    print("\(Self.self) eliberat")
}

Cauzele găsite de obicei: closures stocate care capturează self, delegați strong, Timer neinvalidat, abonamente Combine păstrate în Set<AnyCancellable> cu closures care capturează puternic owner-ul, observatori NotificationCenter bazați pe blocuri neeliminați.

Nu toate creșterile de memorie sunt leak-uri: un cache de imagini (NSCache, URLCache) poate crește în mod legitim și este golit de sistem la presiune de memorie. Diferența este că un leak nu poate fi recuperat niciodată.

Ce urmărește intervievatorul: Se verifică experiența practică cu uneltele Xcode, nu doar teoria; un candidat bun descrie un proces repetabil.

36 Mid

Ce afișează codul și de ce?

SWIFT
var x = 1
let a = { print(x) }
let b = { [x] in print(x) }
x = 2
a()
b()

Răspuns scurt: Afișează 2, apoi 1. Closure-ul a capturează variabila x prin referință și vede valoarea curentă la execuție, iar b copiază valoarea lui x în momentul creării prin lista de captură.

Implicit, un closure capturează variabila, nu valoarea ei din momentul creării. Dacă variabila se schimbă înainte de execuție, closure-ul vede noua valoare. De aceea a() afișează 2.

O listă de captură ([x]) evaluează expresia în momentul în care closure-ul este creat și păstrează o copie constantă. Modificarea ulterioară a lui x nu afectează copia, deci b() afișează 1.

Același mecanism stă în spatele lui [weak self]: și acolo lista de captură creează o legătură nouă, evaluată la creare, cu un mod diferit de reținere.

Comportamentul are consecințe practice:

SWIFT
var handlers: [() -> Void] = []
for i in 1...3 {
    handlers.append { print(i) }    // fiecare iterație are propriul i
}
handlers.forEach { $0() }           // 1 2 3

var counter = 0
let increment = { counter += 1 }
increment(); increment()
print(counter)                      // 2: closure-ul modifică variabila originală

În bucla for-in, fiecare iterație creează o constantă nouă i, deci nu apare problema clasică din JavaScript mai vechi cu var.

În cod concurent, capturarea unei variabile mutabile într-un closure care rulează pe alt thread poate produce o cursă de date. În Swift 6, compilatorul refuză în modul strict capturarea unei var locale într-un closure @Sendable, iar lista de captură cu valoare copiată este una dintre soluțiile simple.

Ce urmărește intervievatorul: Întrebare de tip „ce afișează”; se verifică dacă înțelegi capturarea prin referință și efectul listei de captură.

37 Senior

Când alegi unowned în locul lui weak și ce riscuri există?

Răspuns scurt: unowned se alege când obiectul referit trăiește garantat cel puțin cât cel care îl referă, de exemplu un copil care nu există fără părinte. Riscul este crash-ul la accesarea unui obiect deja eliberat, iar câștigul de performanță față de weak este de obicei neglijabil.

Ambele evită cicluri, dar diferă la ce se întâmplă după eliberare:

  • weak devine nil automat. Codul trebuie să trateze absența (guard let self). Runtime-ul Swift gestionează aceste referințe printr-un mecanism suplimentar (side table), cu un cost mic.
  • unowned nu devine nil. Accesarea după eliberare produce o oprire deterministă a aplicației (Swift verifică acest lucru). Există și unowned(unsafe), care elimină verificarea și poate citi memorie invalidă: practic niciodată justificat în cod de aplicație.

Cazuri potrivite pentru unowned:

SWIFT
final class Order {
    lazy var summary: () -> String = { [unowned self] in
        "Comanda \(self.id) cu \(self.items.count) produse"
    }
    let id: Int
    var items: [String] = []
    init(id: Int) { self.id = id }
}

Closure-ul este deținut de Order și nu poate supraviețui obiectului, deci unowned este sigur. La fel pentru relații stricte de compoziție, unde părintele creează și deține copiii.

Cazuri periculoase: callbacks asincrone (rețea, animații întârziate, notificări), unde nu controlezi momentul execuției. Dacă utilizatorul închide ecranul înainte să vină răspunsul, unowned self produce crash.

Argumentul de performanță este rar relevant în aplicații: diferența contează doar în bucle foarte calde. Decizia ar trebui să se bazeze pe semantică: unowned documentează o invariantă („obiectul există sigur”). Dacă invarianta poate fi încălcată de schimbări viitoare de cod, weak este alegerea mai robustă, iar într-o echipă mare această robustețe contează mai mult decât câteva linii de guard.

Ce urmărește intervievatorul: Verifică judecata de senior: echilibrul dintre siguranță și claritate, plus înțelegerea faptului că unowned exprimă o invariantă.

38 Senior

Unde apar retain cycles mai greu de observat, de exemplu cu Timer, NotificationCenter, Combine sau Task?

Răspuns scurt: Timer reține puternic target-ul sau closure-ul până la invalidate(), observatorii pe bază de blocuri din NotificationCenter sunt reținuți până sunt eliminați, abonamentele Combine stocate în self rețin closures care capturează self, iar un Task reține tot ce capturează până se termină.

Câteva surse ascunse, frecvente în cod real:

  • Timer: run loop-ul reține timer-ul, iar timer-ul reține target-ul (Timer(target: self, ...)) sau closure-ul. Chiar dacă tu ții timer-ul weak, obiectul nu se eliberează până nu apelezi invalidate(). Un invalidate pus doar în deinit nu rezolvă nimic, pentru că deinit nu ajunge să ruleze.
  • NotificationCenter cu addObserver(forName:object:queue:using:): centrul reține blocul; dacă blocul capturează self puternic, obiectul rămâne viu. Trebuie [weak self] și eliminarea token-ului.
  • Combine:
SWIFT
final class SearchViewModel: ObservableObject {
    @Published var query = ""
    @Published private(set) var results: [String] = []
    private var cancellables = Set<AnyCancellable>()

    init() {
        $query
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .sink { [weak self] text in self?.search(text) }   // fără weak: ciclu
            .store(in: &cancellables)
    }
    private func search(_ text: String) { }
}

Ciclul este self -> cancellables -> sink closure -> self. O variantă fără ciclu pentru atribuiri simple este assign(to: &$results) (iOS 14+), spre deosebire de assign(to:on: self), care reține self puternic.

  • Task: un Task { await self.load() } reține self până la final. Nu este un ciclu permanent dacă task-ul se termină, dar o buclă infinită (for await pe un stream care nu se închide) ține obiectul viu pentru totdeauna. Soluția: păstrezi task-ul și îl anulezi la ieșirea din ecran, sau folosești modificatorul .task din SwiftUI, care anulează automat la dispariția view-ului.

Un senior verifică aceste puncte la code review și adaugă teste care confirmă eliberarea obiectelor (de exemplu o referință weak verificată la finalul testului).

Ce urmărește intervievatorul: Se urmărește experiența cu surse reale și subtile de leak-uri; menționarea lui Task cu bucle infinite și a modificatorului .task arată cunoștințe actuale.

Concurență: GCD, async/await, actors

39 Junior

De ce trebuie actualizată interfața doar pe main thread?

Răspuns scurt: UIKit și SwiftUI nu sunt thread-safe și presupun că toate modificările de UI au loc pe main thread, unde rulează și bucla de evenimente care desenează ecranul. Actualizarea din alt thread poate produce afișări greșite, crash-uri sau avertismente de la Main Thread Checker.

Main thread-ul rulează run loop-ul principal: primește atingerile, rulează animațiile și redesenează ecranul de obicei la 60 sau 120 de cadre pe secundă, în funcție de dispozitiv. Framework-urile de UI nu folosesc lock-uri interne pentru acces concurent, pentru că ar fi lente și complicate; în schimb impun regula ca totul să se întâmple pe un singur thread.

Consecințe:

  • o operație lungă pe main thread (descărcare, decodare de imagini mari, citire sincronă de fișiere) blochează interfața: aplicația nu mai răspunde la atingeri, animațiile se opresc. Dacă blocarea durează mult, sistemul poate închide aplicația (watchdog).
  • o actualizare de UI dintr-un thread de fundal poate funcționa uneori și eșua alteori, ceea ce face bugurile greu de reprodus.
SWIFT
func loadAvatar(from url: URL) {
    Task {
        let (data, _) = try await URLSession.shared.data(from: url)
        let image = UIImage(data: data)
        await MainActor.run {
            self.avatarView.image = image   // înapoi pe main
        }
    }
}

Varianta clasică, cu GCD, este DispatchQueue.main.async { ... }. Cu Swift Concurrency, marchezi clasa sau metoda cu @MainActor, iar compilatorul se asigură că este apelată de pe main thread.

Xcode are activat implicit Main Thread Checker în schemele de debug: dacă apelezi un API UIKit de pe alt thread, primești un avertisment în consolă, cu stack trace. Merită să nu ignori aceste mesaje.

Ce urmărește intervievatorul: Este o regulă de bază; se verifică dacă știi și de ce, și cum muți munca înapoi pe main.

40 Junior

Ce este Grand Central Dispatch și cum folosești DispatchQueue.main și DispatchQueue.global()?

Răspuns scurt: GCD este biblioteca Apple de concurență bazată pe cozi de execuție. Trimiți blocuri de cod pe o coadă, iar sistemul le execută pe un pool de thread-uri. DispatchQueue.main rulează pe main thread (pentru UI), iar DispatchQueue.global(qos:) rulează munca de fundal.

În loc să creezi și să gestionezi thread-uri manual, descrii munca și coada pe care trebuie să ruleze.

SWIFT
DispatchQueue.global(qos: .userInitiated).async {
    let thumbnails = images.map { $0.resized(to: CGSize(width: 100, height: 100)) }

    DispatchQueue.main.async {
        self.collectionView.reloadData(with: thumbnails)
    }
}

DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
    self.toast.hide()
}

Concepte importante:

  • cozi seriale execută câte un bloc odată, în ordine (main queue este serială). Cozi concurente pot rula mai multe blocuri simultan (cozile globale sunt concurente).
  • async trimite blocul și revine imediat; sync așteaptă până când blocul se termină.
  • QoS (Quality of Service) indică prioritatea: .userInteractive, .userInitiated, .utility, .background. Sistemul alocă resurse în funcție de el.
  • poți crea cozi proprii: DispatchQueue(label: "ro.app.cache") (serială implicit) sau cu attributes: .concurrent.

Alte unelte GCD: DispatchGroup pentru a aștepta mai multe operații, DispatchSemaphore pentru limitarea accesului, DispatchWorkItem pentru operații anulabile.

În cod nou, Apple recomandă Swift Concurrency (async/await, actors), care oferă verificări la compilare. GCD rămâne însă omniprezent în proiectele existente și în bibliotecile terțe, deci la interviu se așteaptă să îl înțelegi. O capcană clasică este DispatchQueue.main.sync apelat de pe main thread: produce deadlock.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi conceptele de bază (serial/concurent, sync/async, QoS), nu doar formula main.async.

41 Junior

Ce înseamnă async și await în Swift și ce avantaje au față de completion handlers?

Răspuns scurt: async marchează o funcție care se poate suspenda în timpul execuției, iar await marchează punctul în care apelantul poate fi suspendat până vine rezultatul. Codul asincron se citește secvențial, erorile se propagă cu throws, iar compilatorul garantează că rezultatul este returnat exact o dată.

Swift Concurrency este disponibil din Swift 5.5, cu suport pentru iOS 13 și mai nou (cu unele limitări pe versiunile vechi).

Cu completion handlers, două cereri dependente arată așa:

SWIFT
func loadDashboard(completion: @escaping (Result<Dashboard, Error>) -> Void) {
    api.fetchUser { userResult in
        switch userResult {
        case .failure(let e): completion(.failure(e))
        case .success(let user):
            api.fetchOrders(for: user) { ordersResult in
                completion(ordersResult.map { Dashboard(user: user, orders: $0) })
            }
        }
    }
}

Cu async/await:

SWIFT
func loadDashboard() async throws -> Dashboard {
    let user = try await api.fetchUser()
    let orders = try await api.fetchOrders(for: user)
    return Dashboard(user: user, orders: orders)
}

Avantaje:

  • fluxul de control este linear, ușor de citit și de modificat;
  • erorile se propagă natural prin try, fără ramuri failure repetate;
  • compilatorul împiedică greșelile clasice: uitarea apelului completion pe o ramură sau apelarea lui de două ori;
  • suspendarea nu blochează thread-ul. În timp ce funcția așteaptă rețeaua, thread-ul poate executa altă muncă.

Important: await nu înseamnă că codul rulează pe alt thread, ci că funcția poate fi suspendată acolo. După reluare, poate continua pe alt thread decât cel de dinainte, cu excepția codului izolat pe un actor (de exemplu @MainActor), care revine mereu pe executorul actorului. De asemenea, starea se poate schimba între două await-uri, deci nu presupune că o valoare citită înainte de suspendare este încă actuală.

Ce urmărește intervievatorul: Se verifică înțelegerea modelului mental de suspendare și a avantajelor reale; greșeala tipică este să crezi că await blochează thread-ul.

42 Junior

Cum apelezi o funcție async dintr-un context sincron, de exemplu dintr-un buton?

Răspuns scurt: Creezi un Task { ... }, care pornește o unitate nouă de muncă asincronă în care poți folosi await. În SwiftUI poți folosi și modificatorul .task, care pornește munca la apariția view-ului și o anulează automat la dispariție.

O funcție async poate fi apelată doar dintr-un context asincron. Punctul de trecere dintre lumea sincronă (acțiunea unui buton, viewDidLoad) și cea asincronă este Task.

SWIFT
struct ProfileView: View {
    @State private var user: User?
    @State private var errorText: String?

    var body: some View {
        VStack {
            Text(user?.name ?? "...")
            Button("Reîncarcă") {
                Task { await reload() }
            }
        }
        .task { await reload() }      // la apariție, anulat la dispariție
    }

    private func reload() async {
        do { user = try await API.shared.currentUser() }
        catch { errorText = error.localizedDescription }
    }
}

În UIKit:

SWIFT
override func viewDidLoad() {
    super.viewDidLoad()
    loadTask = Task { await viewModel.load() }
}
override func viewDidDisappear(_ animated: Bool) {
    super.viewDidDisappear(animated)
    loadTask?.cancel()
}

Detalii utile:

  • Task { } moștenește contextul actorului curent. Creat într-un view sau într-o clasă @MainActor, rulează izolat pe main actor (părțile sincrone rulează pe main thread, iar apelurile await către alte funcții pot rula în altă parte).
  • Task.detached { } nu moștenește actorul și nici prioritatea; folosește-l rar, când ai un motiv clar.
  • un Task creat așa nu este anulat automat dacă nu păstrezi referința și nu apelezi cancel(). Modificatorul .task din SwiftUI rezolvă asta automat, iar varianta .task(id:) repornește munca la schimbarea unei valori.
  • erorile dintr-un Task care nu le tratează sunt pierdute în tăcere, deci folosește do/catch în interior.

Ce urmărește intervievatorul: Verifică dacă știi puntea dintre cod sincron și asincron și dacă te gândești la anulare; mulți candidați nu cunosc modificatorul .task.

43 Mid

Ce se întâmplă dacă apelezi DispatchQueue.main.sync de pe main thread și cum eviți deadlock-urile?

Răspuns scurt: Se produce un deadlock: main thread-ul așteaptă terminarea blocului, iar blocul așteaptă ca main thread-ul să se elibereze pentru a rula. Aplicația îngheață definitiv. Regula generală: nu apela sync pe o coadă serială de pe chiar acea coadă.

sync pune blocul în coadă și blochează thread-ul curent până când blocul se termină. Main queue este serială, deci execută câte un bloc odată pe main thread. Dacă ești deja pe main thread și ceri main.sync, blocul nou așteaptă ca blocul curent (codul tău) să termine, iar codul tău așteaptă blocul nou. Niciunul nu poate continua.

SWIFT
// pe main thread
DispatchQueue.main.sync {      // deadlock: aplicația îngheață
    print("nu se ajunge aici")
}

let queue = DispatchQueue(label: "ro.app.serial")
queue.sync {
    queue.sync { print("nici aici") }   // același tip de deadlock
}

Cu GCD, situația se produce de obicei indirect: o funcție utilitară care face queue.sync este apelată, prin câteva niveluri, dintr-un bloc care rulează deja pe aceeași coadă. În Debug, GCD detectează unele cazuri și oprește aplicația cu un mesaj explicit, dar nu pe toate.

Cum eviți:

  • preferă async ori de câte ori nu ai nevoie imediat de rezultat;
  • nu folosi sync pe main queue; pentru UI folosește main.async sau @MainActor;
  • documentează ce coadă protejează fiecare stare și nu apela din interiorul ei metode publice care fac din nou sync;
  • pentru acces protejat la stare, folosește un actor: actorii nu au acest tip de deadlock, pentru că apelurile între actori se suspendă cu await în loc să blocheze.

Un alt tip de blocare, specific Swift Concurrency, apare când blochezi un thread din pool-ul cooperativ cu un semafor ce așteaptă un Task; pool-ul are puține thread-uri și se poate epuiza.

Ce urmărește intervievatorul: Întrebare de depanare clasică; se verifică înțelegerea mecanismului, nu doar memorarea regulii, și cunoașterea alternativelor moderne.

44 Mid

Cum rulezi mai multe operații asincrone în paralel cu async let și TaskGroup?

Răspuns scurt: async let pornește un număr fix de operații în paralel, iar rezultatele se așteaptă ulterior cu await. withTaskGroup sau withThrowingTaskGroup sunt potrivite pentru un număr variabil de operații, de exemplu descărcarea unei liste de imagini.

Apelurile await succesive rulează secvențial. Dacă operațiile sunt independente, poți câștiga timp rulându-le simultan.

Număr fix de operații:

SWIFT
func loadHome() async throws -> Home {
    async let banners = api.banners()
    async let products = api.featuredProducts()
    async let profile = api.profile()

    return try await Home(banners: banners, products: products, profile: profile)
}

Cele trei cereri pornesc imediat. Dacă una aruncă eroare, celelalte sunt anulate automat la ieșirea din scope.

Număr variabil de operații:

SWIFT
func thumbnails(for urls: [URL]) async throws -> [URL: UIImage] {
    try await withThrowingTaskGroup(of: (URL, UIImage?).self) { group in
        for url in urls {
            group.addTask {
                let (data, _) = try await URLSession.shared.data(from: url)
                return (url, UIImage(data: data))
            }
        }
        var result: [URL: UIImage] = [:]
        for try await (url, image) in group {
            result[url] = image
        }
        return result
    }
}

Rezultatele vin în ordinea terminării, nu a adăugării, de aceea întorc perechi (URL, UIImage?).

Aceasta este structured concurrency: task-urile copil nu pot trăi mai mult decât scope-ul care le-a creat, anularea se propagă de la părinte la copii, iar erorile urcă spre părinte. Este diferența principală față de pornirea mai multor Task { } independente, care nu au această legătură.

La sute de URL-uri, merită să limitezi concurența: adaugi inițial, de exemplu, 4 task-uri și adaugi câte unul nou de fiecare dată când unul se termină, ca să nu supraîncarci rețeaua și memoria.

Ce urmărește intervievatorul: Se verifică înțelegerea structured concurrency și alegerea uneltei potrivite; limitarea concurenței este un plus apreciat.

45 Mid

Ce este un actor și ce problemă rezolvă?

Răspuns scurt: Un actor este un tip referință care își protejează starea internă: doar un singur task poate accesa această stare la un moment dat. Elimină data races fără lock-uri manuale, iar accesul din afară se face cu await.

O cursă de date (data race) apare când două thread-uri accesează aceeași memorie simultan și cel puțin unul scrie. Rezultatul este imprevizibil: valori pierdute, crash-uri sporadice. Soluția clasică este un lock sau o coadă serială, ușor de folosit greșit.

Un actor serializează automat accesul:

SWIFT
actor ImageCache {
    private var storage: [URL: UIImage] = [:]

    func image(for url: URL) -> UIImage? { storage[url] }

    func insert(_ image: UIImage, for url: URL) { storage[url] = image }
}

let cache = ImageCache()

func avatar(url: URL) async throws -> UIImage? {
    if let cached = await cache.image(for: url) { return cached }
    let (data, _) = try await URLSession.shared.data(from: url)
    guard let image = UIImage(data: data) else { return nil }
    await cache.insert(image, for: url)
    return image
}

Din interiorul actorului, metodele se apelează normal, sincron. Din afară, fiecare apel este marcat cu await, pentru că apelantul ar putea fi nevoit să aștepte până actorul termină altă operație. Compilatorul refuză accesul direct, nesincronizat, la proprietățile mutabile ale actorului.

Diferențe față de o clasă cu lock:

  • protecția este verificată la compilare;
  • așteptarea nu blochează thread-ul, ci suspendă task-ul;
  • actorii nu au moștenire.

Limite importante: actorul protejează fiecare acces individual, dar nu o secvență de operații separate de await. În exemplul de mai sus, două cereri simultane pentru același URL pot descărca imaginea de două ori, pentru că ambele găsesc cache-ul gol. Fenomenul se numește reentrancy și se rezolvă, de exemplu, memorând task-ul în desfășurare pentru fiecare URL.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea data races și a garanțiilor reale ale actorilor; menționarea reentrancy arată profunzime.

46 Mid

Ce face @MainActor și unde îl folosești?

Răspuns scurt: @MainActor este un actor global care reprezintă main thread-ul. Marcând o clasă, o funcție sau o proprietate cu el, compilatorul garantează că acel cod rulează pe main thread și cere await pentru apelurile din alte contexte.

Este înlocuitorul verificat la compilare pentru DispatchQueue.main.async. Îl folosești pentru tot ce atinge interfața: view controllers, view models care publică stare pentru UI, coordonatori de navigare.

SWIFT
@MainActor
final class OrdersViewModel: ObservableObject {
    @Published private(set) var orders: [Order] = []
    @Published private(set) var isLoading = false

    private let service: OrdersService

    init(service: OrdersService) { self.service = service }

    func load() async {
        isLoading = true
        defer { isLoading = false }
        do {
            orders = try await service.fetchOrders()   // rețeaua rulează în altă parte
        } catch {
            orders = []
        }
    }
}

Toate modificările lui orders și isLoading au loc garantat pe main thread. Funcția fetchOrders(), dacă nu este ea însăși izolată pe main actor, rulează în altă parte, iar după await execuția revine pe main.

Alte forme:

  • await MainActor.run { ... } pentru un bloc punctual;
  • Task { @MainActor in ... };
  • nonisolated pentru a scoate o metodă anume din izolarea clasei, când nu atinge stare protejată.

Context de versiune: UIView, UIViewController și protocolul View din SwiftUI sunt marcate de Apple cu @MainActor (pentru View, explicit la nivelul întregului protocol începând cu SDK-urile din 2024). Xcode 26 cu Swift 6.2 permite și setarea „default actor isolation” la MainActor pentru un întreg target, astfel încât codul de aplicație este pe main implicit, iar munca grea trebuie mutată explicit în altă parte.

O greșeală frecventă: să pui calcule costisitoare (decodări mari, procesare de imagini) în metode @MainActor, ceea ce blochează interfața.

Ce urmărește intervievatorul: Se verifică dacă știi folosi izolarea pe main corect și nu confunzi @MainActor cu „totul pe main”.

47 Mid

Cum funcționează anularea în Swift Concurrency?

Răspuns scurt: Anularea este cooperativă: task.cancel() doar marchează task-ul ca anulat, iar codul trebuie să verifice Task.isCancelled sau să apeleze try Task.checkCancellation(). Multe API-uri Apple, precum URLSession și Task.sleep, reacționează singure aruncând CancellationError.

Spre deosebire de oprirea forțată a unui thread, Swift nu întrerupe codul în mijlocul execuției. Un task anulat continuă să ruleze până când codul lui verifică starea de anulare și decide să se oprească. Asta evită stări corupte (de exemplu o scriere pe disc întreruptă la jumătate).

SWIFT
func processAll(_ files: [URL]) async throws -> [Report] {
    var reports: [Report] = []
    for file in files {
        try Task.checkCancellation()          // aruncă CancellationError dacă e anulat
        reports.append(try await parse(file))
    }
    return reports
}

let task = Task { try await processAll(files) }
// utilizatorul închide ecranul
task.cancel()

Reguli importante:

  • anularea se propagă în jos, la task-urile copil create cu async let sau TaskGroup; nu se propagă la Task { } independente sau la Task.detached.
  • URLSession.data(from:) aruncă URLError(.cancelled) la anulare, iar Task.sleep aruncă CancellationError.
  • pentru resurse care trebuie eliberate, withTaskCancellationHandler permite rularea imediată a unui cod de curățenie, de exemplu anularea unei operații vechi bazate pe callback.
  • în UI, de obicei nu vrei să afișezi o eroare la anulare. Filtrează CancellationError (și URLError.cancelled) înainte de a arăta un mesaj.

Un exemplu clasic: căutarea pe măsură ce utilizatorul tastează. Fiecare tastare anulează task-ul anterior și pornește unul nou, ca rezultatele vechi să nu suprascrie rezultatele noi. În SwiftUI, .task(id: query) face asta automat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că anularea este cooperativă și cum se propagă; greșeala comună este să crezi că cancel() oprește imediat codul.

48 Senior

Ce este Sendable și ce schimbă modul strict de concurență din Swift 6?

Răspuns scurt: Sendable marchează tipurile care pot fi transmise în siguranță între domenii de concurență (task-uri, actori) fără data races. Modul de limbaj Swift 6 transformă verificările de concurență în erori de compilare, astfel încât data races devin imposibile în codul verificat.

Un tip este Sendable dacă poate fi copiat sau partajat între thread-uri fără risc:

  • tipurile valoare ale căror proprietăți sunt toate Sendable (multe struct-uri și enum-uri primesc conformarea automat, dacă nu sunt public);
  • actorii, care își protejează singuri starea;
  • clasele final cu proprietăți exclusiv let de tipuri Sendable;
  • clasele care se sincronizează intern pot fi marcate @unchecked Sendable, dar atunci responsabilitatea corectitudinii este a ta.

Closures transmise între contexte trebuie să fie @Sendable, adică să nu captureze stare mutabilă nesigură.

SWIFT
final class Settings {           // nu este Sendable: are var
    var theme = "light"
}

func update(_ s: Settings) {
    Task.detached {
        s.theme = "dark"         // Swift 6: eroare, Settings trece între domenii
    }
}

Swift 5.x afișa aceste probleme ca avertismente, opțional, prin setarea „Strict Concurrency Checking”. Modul Swift 6 le face erori. Swift 6.2 (Xcode 26) a adăugat unelte de „approachable concurrency”: izolare implicită pe main actor pentru un target, funcții nonisolated async care rulează implicit pe actorul apelantului și atributul @concurrent pentru munca explicit paralelă.

Strategia de migrare într-un proiect mare: activezi verificarea completă pe modulele cele mai izolate, rezolvi avertismentele modul cu modul, marchezi codul de UI @MainActor, transformi singleton-urile mutabile în actori sau le izolezi, și folosești @preconcurrency import pentru biblioteci terțe care încă nu au adnotări. Abuzul de @unchecked Sendable doar ca să dispară erorile ascunde exact problemele pe care modul strict le scoate la suprafață.

Ce urmărește intervievatorul: Se verifică experiența cu migrarea la Swift 6 și înțelegerea garanțiilor; candidații slabi propun @unchecked Sendable ca soluție universală.

49 Senior

Ce este actor reentrancy și cum o gestionezi?

Răspuns scurt: Reentrancy înseamnă că, atunci când o metodă a unui actor ajunge la un await, actorul poate executa între timp alte apeluri. Starea actorului se poate deci schimba între două await-uri, iar invariantele verificate înainte de suspendare pot să nu mai fie valabile după.

Actorii Swift sunt intenționat reentranți: dacă ar fi blocați pe toată durata unei metode, inclusiv în timpul așteptării rețelei, ar apărea deadlock-uri și o performanță slabă. Prețul este că fiecare await din interiorul unui actor este un punct în care starea poate fi modificată de alt apel.

Exemplu de bug:

SWIFT
actor TokenStore {
    private var token: String?

    func validToken() async throws -> String {
        if let token { return token }
        let fresh = try await api.refreshToken()   // alte apeluri pot intra aici
        token = fresh
        return fresh
    }
}

Dacă zece cereri pornesc simultan fără token, toate trec de verificare înainte ca prima să termine, iar serverul primește zece cereri de reîmprospătare. Unele servere invalidează tokenurile anterioare, deci rezultatul poate fi chiar o deconectare.

Soluția: memorezi operația în desfășurare, nu doar rezultatul.

SWIFT
actor TokenStore {
    private var token: String?
    private var refreshTask: Task<String, Error>?

    func validToken() async throws -> String {
        if let token { return token }
        if let refreshTask { return try await refreshTask.value }

        let task = Task { try await api.refreshToken() }
        refreshTask = task
        defer { refreshTask = nil }
        let fresh = try await task.value
        token = fresh
        return fresh
    }
}

Reguli generale: fă modificările de stare sincron, înainte sau după await, nu la mijloc; reverifică invariantele după fiecare await; păstrează secțiunile critice fără suspendări. La code review, fiecare await dintr-un actor merită întrebarea „ce se poate schimba aici?”.

Ce urmărește intervievatorul: Este o întrebare de senior despre corectitudine în cod concurent; un exemplu concret precum refresh-ul de token arată experiență reală.

50 Senior

Cum transformi un API bazat pe completion handler într-o funcție async?

Răspuns scurt: Folosești withCheckedContinuation sau withCheckedThrowingContinuation: apelezi API-ul vechi în interior și reiei funcția cu continuation.resume(returning:) sau resume(throwing:). Continuarea trebuie reluată exact o dată pe fiecare cale de execuție.

Multe biblioteci și API-uri mai vechi folosesc încă callbacks. O continuare (continuation) face puntea:

SWIFT
extension LocationProvider {
    func currentLocation() async throws -> CLLocation {
        try await withCheckedThrowingContinuation { continuation in
            requestLocation { result in
                switch result {
                case .success(let location):
                    continuation.resume(returning: location)
                case .failure(let error):
                    continuation.resume(throwing: error)
                }
            }
        }
    }
}

Dacă callback-ul livrează direct un Result, poți scrie continuation.resume(with: result).

Reguli critice:

  • reluarea de două ori este o eroare de programare și oprește aplicația;
  • dacă nu reiei niciodată, task-ul rămâne suspendat pentru totdeauna, iar varianta „checked” afișează un avertisment în consolă. Verifică toate ramurile, inclusiv cele de timeout sau de eroare timpurie;
  • variantele withUnsafeContinuation elimină verificările, cu un câștig minim de performanță; în cod de aplicație, varianta checked este alegerea potrivită.

Pentru API-uri care livrează mai multe valori în timp (delegați de locație, notificări, evenimente de socket), o continuare nu este suficientă. Folosești AsyncStream:

SWIFT
func locationUpdates() -> AsyncStream<CLLocation> {
    AsyncStream { continuation in
        let observer = LocationObserver { continuation.yield($0) }
        continuation.onTermination = { _ in observer.stop() }
        observer.start()
    }
}

Ca senior, discuți și anularea: o continuare simplă nu reacționează la task.cancel(). Pentru operații lungi, combini cu withTaskCancellationHandler, care oprește operația veche și reia continuarea cu CancellationError. Multe API-uri Apple au deja variante async generate automat din metodele Objective-C cu completion handler.

Ce urmărește intervievatorul: Verifică experiența de migrare a codului existent și atenția la regula „exact o dată”; menționarea AsyncStream și a anulării este nivel senior.

SwiftUI și UIKit

51 Junior

Care sunt diferențele principale dintre SwiftUI și UIKit și când l-ai alege pe fiecare?

Răspuns scurt: UIKit este framework-ul imperativ, matur, bazat pe clase (UIView, UIViewController), în care modifici direct interfața. SwiftUI este declarativ: descrii interfața ca funcție de stare, iar framework-ul o actualizează singur. Proiectele noi pornesc des cu SwiftUI, cu UIKit unde e nevoie de control fin.

UIKit (din 2008, iOS 2):

  • imperativ: creezi view-uri, le adaugi în ierarhie și le modifici explicit când se schimbă datele (label.text = user.name);
  • bazat pe clase, moștenire și delegați (UITableViewDataSource);
  • layout prin Auto Layout, storyboards sau cod;
  • control complet și API-uri mature pentru orice situație.

SwiftUI (din 2019, iOS 13; practic utilizabil din iOS 14–15, mult îmbunătățit apoi):

  • declarativ: body descrie cum arată interfața pentru starea curentă;
  • view-urile sunt struct-uri ușoare; când starea se schimbă, SwiftUI recalculează body și aplică doar diferențele;
  • mai puțin cod, previzualizări live în Xcode, suport comun pentru iOS, macOS, watchOS;
  • unele funcționalități apar doar pe versiuni noi de iOS, ceea ce contează dacă aplicația suportă versiuni vechi.
SWIFT
// SwiftUI
struct Greeting: View {
    @State private var name = ""
    var body: some View {
        VStack {
            TextField("Nume", text: $name)
            Text("Salut, \(name)")
        }
    }
}

Echivalentul UIKit ar necesita un UITextField, un UILabel, constrângeri și o acțiune pentru evenimentul de editare care actualizează manual label-ul.

Alegerea în practică: versiunea minimă de iOS suportată, experiența echipei și codul existent. Multe aplicații sunt hibride: ecrane noi în SwiftUI integrate prin UIHostingController într-o aplicație UIKit, sau componente UIKit în SwiftUI prin UIViewRepresentable. La interviu merită să arăți că le cunoști pe amândouă, pentru că majoritatea proiectelor comerciale au cod UIKit existent.

Ce urmărește intervievatorul: Se verifică înțelegerea paradigmelor (imperativ vs declarativ) și realismul: un răspuns bun recunoaște că proiectele reale sunt adesea hibride.

52 Junior

Ce fac @State și @Binding în SwiftUI?

Răspuns scurt: @State declară o stare locală deținută de view, stocată de SwiftUI în afara struct-ului; la schimbare, view-ul se redesenează. @Binding este o legătură bidirecțională, transmisă cu $, prin care un view copil citește și modifică starea părintelui.

View-urile SwiftUI sunt struct-uri recreate frecvent, deci nu pot ține singure stare mutabilă. @State îi cere lui SwiftUI să păstreze valoarea în propria memorie, legată de identitatea view-ului în ierarhie.

SWIFT
struct SettingsView: View {
    @State private var notificationsOn = false

    var body: some View {
        Form {
            ToggleRow(title: "Notificări", isOn: $notificationsOn)
            Text(notificationsOn ? "Activate" : "Dezactivate")
        }
    }
}

struct ToggleRow: View {
    let title: String
    @Binding var isOn: Bool

    var body: some View {
        Toggle(title, isOn: $isOn)
    }
}

Cine deține starea: SettingsView. ToggleRow nu are propria copie; primește un Binding<Bool> prin $notificationsOn și, când utilizatorul apasă comutatorul, modifică direct starea părintelui. Ambele view-uri se actualizează.

Reguli utile:

  • declară @State ca private: este starea internă a view-ului și nu ar trebui inițializată din exterior (valoarea inițială dată din afară este folosită doar la prima creare a view-ului, ceea ce surprinde des începătorii);
  • @State este potrivit pentru tipuri valoare simple și stare de UI (text introdus, un toggle, un sheet deschis). Din iOS 17 poate ține și un obiect @Observable;
  • pentru previzualizări sau valori fixe, .constant(true) creează un binding imuabil;
  • single source of truth: fiecare informație trebuie să aibă un singur proprietar, iar ceilalți primesc binding-uri, nu copii.

Dacă un copil primește o valoare simplă (let isOn: Bool) în loc de binding, nu o poate modifica, iar modificările locale nu ajung la părinte.

Ce urmărește intervievatorul: Întrebare de bază în SwiftUI; se urmărește înțelegerea proprietății stării și a fluxului de date, nu doar a sintaxei cu $.

53 Junior

De ce view-urile SwiftUI sunt struct-uri și ce înseamnă că body se recalculează?

Răspuns scurt: Un view SwiftUI este o descriere ușoară a interfeței, nu obiectul desenat pe ecran. Când o stare de care depinde se schimbă, SwiftUI apelează din nou body, compară noua descriere cu cea veche și actualizează doar ce s-a schimbat.

În UIKit, un UIView este un obiect de durată, cu stare proprie, care ocupă memorie și este modificat direct. În SwiftUI, struct-ul View este doar o valoare care spune „aici trebuie să fie un text cu acest conținut și acest font”. Crearea lui este foarte ieftină, de aceea SwiftUI îl poate reconstrui de multe ori.

Ciclul de actualizare:

1. o sursă de adevăr se schimbă (@State, @Binding, un obiect observat, @Environment); 2. SwiftUI marchează view-urile care depind de ea; 3. reapelează body pentru acele view-uri; 4. compară rezultatul cu versiunea anterioară și aplică doar diferențele pe interfața reală.

Consecințe practice:

  • body trebuie să fie rapid și fără efecte secundare. Nu porni cereri de rețea, nu crea obiecte costisitoare și nu modifica stare în body. Pentru munca la apariție folosește .task sau .onAppear.
  • nu te baza pe numărul de apeluri ale lui body; poate fi apelat mai des decât te aștepți.
  • un obiect creat direct în view (let vm = ViewModel() ca proprietate simplă) este recreat la fiecare reconstruire a struct-ului; pentru obiecte persistente folosești @StateObject sau @State cu @Observable.
SWIFT
struct Counter: View {
    @State private var count = 0
    var body: some View {
        let _ = Self._printChanges()   // debug: afișează ce a declanșat recalcularea
        Button("Apăsat de \(count) ori") { count += 1 }
    }
}

Self._printChanges() este un API intern de depanare, util în dezvoltare, dar nu trebuie lăsat în producție.

Ce urmărește intervievatorul: Se verifică modelul mental corect al SwiftUI; greșeala tipică este să tratezi body ca pe un loc pentru logică sau efecte secundare.

54 Junior

Contează ordinea modificatorilor în SwiftUI? Ce diferență este între cele două variante?

SWIFT
Text("Salut").padding().background(.yellow)
Text("Salut").background(.yellow).padding()

Răspuns scurt: Da, contează. În prima variantă, fundalul galben acoperă textul plus spațiul de padding. În a doua, fundalul acoperă doar textul, iar padding-ul se adaugă în afara fundalului, ca spațiu transparent.

Fiecare modificator nu modifică view-ul existent, ci îl înfășoară într-un view nou. Ordinea apelurilor determină ordinea înfășurării, de la interior spre exterior.

Prima variantă:

1. Text("Salut") 2. .padding() creează un view mai mare, care conține textul și spațiul din jur 3. .background(.yellow) colorează tot acest view mai mare

A doua variantă:

1. Text("Salut") 2. .background(.yellow) colorează doar zona textului 3. .padding() adaugă spațiu transparent în jurul view-ului deja colorat

Același principiu explică multe comportamente:

SWIFT
Image("avatar")
    .resizable()
    .frame(width: 80, height: 80)
    .clipShape(Circle())        // decupează imaginea redimensionată
    .overlay(Circle().stroke(.white, lineWidth: 2))
    .shadow(radius: 4)          // umbra se aplică formei finale

Dacă pui .shadow înainte de .clipShape, umbra este decupată și dispare. Dacă pui .frame după .background, fundalul rămâne cât conținutul inițial.

Alte exemple: .onTapGesture pus înainte de .padding face ca doar zona textului să fie apăsabilă; după .padding, zona apăsabilă include padding-ul doar dacă există conținut desenat acolo (altfel adaugi .contentShape(Rectangle())).

Există și modificatori care se propagă în jos prin environment (.font, .foregroundStyle aplicate unui container), la care ordinea contează mai puțin, pentru că valoarea ajunge la copii. Pentru depanarea layout-ului, adăugarea temporară a unui .border(.red) în diferite puncte ale lanțului arată exact ce dimensiune are fiecare strat.

Ce urmărește intervievatorul: Exercițiu practic frecvent la SwiftUI; se verifică dacă înțelegi că modificatorii înfășoară view-uri, nu le modifică pe loc.

55 Junior

Cum afișezi o listă de date în SwiftUI și de ce este important Identifiable?

Răspuns scurt: Folosești List sau ForEach peste o colecție. Fiecare element trebuie să aibă o identitate stabilă, prin Identifiable sau prin id: \.cheie, ca SwiftUI să știe ce rând s-a adăugat, s-a șters sau s-a mutat și să anime corect schimbările.

SWIFT
struct TodoItem: Identifiable {
    let id: UUID
    var title: String
    var done: Bool
}

struct TodoList: View {
    @State private var items: [TodoItem] = [
        TodoItem(id: UUID(), title: "Învăț Swift", done: false),
        TodoItem(id: UUID(), title: "Fac tema", done: true)
    ]

    var body: some View {
        List {
            ForEach($items) { $item in
                Toggle(item.title, isOn: $item.done)
            }
            .onDelete { items.remove(atOffsets: $0) }
        }
    }
}

TodoItem (și nu Task) evită conflictul cu tipul Task din Swift Concurrency. De ce contează identitatea: când lista se schimbă, SwiftUI compară vechea colecție cu cea nouă. Dacă identificatorii sunt stabili, știe că rândul cu id-ul X a fost șters și poate anima doar dispariția lui, păstrând starea celorlalte rânduri.

Greșeli frecvente:

  • ForEach(items, id: \.self) pe valori care se pot repeta (două titluri identice) produce comportament imprevizibil;
  • folosirea indexului ca identitate (ForEach(0..<items.count, id: \.self)): la ștergerea primului element, toate rândurile își schimbă identitatea, animațiile devin greșite, iar starea locală a rândurilor (de exemplu un câmp de text) ajunge la alt element;
  • generarea unui UUID() nou ca proprietate computed id: fiecare recalculare produce identități noi, deci SwiftUI crede că toată lista s-a schimbat.

Ideal, id vine din datele tale, de exemplu id-ul din baza de date sau din API. ForEach($items) (iOS 15+) oferă binding-uri pentru fiecare element.

Ce urmărește intervievatorul: Verifică înțelegerea identității în SwiftUI; folosirea indexului drept identitate este greșeala tipică pe care intervievatorul o caută.

56 Junior

Descrie ciclul de viață al unui UIViewController.

Răspuns scurt: Ordinea principală este: loadView, viewDidLoad (o singură dată, după încărcarea view-ului), apoi la fiecare afișare viewWillAppear, viewIsAppearing (iOS 17+, disponibil retroactiv din iOS 13), viewDidAppear, iar la ascundere viewWillDisappear și viewDidDisappear. Layout-ul trece prin viewWillLayoutSubviews și viewDidLayoutSubviews.

Metodele și ce pui în ele:

  • loadView(): creează ierarhia de view-uri. O suprascrii doar dacă vrei să setezi un view complet custom (view = ProfileView()), fără super.
  • viewDidLoad(): rulează o singură dată, după ce view-ul a fost încărcat în memorie. Configurare inițială: adăugarea subview-urilor, constrângeri, legarea view model-ului, prima încărcare de date.
  • viewWillAppear(_:): înaintea fiecărei afișări. Actualizări care trebuie refăcute de fiecare dată când ecranul revine (de exemplu reîmprospătarea unui contor).
  • viewIsAppearing(_:): după ce view-ul are dimensiunile și trăsăturile (trait collection) corecte, dar înainte să fie vizibil. Locul potrivit pentru ajustări care depind de geometrie.
  • viewDidAppear(_:): ecranul este vizibil. Pornirea animațiilor, a analizei, focus pe un câmp de text.
  • viewWillDisappear(_:) și viewDidDisappear(_:): oprirea timerelor, salvarea unor modificări, anularea task-urilor.
  • viewWillLayoutSubviews() și viewDidLayoutSubviews(): pot rula de multe ori, la rotire sau la schimbarea dimensiunilor.
SWIFT
override func viewDidLoad() {
    super.viewDidLoad()
    setupLayout()
    Task { await viewModel.load() }
}

Greșeli frecvente:

  • citirea view.bounds în viewDidLoad, când dimensiunile finale nu sunt încă stabilite;
  • pornirea cererilor în viewWillAppear fără să ții cont că se apelează la fiecare revenire (de exemplu după închiderea unui modal);
  • uitarea apelului super.

Un modal prezentat cu stilul implicit .pageSheet (iOS 13+) nu declanșează viewWillDisappear pe ecranul de dedesubt, pentru că acesta rămâne parțial vizibil; e o sursă frecventă de buguri.

Ce urmărește intervievatorul: Întrebare clasică UIKit; se verifică dacă știi ce cod pui în fiecare metodă și capcanele precum dimensiunile din viewDidLoad.

57 Junior

Cum funcționează Auto Layout și ce înseamnă constrângeri ambigue sau conflictuale?

Răspuns scurt: Auto Layout calculează poziția și dimensiunea view-urilor din constrângeri, adică relații liniare între atributele lor (margini, centru, lățime). Layout-ul este ambiguu când constrângerile nu determină o singură soluție și conflictual când unele constrângeri nu pot fi satisfăcute simultan.

Fiecare view are nevoie de suficiente informații pentru poziția orizontală, poziția verticală, lățime și înălțime. Unele view-uri (UILabel, UIButton) au o dimensiune naturală (intrinsic content size), deci nu au nevoie de lățime și înălțime explicite.

SWIFT
let title = UILabel()
title.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(title)

NSLayoutConstraint.activate([
    title.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 16),
    title.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
    title.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16)
])

translatesAutoresizingMaskIntoConstraints = false este obligatoriu pentru view-urile create din cod; altfel sistemul adaugă constrângeri automate care intră în conflict cu ale tale.

Ambiguitate: lipsește o informație, de exemplu ai poziția, dar nu și înălțimea unui view fără dimensiune naturală. View-ul poate apărea cu dimensiune zero sau în poziții diferite.

Conflict: constrângerile se contrazic (lățime 200 și, simultan, margini care impun lățimea 300). În consolă apare mesajul „Unable to simultaneously satisfy constraints”, iar sistemul elimină una dintre constrângeri.

Unelte de rezolvare:

  • prioritățile (priority), cu valoarea 1000 obligatorie și valori mai mici opționale;
  • content hugging (rezistența la creștere) și compression resistance (rezistența la micșorare) decid cine cedează când două label-uri concurează pe același rând;
  • UIStackView reduce mult numărul de constrângeri manuale;
  • View Debugger din Xcode arată ierarhia 3D și constrângerile problematice.

Marginile se definesc cu leading și trailing, nu left și right, ca layout-ul să se inverseze corect în limbile scrise de la dreapta la stânga.

Ce urmărește intervievatorul: Se verifică experiența practică cu layout-ul în UIKit; un plus este menționarea priorităților, hugging/compression și leading/trailing.

58 Mid

Care este diferența dintre @StateObject, @ObservedObject, @EnvironmentObject și noul @Observable?

Răspuns scurt: @StateObject creează și deține un ObservableObject pe durata vieții view-ului, @ObservedObject doar observă un obiect primit din afară, iar @EnvironmentObject îl primește din environment. Din iOS 17, macro-ul @Observable înlocuiește acest model: obiectul se ține cu @State, se transmite ca proprietate simplă sau prin @Environment.

Modelul vechi (iOS 13–16), bazat pe Combine:

SWIFT
final class CartModel: ObservableObject {
    @Published var items: [String] = []
}

struct CartScreen: View {
    @StateObject private var cart = CartModel()      // creat și deținut aici
    var body: some View { CartList(cart: cart) }
}

struct CartList: View {
    @ObservedObject var cart: CartModel              // primit, nu deținut
    var body: some View { List(cart.items, id: \.self) { Text($0) } }
}

Greșeala clasică este @ObservedObject var cart = CartModel(): când părintele se redesenează, struct-ul copilului este recreat, deci se creează și un model nou, iar starea se pierde. @StateObject păstrează instanța.

@EnvironmentObject evită transmiterea manuală prin multe niveluri; dacă obiectul lipsește din environment, aplicația se oprește la rulare.

Modelul nou (iOS 17+, framework-ul Observation):

SWIFT
@Observable
final class CartModel {
    var items: [String] = []
}

struct CartScreen: View {
    @State private var cart = CartModel()
    var body: some View { CartList(cart: cart) }
}

struct CartList: View {
    let cart: CartModel        // fără property wrapper
    var body: some View { List(cart.items, id: \.self) { Text($0) } }
}

Avantajul major: urmărirea este per proprietate. Cu ObservableObject, orice @Published modificat redesenează toate view-urile care observă obiectul. Cu @Observable, se redesenează doar view-urile care au citit efectiv proprietatea schimbată. Pentru binding-uri către un obiect @Observable primit ca parametru folosești @Bindable.

Alegerea depinde de versiunea minimă de iOS a aplicației.

Ce urmărește intervievatorul: Întrebare foarte frecventă; se verifică dacă știi bugul @ObservedObject inițializat local și dacă cunoști modelul @Observable.

59 Mid

Cum implementezi navigarea în SwiftUI cu NavigationStack?

Răspuns scurt: NavigationStack (iOS 16+) gestionează o stivă de ecrane. Folosești NavigationLink(value:) pentru a adăuga o valoare în stivă și .navigationDestination(for:) pentru a decide ce ecran corespunde fiecărui tip de valoare. Ținând calea într-un NavigationPath sau array, poți controla navigarea programatic.

Înainte de iOS 16, NavigationView cu NavigationLink(destination:) lega direct destinația de buton și făcea dificilă navigarea programatică, de exemplu din deep links. NavigationStack separă valoarea de destinație:

SWIFT
enum Route: Hashable {
    case product(id: Int)
    case cart
}

struct ShopView: View {
    @State private var path: [Route] = []

    var body: some View {
        NavigationStack(path: $path) {
            List(1...20, id: \.self) { id in
                NavigationLink("Produs \(id)", value: Route.product(id: id))
            }
            .navigationTitle("Magazin")
            .navigationDestination(for: Route.self) { route in
                switch route {
                case .product(let id): ProductView(id: id, onBuy: { path.append(.cart) })
                case .cart: CartView(onDone: { path.removeAll() })
                }
            }
        }
    }
}

Avantaje:

  • navigarea este stare: path.append(...) deschide un ecran, path.removeLast() revine, path.removeAll() duce la rădăcină;
  • deep links devin simple: transformi URL-ul în valori Route și setezi path;
  • dacă Route este Codable, poți salva și restaura calea (cu NavigationPath și reprezentarea codable);
  • destinațiile sunt create leneș, doar la navigare.

Alte forme de prezentare: .sheet(item:), .fullScreenCover, .alert, iar pentru iPad și ecrane mari NavigationSplitView, care arată mai multe coloane.

Ca practică: pune .navigationDestination pe un view din interiorul stivei, nu în interiorul unui List lazy care poate fi eliberat, și evită mai multe NavigationStack imbricate, care produc bare de navigare duble și comportament imprevizibil. În aplicații mari, logica rutelor se mută într-un obiect router dedicat, ușor de testat.

Ce urmărește intervievatorul: Se verifică cunoașterea API-ului modern și a navigării bazate pe stare; deep linking este un exemplu bun de aplicare.

60 Mid

Într-un UITableView, la derulare apar imagini greșite în celule. De ce și cum rezolvi?

Răspuns scurt: Celulele sunt reutilizate, iar descărcarea pornită pentru rândul vechi se termină și pune imaginea în celula care acum afișează alt rând. Rezolvi prin resetare în prepareForReuse, anularea descărcării și verificarea că rezultatul aparține rândului curent.

Pentru performanță, UITableView și UICollectionView nu creează câte o celulă pentru fiecare rând. Păstrează doar celulele vizibile plus câteva în rezervă și le reciclează prin dequeueReusableCell(withIdentifier:for:).

Secvența care produce bugul: celula A afișează rândul 1 și pornește descărcarea imaginii 1. Utilizatorul derulează, celula A este reutilizată pentru rândul 15 și pornește descărcarea imaginii 15. Descărcarea imaginii 1 se termină mai târziu și o pune în celula A, care acum afișează rândul 15.

SWIFT
final class ProductCell: UITableViewCell {
    private var imageTask: Task<Void, Never>?
    private var currentURL: URL?

    func configure(with product: Product) {
        textLabel?.text = product.name
        currentURL = product.imageURL
        imageTask = Task { [weak self] in
            guard let url = product.imageURL,
                  let image = await ImageLoader.shared.image(for: url) else { return }
            guard !Task.isCancelled, self?.currentURL == url else { return }
            self?.imageView?.image = image
        }
    }

    override func prepareForReuse() {
        super.prepareForReuse()
        imageTask?.cancel()
        imageTask = nil
        currentURL = nil
        imageView?.image = nil
    }
}

Trei măsuri:

  • prepareForReuse resetează conținutul și anulează operațiile în desfășurare;
  • verifici că rezultatul corespunde încă elementului afișat;
  • folosești un cache, ca imaginile deja descărcate să apară instantaneu la revenire.

Aceeași reutilizare cauzează și alte buguri: un switch rămas activ, o culoare de fundal schimbată condiționat. Regula: configure trebuie să seteze fiecare proprietate pe toate ramurile, nu doar pe cea „specială”. Bibliotecile de imagini (de exemplu Kingfisher sau SDWebImage) rezolvă automat aceste probleme, dar la interviu se așteaptă să înțelegi mecanismul.

Ce urmărește intervievatorul: Este un bug clasic, iar întrebarea verifică dacă înțelegi reutilizarea celulelor și condițiile de cursă din UI.

61 Mid

Cum integrezi SwiftUI într-o aplicație UIKit și invers?

Răspuns scurt: Un ecran SwiftUI se afișează în UIKit prin UIHostingController(rootView:). O componentă UIKit se folosește în SwiftUI prin protocoalele UIViewRepresentable sau UIViewControllerRepresentable, cu un Coordinator pentru delegați și evenimente.

Migrarea treptată este cea mai comună situație în proiecte existente: ecranele noi sunt scrise în SwiftUI, iar restul aplicației rămâne UIKit.

SwiftUI în UIKit:

SWIFT
let settings = SettingsView(onLogout: { [weak self] in self?.logout() })
let host = UIHostingController(rootView: settings)
navigationController?.pushViewController(host, animated: true)

Pentru a include un view SwiftUI ca parte a unui ecran UIKit, adaugi host ca child view controller (addChild, view.addSubview, didMove(toParent:)). Din iOS 16, celulele pot afișa conținut SwiftUI prin UIHostingConfiguration.

UIKit în SwiftUI:

SWIFT
struct SearchBar: UIViewRepresentable {
    @Binding var text: String

    func makeUIView(context: Context) -> UISearchBar {
        let bar = UISearchBar()
        bar.delegate = context.coordinator
        return bar
    }

    func updateUIView(_ uiView: UISearchBar, context: Context) {
        if uiView.text != text { uiView.text = text }
    }

    func makeCoordinator() -> Coordinator { Coordinator(text: $text) }

    final class Coordinator: NSObject, UISearchBarDelegate {
        var text: Binding<String>
        init(text: Binding<String>) { self.text = text }
        func searchBar(_ searchBar: UISearchBar, textDidChange searchText: String) {
            text.wrappedValue = searchText
        }
    }
}

Responsabilitățile: makeUIView creează view-ul o singură dată, updateUIView sincronizează starea SwiftUI în view-ul UIKit la fiecare schimbare, iar Coordinator primește evenimentele UIKit și le trimite înapoi prin binding.

Capcane: în updateUIView evită modificările care declanșează din nou delegatul și produc bucle (de aceea comparația if uiView.text != text); nu recrea view-ul în updateUIView; transmite dimensiunile corect, eventual prin sizeThatFits (iOS 16+).

Ce urmărește intervievatorul: Verifică experiența cu proiecte hibride, foarte răspândite; rolul Coordinator și al updateUIView sunt detaliile cheie.

62 Mid

Ce faci ca o aplicație iOS să fie accesibilă?

Răspuns scurt: Te asiguri că elementele au etichete clare pentru VoiceOver, că textul respectă Dynamic Type, că există contrast suficient, zone de atingere mari și că informația nu e transmisă doar prin culoare. Testezi efectiv cu VoiceOver și cu Accessibility Inspector.

Accesibilitatea face aplicația utilizabilă de persoane cu deficiențe de vedere, auz sau motorii. Pentru unele categorii de aplicații este și o cerință legală, de exemplu prin European Accessibility Act, aplicabil din iunie 2025 anumitor servicii digitale din UE.

Elemente practice:

  • VoiceOver: elementele standard au etichete automate, dar butoanele doar cu iconiță nu. Adaugă accessibilityLabel („Adaugă în coș”, nu „plus”), accessibilityHint când acțiunea nu e evidentă și grupează elementele care formează o singură informație.
SWIFT
HStack {
    Image(systemName: "star.fill")
    Text("4,8")
}
.accessibilityElement(children: .combine)
.accessibilityLabel("Rating 4,8 din 5")

Button { addToCart() } label: { Image(systemName: "cart.badge.plus") }
    .accessibilityLabel("Adaugă în coș")
  • Dynamic Type: folosește stiluri de text (.font(.body), UIFont.preferredFont(forTextStyle:) cu adjustsFontForContentSizeCategory = true) în loc de dimensiuni fixe. Testează la dimensiunile cele mai mari și permite textului să treacă pe mai multe rânduri.
  • Contrast și culori: contrast suficient între text și fundal, verificat și în Dark Mode; nu transmite starea doar prin culoare (o eroare se marchează și prin text sau iconiță).
  • Zone de atingere: Apple recomandă minimum 44 x 44 puncte.
  • Reduce Motion: respectă accessibilityReduceMotion pentru animațiile mari.
  • trăsăturile elementelor (.isHeader, .isButton) ajută la navigarea rapidă cu rotorul VoiceOver.

Testare: pornești VoiceOver pe dispozitiv și parcurgi fluxurile principale fără să te uiți la ecran, folosești Accessibility Inspector din Xcode pentru audit automat și scrii teste UI care găsesc elementele după eticheta de accesibilitate, ceea ce le face și mai stabile.

Ce urmărește intervievatorul: Se verifică maturitatea profesională; mulți candidați nu au testat niciodată cu VoiceOver, iar cei care au făcut-o ies în evidență.

63 Senior

Un ecran SwiftUI complex devine lent. Cum identifici și reduci redesenările inutile?

Răspuns scurt: Măsori cu instrumentul SwiftUI din Instruments și cu Self._printChanges() ce view-uri se recalculează și de ce, apoi reduci dependențele: împarți view-urile mari în subview-uri care primesc doar datele necesare, folosești @Observable pentru urmărire per proprietate, identități stabile și containere lazy.

Performanța în SwiftUI depinde de cât de des se recalculează body și cât costă fiecare recalculare. Procesul:

1. Măsurare. Instruments are un template SwiftUI care arată numărul de evaluări ale fiecărui view și duratele (Xcode 26 a adăugat un instrument SwiftUI nou, mai detaliat). În dezvoltare, let _ = Self._printChanges() în body afișează ce proprietate a declanșat recalcularea.

2. Cauze frecvente și soluții:

  • un obiect mare ObservableObject cu multe @Published: orice modificare (de exemplu un timer care actualizează un contor) redesenează toate view-urile care îl observă. Soluții: migrarea la @Observable (iOS 17+), împărțirea în obiecte mai mici sau transmiterea doar a valorilor necesare.
  • un body uriaș: o schimbare mică recalculează tot. Extrage subview-uri ca struct-uri separate cu parametri minimi; SwiftUI poate sări peste recalcularea lor dacă intrările nu s-au schimbat.
SWIFT
struct PriceTag: View, Equatable {
    let price: Decimal
    var body: some View { Text(price, format: .currency(code: "RON")) }
}
  • muncă grea în body: sortări, filtrări, formatare de date cu formatter nou la fiecare apel. Mută calculul în model și păstrează rezultatul.
  • identitate instabilă: id generat la fiecare recalculare sau AnyView care ascunde structura forțează recrearea view-urilor și pierderea stării.
  • liste mari în VStack în loc de LazyVStack sau List, ceea ce creează toate rândurile deodată.
  • condiții if care schimbă tipul view-ului, când un modificator (de exemplu .opacity) ar păstra identitatea.

3. Verificare: măsori din nou pe un dispozitiv real, în configurația Release, pentru că build-ul Debug și simulatorul nu reflectă performanța reală.

Ce urmărește intervievatorul: Întrebare de senior: se urmărește un proces bazat pe măsurare și cunoașterea mecanismelor interne de invalidare, nu sfaturi generice.

64 Senior

Utilizatorii raportează sacadări la derularea unei liste. Cum investighezi?

Răspuns scurt: Reproduci pe un dispozitiv real în Release, apoi folosești Instruments (Time Profiler, Animation Hitches, Allocations) ca să vezi ce rulează pe main thread în cadrele lente. Cauzele tipice sunt decodarea imaginilor mari, calculele de layout, formatarea sau accesul sincron la disc pe main thread.

O sacadare (hitch) apare când un cadru nu este gata la timp: pe un ecran de 60 Hz ai aproximativ 16,7 ms pe cadru, iar pe ProMotion de 120 Hz aproximativ 8,3 ms. Orice muncă ce depășește acest buget pe main thread produce cadre pierdute.

Pași de investigație:

1. Reproducere pe dispozitivul cel mai slab suportat, cu build Release. Simulatorul folosește procesorul Mac-ului și ascunde problemele. 2. Animation Hitches în Instruments arată exact cadrele întârziate și dacă problema este în aplicație (commit) sau în randare. 3. Time Profiler pe intervalul cu sacadări, filtrat pe main thread, cu „Hide System Libraries” activat la început, arată funcțiile tale care consumă timp. 4. Allocations arată dacă se creează foarte multe obiecte la derulare.

Cauze frecvente și remedieri:

  • imagini mari decodate pe main thread: o fotografie de câțiva megapixeli afișată într-o miniatură. Le redimensionezi în fundal. Din iOS 15, UIImage.prepareThumbnail(of:) și byPreparingForDisplay() fac acest lucru eficient.
SWIFT
let thumb = await image.byPreparingThumbnail(ofSize: CGSize(width: 120, height: 120))
  • crearea de DateFormatter sau NumberFormatter pentru fiecare celulă: sunt costisitoare, deci le refolosești;
  • layout costisitor: Auto Layout complex cu multe stack-uri imbricate și dimensiuni calculate dinamic; poți simplifica ierarhia sau precalcula înălțimile;
  • umbre fără shadowPath, colțuri rotunjite cu masksToBounds pe multe straturi (offscreen rendering), vizibile cu opțiunile de debug ale Core Animation;
  • citiri sincrone din baza de date sau UserDefaults mari în cellForRowAt.

Folosește și prefetching (UITableViewDataSourcePrefetching) pentru a începe descărcarea înainte ca rândurile să apară. După fiecare modificare, măsori din nou ca să confirmi îmbunătățirea.

Ce urmărește intervievatorul: Verifică dacă ai un proces de diagnostic bazat pe unelte și cunoști cauzele reale; răspunsul „pun totul pe background” fără măsurare este slab.

Arhitectură, ciclu de viață, persistență și networking

65 Junior

Care sunt stările prin care trece o aplicație iOS și ce rol au AppDelegate și SceneDelegate?

Răspuns scurt: O aplicație poate fi Not Running, Inactive, Active, Background sau Suspended. AppDelegate gestionează evenimentele la nivel de proces (lansare, notificări push), iar din iOS 13 SceneDelegate gestionează fiecare fereastră (scenă) a aplicației: apariția în prim-plan, trecerea în fundal, deconectarea.

Stările:

  • Not Running: aplicația nu a fost pornită sau a fost închisă de sistem.
  • Inactive: în prim-plan, dar nu primește evenimente (în timpul unui apel, la deschiderea Control Center sau în tranziții).
  • Active: în prim-plan și primește evenimente; starea normală de utilizare.
  • Background: nu mai este vizibilă, dar codul poate rula încă un timp scurt sau pentru task-uri permise (audio, locație, descărcări).
  • Suspended: în memorie, dar nu execută cod. Sistemul o poate închide oricând, fără notificare, pentru a elibera memorie.
SWIFT
final class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    func sceneDidBecomeActive(_ scene: UIScene) { /* reiei timere, reîmprospătezi */ }
    func sceneWillResignActive(_ scene: UIScene) { /* pui pe pauză jocuri, video */ }
    func sceneDidEnterBackground(_ scene: UIScene) { /* salvezi starea, eliberezi resurse */ }
}

AppDelegate rămâne locul pentru application(_:didFinishLaunchingWithOptions:) (configurarea SDK-urilor, a analizelor), înregistrarea pentru notificări push și evenimente globale.

Separarea a apărut în iOS 13 pentru că pe iPad o aplicație poate avea mai multe ferestre simultan, fiecare cu propriul ciclu de viață. În aplicațiile SwiftUI, ambele sunt înlocuite de protocolul App și de scenePhase, dar poți păstra un AppDelegate prin @UIApplicationDelegateAdaptor.

Consecința importantă: când aplicația ajunge în fundal, trebuie să salvezi tot ce e important (un formular completat, poziția în conținut), pentru că din starea Suspended poate fi închisă fără ca vreun cod de-al tău să mai ruleze.

Ce urmărește intervievatorul: Se verifică înțelegerea ciclului de viață și a faptului că sistemul poate închide aplicația fără avertisment; candidații uită des de starea Suspended.

66 Junior

Cum reacționezi în SwiftUI la trecerea aplicației în fundal?

Răspuns scurt: Citești valoarea @Environment(\.scenePhase) și reacționezi cu .onChange(of: scenePhase). Valorile posibile sunt .active, .inactive și .background; de obicei salvezi datele la .background și reîmprospătezi la revenirea în .active.

Aplicațiile SwiftUI pornesc dintr-un tip care respectă protocolul App, fără AppDelegate obligatoriu:

SWIFT
@main
struct NotesApp: App {
    @Environment(\.scenePhase) private var scenePhase
    @State private var store = NotesStore()

    var body: some Scene {
        WindowGroup {
            NotesListView(store: store)
        }
        .onChange(of: scenePhase) { _, newPhase in
            switch newPhase {
            case .background:
                store.saveToDisk()
            case .active:
                store.refreshIfNeeded()
            case .inactive:
                break
            @unknown default:
                break
            }
        }
    }
}

Semnătura .onChange(of:) { oldValue, newValue in } cu doi parametri este disponibilă din iOS 17; pe versiuni mai vechi există varianta cu un singur parametru, acum marcată ca depreciată.

Detalii utile:

  • scenePhase citit în App reflectă starea agregată a tuturor scenelor, iar citit într-un view reflectă starea scenei din care face parte acel view;
  • @unknown default tratează eventualele cazuri adăugate în versiuni viitoare ale enum-ului;
  • pentru evenimente pe care SwiftUI nu le expune (token-ul de notificări push, unele SDK-uri terțe), adaugi un AppDelegate clasic prin @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate.

O greșeală frecventă este salvarea datelor doar la închiderea aplicației: nu există un eveniment fiabil pentru momentul în care sistemul închide o aplicație suspendată. Salvarea la intrarea în fundal (sau imediat după fiecare modificare importantă) este abordarea corectă. Tot la .background merită oprite operațiile costisitoare și ascunse datele sensibile din captura folosită de app switcher.

Ce urmărește intervievatorul: Verifică dacă știi ciclul de viață în varianta SwiftUI; un plus este explicația de ce salvezi la .background.

67 Junior

Ce pui și ce nu pui în UserDefaults?

Răspuns scurt: UserDefaults este potrivit pentru setări și preferințe mici: tema aleasă, dacă onboarding-ul a fost văzut, ultima filtrare. Nu este potrivit pentru date sensibile (tokenuri, parole), care merg în Keychain, și nici pentru volume mari de date, care merg în fișiere sau într-o bază de date.

UserDefaults stochează perechi cheie-valoare într-un fișier plist din containerul aplicației. Datele sunt încărcate în memorie, iar accesul este sincron.

SWIFT
let defaults = UserDefaults.standard
defaults.set(true, forKey: "hasSeenOnboarding")
let seen = defaults.bool(forKey: "hasSeenOnboarding")   // false dacă lipsește

// SwiftUI
struct SettingsView: View {
    @AppStorage("prefersDarkMode") private var prefersDarkMode = false
    var body: some View { Toggle("Mod întunecat", isOn: $prefersDarkMode) }
}

Potrivit:

  • preferințe ale utilizatorului și flag-uri de stare ale aplicației;
  • valori simple: Bool, Int, String, Date, Data, array-uri și dicționare ale acestora;
  • obiecte mici Codable, convertite în Data.

Nepotrivit:

  • tokenuri de autentificare, parole, date personale sensibile: fișierul nu este criptat separat (are doar protecția generală a containerului), apare în backup-uri și poate fi citit pe dispozitive compromise. Pentru ele folosești Keychain.
  • liste mari, imagini, istoricul complet al comenzilor: încetinesc pornirea aplicației, pentru că plist-ul este încărcat, și nu oferă interogări. Folosești fișiere, SwiftData, Core Data sau SQLite.
  • date partajate între aplicație și extensii (widget-uri): ai nevoie de UserDefaults(suiteName:) cu un App Group.

Detalii: folosește constante sau un enum pentru chei, ca să eviți greșelile de scriere; valorile implicite pot fi înregistrate cu register(defaults:). Apelul synchronize() nu mai este necesar de mult timp. Din 2024, Apple cere declararea motivului folosirii UserDefaults în privacy manifest (PrivacyInfo.xcprivacy), fiind un „required reason API”.

Ce urmărește intervievatorul: Se verifică judecata privind securitatea și volumul datelor; stocarea tokenului în UserDefaults este greșeala clasică pe care intervievatorul o caută.

68 Junior

Ce este Keychain și când îl folosești?

Răspuns scurt: Keychain este spațiul de stocare criptat al sistemului pentru date mici și sensibile: tokenuri de acces, parole, chei. Datele sunt protejate de sistem, pot fi legate de deblocarea dispozitivului și pot fi partajate controlat între aplicațiile aceluiași dezvoltator.

Spre deosebire de UserDefaults, Keychain criptează datele, iar accesul este controlat de sistemul de operare. API-ul nativ (Security framework) este de nivel jos, bazat pe dicționare, așa că multe echipe îl înfășoară într-un tip mic sau folosesc o bibliotecă.

SWIFT
import Security

enum KeychainError: Error { case status(OSStatus) }

func saveToken(_ token: String, account: String) throws {
    let data = Data(token.utf8)
    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: account
    ]
    SecItemDelete(query as CFDictionary)   // înlocuiește valoarea existentă

    var attributes = query
    attributes[kSecValueData as String] = data
    attributes[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly

    let status = SecItemAdd(attributes as CFDictionary, nil)
    guard status == errSecSuccess else { throw KeychainError.status(status) }
}

Detalii care contează:

  • accesibilitatea (kSecAttrAccessible) decide când pot fi citite datele. AfterFirstUnlock permite citirea și în fundal după prima deblocare de la pornirea telefonului; WhenUnlocked doar cu ecranul deblocat. Sufixul ThisDeviceOnly împiedică transferul pe alt dispozitiv prin backup.
  • elementele din Keychain pot rămâne pe dispozitiv chiar după dezinstalarea aplicației. Dacă aplicația presupune că un utilizator nou nu are token, verifică la prima pornire (de exemplu printr-un flag în UserDefaults) și curăță valorile vechi.
  • pentru date legate de biometrie, poți folosi access control cu Face ID sau Touch ID.
  • partajarea între aplicații și extensii se face prin keychain access groups.

Keychain nu este o bază de date: păstrează acolo doar secrete mici, nu profilul complet al utilizatorului.

Ce urmărește intervievatorul: Verifică dacă tratezi corect datele sensibile; detaliul că elementele supraviețuiesc dezinstalării arată experiență practică.

69 Junior

Scrie o funcție care descarcă o listă de utilizatori dintr-un API JSON folosind URLSession și async/await.

Răspuns scurt: Construiești URL-ul, apelezi try await URLSession.shared.data(from:), verifici că răspunsul este HTTPURLResponse cu cod 2xx, apoi decodezi datele cu JSONDecoder într-un model Decodable. Erorile de rețea, de status și de decodare se propagă prin throws.

SWIFT
struct User: Decodable, Identifiable {
    let id: Int
    let name: String
    let email: String
}

enum APIError: Error {
    case invalidResponse
    case httpStatus(Int)
}

func fetchUsers() async throws -> [User] {
    guard let url = URL(string: "https://jsonplaceholder.typicode.com/users") else {
        throw URLError(.badURL)
    }

    var request = URLRequest(url: url)
    request.setValue("application/json", forHTTPHeaderField: "Accept")
    request.timeoutInterval = 15

    let (data, response) = try await URLSession.shared.data(for: request)

    guard let http = response as? HTTPURLResponse else {
        throw APIError.invalidResponse
    }
    guard (200..<300).contains(http.statusCode) else {
        throw APIError.httpStatus(http.statusCode)
    }

    return try JSONDecoder().decode([User].self, from: data)
}

Puncte pe care intervievatorul le urmărește:

  • verificarea status code-ului: URLSession nu aruncă eroare pentru 404 sau 500. Un răspuns 500 cu un mesaj HTML ar ajunge la decodor și ar produce o eroare de decodare confuză.
  • tipuri de erori separate: lipsa conexiunii (URLError), eroarea HTTP și eroarea de decodare trebuie afișate diferit utilizatorului.
  • folosirea din UI: apelul se face dintr-un view model @MainActor, iar rezultatul actualizează starea; URLSession rulează rețeaua în afara main thread-ului.
  • App Transport Security: iOS blochează implicit cererile HTTP necriptate; folosește HTTPS.

Pentru producție, extinzi soluția cu un client reutilizabil: URL de bază configurabil, header de autentificare, strategii de decodare (keyDecodingStrategy, dateDecodingStrategy), retry pentru erori temporare și injectarea unui URLSession configurat, astfel încât codul să poată fi testat.

Ce urmărește intervievatorul: Exercițiu practic tipic pentru temele de casă; se verifică în special tratarea status code-ului și a erorilor, nu doar fluxul fericit.

70 Junior

Ce este MVC în UIKit și ce înseamnă „Massive View Controller”?

Răspuns scurt: MVC separă aplicația în Model (date și reguli), View (afișare) și Controller (legătura dintre ele). În UIKit, view controller-ul ajunge des să conțină rețea, formatare, validări și navigare, devenind uriaș și greu de testat; acesta este „Massive View Controller”.

MVC este arhitectura promovată istoric de Apple pentru UIKit:

  • Model: struct-uri și clase de domeniu, reguli de business, persistență;
  • View: UIView, celule, elemente vizuale, fără logică de business;
  • Controller: UIViewController, care primește acțiunile utilizatorului, actualizează modelul și reîmprospătează view-ul.

Problema este că în UIKit view-ul și controller-ul sunt strâns legate: view controller-ul gestionează ciclul de viață al view-ului, delegații tabelului, tastatura, animațiile. Când se adaugă cererile de rețea, parsarea, formatarea datelor, validarea formularelor și navigarea, fișierul ajunge la mii de linii.

Consecințe:

  • logica nu poate fi testată fără a instanția un view controller și ierarhia lui;
  • modificările mici riscă să strice părți fără legătură;
  • conflicte frecvente în Git, pentru că toată lumea lucrează în același fișier.

Remedii, chiar fără a schimba arhitectura:

  • extragi data source-ul tabelului într-un obiect separat;
  • muți rețeaua într-un serviciu (UserService) injectat;
  • muți formatarea într-un tip dedicat (PriceFormatter);
  • împarți ecranele mari în child view controllers;
  • muți navigarea într-un coordinator.
SWIFT
final class ProfileViewController: UIViewController {
    private let service: ProfileService
    init(service: ProfileService) {
        self.service = service
        super.init(nibName: nil, bundle: nil)
    }
    required init?(coder: NSCoder) { fatalError("init(coder:) nu este folosit") }
}

Alternativele cele mai folosite sunt MVVM (logica de prezentare într-un view model testabil), VIPER sau Clean Architecture pentru aplicații mari și, în SwiftUI, abordări bazate pe stare, precum The Composable Architecture. Alegerea depinde de mărimea echipei și a aplicației.

Ce urmărește intervievatorul: Se verifică dacă recunoști problemele MVC în practică și știi metode concrete de a le reduce, nu doar numele altor arhitecturi.

71 Mid

Cum aplici MVVM într-o aplicație SwiftUI și ce responsabilități are view model-ul?

Răspuns scurt: View-ul afișează starea și transmite acțiunile utilizatorului, iar view model-ul (de obicei @MainActor și @Observable) ține starea ecranului, apelează serviciile și transformă datele de domeniu în date gata de afișat. Serviciile sunt injectate prin protocoale, ca view model-ul să poată fi testat.

SWIFT
protocol ArticlesService {
    func latest() async throws -> [Article]
}

@MainActor
@Observable
final class ArticlesViewModel {
    enum State { case idle, loading, loaded([ArticleRow]), failed(String) }

    private(set) var state: State = .idle
    private let service: ArticlesService

    init(service: ArticlesService) { self.service = service }

    func onAppear() async {
        state = .loading
        do {
            let articles = try await service.latest()
            state = .loaded(articles.map(ArticleRow.init))
        } catch {
            state = .failed("Nu am putut încărca articolele.")
        }
    }
}

struct ArticlesView: View {
    @State var viewModel: ArticlesViewModel

    var body: some View {
        Group {
            switch viewModel.state {
            case .idle, .loading: ProgressView()
            case .loaded(let rows): List(rows) { Text($0.title) }
            case .failed(let message): Text(message)
            }
        }
        .task { await viewModel.onAppear() }
    }
}

Responsabilitățile view model-ului:

  • starea ecranului, preferabil ca enum, ca să nu existe combinații imposibile;
  • logica de prezentare: formatare, sortare, mesaje de eroare prietenoase;
  • coordonarea apelurilor către servicii;
  • nimic din SwiftUI sau UIKit (fără Color, Image, UIViewController), ca să fie testabil simplu.

Ce nu face: nu ține logica de business complexă (aceea stă în servicii sau în domeniu) și nu navighează direct, ci expune o intenție sau primește un callback.

Testul devine simplu: creezi view model-ul cu un FakeArticlesService, apelezi onAppear() și verifici state.

O discuție de nivel mid: în SwiftUI, view-ul este deja o funcție de stare, iar unii argumentează că view model-ul este redundant pentru ecrane simple. O poziție echilibrată: pentru ecrane cu logică, rețea și teste, view model-ul aduce claritate; pentru componente mici, @State local este suficient.

Ce urmărește intervievatorul: Intervievatorul verifică separarea responsabilităților și testabilitatea; un plus este o opinie argumentată despre când MVVM nu e necesar.

72 Mid

Cum alegi între SwiftData, Core Data, SQLite și fișiere pentru persistență?

Răspuns scurt: Pentru câteva obiecte sau un cache simplu, fișierele Codable sunt suficiente. Pentru date relaționale, interogări și volum mare, Core Data (matur, iOS 3+) sau SwiftData (modern, iOS 17+, construit peste Core Data). SQLite direct, de obicei printr-o bibliotecă precum GRDB, oferă control maxim asupra SQL-ului.

Criteriile de alegere: volumul datelor, nevoia de interogări și relații, versiunea minimă de iOS, sincronizarea și experiența echipei.

Fișiere Codable în directorul Application Support sau Caches:

SWIFT
let url = URL.applicationSupportDirectory.appending(path: "favorites.json")
try FileManager.default.createDirectory(at: .applicationSupportDirectory, withIntermediateDirectories: true)
try JSONEncoder().encode(favorites).write(to: url, options: .atomic)

Simplu și transparent, dar citești și scrii tot fișierul, fără interogări; potrivit pentru zeci sau sute de elemente.

Core Data: un framework de gestionare a grafului de obiecte, cu persistență în SQLite, relații, migrări, încărcare leneșă (faulting), integrare cu NSFetchedResultsController și sincronizare iCloud prin NSPersistentCloudKitContainer. Puternic, dar cu reguli stricte privind thread-urile: obiectele unui context nu se folosesc din alt context.

SwiftData (iOS 17+): modele definite cu macro-ul @Model, interogări cu @Query în SwiftUI, sintaxă mult mai simplă. Funcționalitatea s-a extins în versiunile ulterioare, dar pentru cerințe avansate sau suport pentru versiuni mai vechi de iOS, Core Data rămâne mai complet.

SWIFT
@Model
final class Note {
    var text: String
    var createdAt: Date
    init(text: String) { self.text = text; createdAt = .now }
}

SQLite direct (GRDB, SQLite.swift): control complet al schemei și al interogărilor, performanță predictibilă, potrivit pentru echipe care gândesc în SQL sau pentru date partajate cu Android.

Indiferent de alegere: izolează persistența în spatele unui protocol (NotesRepository), ca să o poți schimba sau simula în teste, planifică migrările de schemă de la prima versiune și nu salva în Documents date care nu sunt create de utilizator, pentru că acel director este vizibil în aplicația Fișiere dacă activezi partajarea.

Ce urmărește intervievatorul: Se verifică dacă alegi argumentat, în funcție de context; candidații slabi aleg o tehnologie din obișnuință, fără să discute compromisurile.

73 Mid

Cum ai proiecta stratul de networking al unei aplicații?

Răspuns scurt: Un client HTTP central, injectat prin protocol, primește descrieri de endpoint-uri (cale, metodă, parametri, tip de răspuns), adaugă autentificarea, verifică status code-ul, decodează și mapează erorile în tipuri clare pentru aplicație. Logging-ul, retry-ul și reîmprospătarea tokenului stau în același loc, nu în fiecare ecran.

Scopul este ca ecranele să ceară date („dă-mi comenzile”), fără să știe de URL-uri, headere sau coduri HTTP.

SWIFT
struct Endpoint<Response: Decodable> {
    let path: String
    var method = "GET"
    var query: [URLQueryItem] = []
    var body: Data? = nil
}

protocol HTTPClient {
    func send<R: Decodable>(_ endpoint: Endpoint<R>) async throws -> R
}

enum NetworkError: Error {
    case unauthorized, server(Int), decoding(Error)
}

final class APIClient: HTTPClient {
    private let baseURL: URL
    private let session: URLSession
    private let tokenProvider: () async throws -> String?

    init(baseURL: URL, session: URLSession = .shared,
         tokenProvider: @escaping () async throws -> String?) {
        self.baseURL = baseURL; self.session = session; self.tokenProvider = tokenProvider
    }

    func send<R: Decodable>(_ endpoint: Endpoint<R>) async throws -> R {
        var components = URLComponents(url: baseURL.appending(path: endpoint.path),
                                       resolvingAgainstBaseURL: false)!
        components.queryItems = endpoint.query.isEmpty ? nil : endpoint.query
        var request = URLRequest(url: components.url!)
        request.httpMethod = endpoint.method
        request.httpBody = endpoint.body
        if let token = try await tokenProvider() {
            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
        }
        let (data, response) = try await session.data(for: request)
        let status = (response as? HTTPURLResponse)?.statusCode ?? 0
        if status == 401 { throw NetworkError.unauthorized }
        guard (200..<300).contains(status) else { throw NetworkError.server(status) }
        do { return try JSONDecoder().decode(R.self, from: data) }
        catch { throw NetworkError.decoding(error) }
    }
}

De discutat: endpoint-urile tipizate împiedică decodarea în tipul greșit, protocolul permite un client fals în teste, erorile mapate permit mesaje diferite, retry doar pentru GET și erori temporare, iar refresh-ul tokenului la 401 se coordonează centralizat.

Ce urmărește intervievatorul: Se verifică gândirea de design: separarea responsabilităților, testabilitate și tratarea erorilor la nivelul întregii aplicații.

74 Mid

Ce este dependency injection și cum îl aplici într-o aplicație iOS?

Răspuns scurt: Dependency injection înseamnă că un obiect își primește dependențele din afară (prin inițializator, proprietate sau environment), în loc să le creeze singur sau să folosească singleton-uri. Codul devine testabil, configurabil și cu dependențe vizibile.

Fără DI, un view model își creează singur serviciile sau folosește singleton-uri:

SWIFT
final class LoginViewModel {
    func login() async throws {
        try await AuthService.shared.login()   // dependență ascunsă, greu de testat
    }
}

În test nu poți înlocui AuthService.shared cu o versiune falsă, deci testul va face cereri reale.

Cu injectare prin inițializator (forma cea mai simplă și mai clară):

SWIFT
protocol AuthServicing {
    func login(email: String, password: String) async throws -> Session
}

@MainActor
final class LoginViewModel {
    private let auth: AuthServicing
    init(auth: AuthServicing) { self.auth = auth }
}

// producție
let vm = LoginViewModel(auth: AuthService(client: apiClient))
// test
let vmTest = LoginViewModel(auth: FakeAuthService(result: .success(.mock)))

Unde se construiesc obiectele: într-un composition root, de obicei la pornirea aplicației sau într-un container simplu care știe să creeze ecranele cu dependențele lor. Coordinatorii sau fabricile de ecrane folosesc acest container.

Variante:

  • injectare prin proprietate, necesară uneori în UIKit când view controller-ul vine din storyboard;
  • @Environment în SwiftUI, cu chei proprii (EnvironmentValues extins, mai simplu din iOS 18 cu macro-ul @Entry), util pentru dependențe folosite de multe view-uri;
  • biblioteci precum Factory sau swift-dependencies, utile în proiecte mari.

Singleton-urile nu sunt interzise: URLSession.shared sau un logger global sunt acceptabile. Problema apare când logica de business accesează direct singleton-uri mutabile. Un compromis pragmatic este parametrul cu valoare implicită: init(auth: AuthServicing = AuthService.shared), care păstrează apelurile simple și permite testarea.

Ce urmărește intervievatorul: Intervievatorul verifică dacă scrii cod testabil; un răspuns matur nu demonizează singleton-urile, ci explică problema dependențelor ascunse.

75 Mid

Cum rulezi muncă în fundal pe iOS și ce limite impune sistemul?

Răspuns scurt: iOS nu permite rularea liberă în fundal. Ai la dispoziție câteva mecanisme: timp suplimentar scurt după intrarea în fundal, BGTaskScheduler pentru reîmprospătări și procesări programate de sistem, sesiuni URLSession de fundal pentru transferuri și moduri speciale (audio, locație, VoIP) justificate de funcționalitate.

Sistemul protejează bateria și performanța, așa că decide singur când și cât rulează aplicația în fundal.

Mecanismele principale:

  • timp suplimentar scurt: UIApplication.shared.beginBackgroundTask cere câteva secunde în plus pentru a termina o operație începută (de exemplu salvarea unui formular). Trebuie să închei task-ul cu endBackgroundTask, altfel aplicația poate fi închisă.
  • BGTaskScheduler (iOS 13+): BGAppRefreshTask pentru reîmprospătări scurte (de exemplu descărcarea noutăților) și BGProcessingTask pentru muncă mai lungă, care poate cere alimentare la încărcător sau rețea. Sistemul decide momentul, în funcție de obiceiurile utilizatorului și de baterie; nu există garanția unei ore exacte.
SWIFT
BGTaskScheduler.shared.register(forTaskWithIdentifier: "ro.app.refresh", using: nil) { task in
    let work = Task {
        await FeedStore.shared.refresh()
        task.setTaskCompleted(success: true)
    }
    task.expirationHandler = { work.cancel() }
}

let request = BGAppRefreshTaskRequest(identifier: "ro.app.refresh")
request.earliestBeginDate = Date(timeIntervalSinceNow: 60 * 60)
try? BGTaskScheduler.shared.submit(request)

Identificatorii trebuie declarați în Info.plist (BGTaskSchedulerPermittedIdentifiers), iar capabilitatea Background Modes trebuie activată.

  • URLSession de fundal: descărcările și încărcările continuă gestionate de sistem chiar dacă aplicația este suspendată sau închisă; aplicația este trezită la final.
  • notificări push silențioase: pot trezi aplicația pentru puțin timp, dar sistemul le limitează frecvența.
  • moduri speciale: redare audio, navigație cu locație, VoIP. Folosirea lor fără o funcționalitate reală duce la respingere în App Review.

Dacă utilizatorul închide forțat aplicația din app switcher, reîmprospătările în fundal nu mai rulează până la următoarea deschidere. Testarea se face din debugger, cu comenzi LLDB care simulează lansarea task-ului.

Ce urmărește intervievatorul: Verifică dacă știi limitele reale ale platformei; candidații care vin din Android sau backend se așteaptă des la servicii care rulează oricât.

76 Senior

Cum ai proiecta o aplicație care funcționează offline și sincronizează datele cu serverul?

Răspuns scurt: Baza locală devine sursa de adevăr pentru UI, modificările intră într-o coadă trimisă la server când revine rețeaua, sincronizarea este incrementală, iar conflictele se rezolvă după o strategie definită (ultima scriere câștigă, versiuni, îmbinare).

Arhitectura de bază, „offline-first”:

  • sursa de adevăr locală: ecranele citesc doar din baza locală (SwiftData, Core Data, GRDB). Rețeaua actualizează baza, iar UI-ul reacționează la schimbări. Astfel aplicația arată date imediat, cu sau fără conexiune.
  • coada de operații (outbox): fiecare modificare a utilizatorului se scrie local și se adaugă ca operație persistentă („creează notița X”, „marchează comanda Y”). Un sincronizator trimite operațiile în ordine când există conexiune (NWPathMonitor detectează schimbările de rețea) și le șterge doar după confirmarea serverului.
  • idempotență: fiecare operație are un identificator unic generat pe client; dacă trimiterea se repetă după un timeout, serverul nu creează duplicate.
  • sincronizare incrementală: clientul cere doar schimbările de după ultimul cursor sau timestamp primit de la server, inclusiv ștergerile (tombstones).
SWIFT
struct PendingOperation: Codable, Identifiable {
    let id: UUID              // cheie de idempotență
    let entityID: UUID
    let kind: Kind
    let payload: Data
    let createdAt: Date
    var attempts: Int
    enum Kind: String, Codable { case create, update, delete }
}

Conflictele sunt partea dificilă și depind de domeniu: „ultima scriere câștigă” este simplu, dar poate pierde date; numerele de versiune permit serverului să refuze o actualizare bazată pe date vechi, cu rezolvare ulterioară; pentru documente editate colaborativ există structuri specializate (CRDT).

Alte decizii: ce date sunt disponibile offline, retry cu pauză crescătoare, starea de sincronizare afișată în UI și teste cu rețea instabilă. Dacă datele sunt doar ale utilizatorului și ecosistemul este Apple, NSPersistentCloudKitContainer sau CloudKit pot rezolva o mare parte din sincronizare fără server propriu.

Ce urmărește intervievatorul: Întrebare de design de sistem pe mobil; se urmărește gândirea în compromisuri (conflicte, idempotență, consistență), nu o soluție unică.

77 Senior

Cum ai modulariza o aplicație iOS mare și ce câștigi?

Răspuns scurt: Împarți codul în pachete Swift Package Manager (Core, Networking, DesignSystem, câte unul pe feature), cu dependențe într-o singură direcție și API public minim. Câștigi compilare mai rapidă, granițe clare între echipe, teste izolate și aplicații demo pe feature.

Într-un singur target mare, orice fișier poate depinde de orice alt fișier, compilarea devine lentă, iar schimbările au efecte greu de prevăzut.

O structură tipică:

App (target subțire: compune modulele, configurează dependențele)
 ├── Features/Checkout, Features/Profile, Features/Search
 ├── DesignSystem (culori, fonturi, componente UI)
 ├── Networking (client HTTP, endpoint-uri)
 ├── Persistence
 └── Core (modele de domeniu, utilitare, fără UIKit/SwiftUI)
SWIFT
// Package.swift (fragment)
.target(name: "Checkout", dependencies: ["DesignSystem", "Networking", "Core"]),
.testTarget(name: "CheckoutTests", dependencies: ["Checkout"])

Reguli:

  • dependențele merg într-o singură direcție: feature-urile depind de modulele de bază, niciodată invers, iar feature-urile nu depind direct unele de altele. Navigarea între ele trece prin interfețe (protocoale sau rute) definite într-un modul comun, implementate de target-ul aplicației.
  • API public mic: doar ce marchezi public este accesibil; restul poate fi schimbat liber.
  • modulele de interfață: pentru dependențe grele, separi protocolul (AnalyticsInterface) de implementare, ca feature-urile să compileze fără implementarea concretă.

Beneficii: Xcode recompilează doar modulele afectate; testele unui modul rulează rapid, fără aplicația întreagă; o aplicație demo pentru un singur feature pornește în câteva secunde; echipele au proprietate clară asupra modulelor, iar conflictele în project.pbxproj scad, pentru că pachetele SPM sunt descrise în cod.

Costuri: configurare inițială, granițe greu de schimbat dacă sunt alese prost, nevoia de a decide ce intră în Core fără să devină un „modul de tot ce nu are loc”. Recomandarea pragmatică este să modularizezi incremental, începând cu straturile stabile (DesignSystem, Networking), nu printr-o rescriere completă.

Ce urmărește intervievatorul: Se verifică experiența cu aplicații mari și gândirea despre dependențe; candidații buni menționează și costurile, nu doar beneficiile.

Testare, depanare și App Store

78 Junior

Cum scrii un test unitar pentru o funcție simplă în Xcode?

Răspuns scurt: Creezi un target de teste, importi modulul cu @testable import, apoi scrii o metodă de test care pregătește datele, apelează funcția și verifică rezultatul. Cu XCTest metodele încep cu test și folosesc XCTAssertEqual; cu Swift Testing (Xcode 16+) folosești @Test și #expect.

Funcția testată:

SWIFT
struct PriceCalculator {
    func total(prices: [Decimal], discountPercent: Decimal) -> Decimal {
        let sum = prices.reduce(0, +)
        return sum - sum * discountPercent / 100
    }
}

Cu XCTest:

SWIFT
import XCTest
@testable import Shop

final class PriceCalculatorTests: XCTestCase {
    func test_total_appliesDiscount() {
        let sut = PriceCalculator()
        let result = sut.total(prices: [100, 50], discountPercent: 10)
        XCTAssertEqual(result, 135)
    }

    func test_total_emptyCart_isZero() {
        XCTAssertEqual(PriceCalculator().total(prices: [], discountPercent: 20), 0)
    }
}

Cu Swift Testing (inclus în Xcode 16+):

SWIFT
import Testing
@testable import Shop

@Test(arguments: [(Decimal(0), Decimal(150)), (10, 135), (100, 0)])
func totalWithDiscount(discount: Decimal, expected: Decimal) {
    #expect(PriceCalculator().total(prices: [100, 50], discountPercent: discount) == expected)
}

Structura unui test bun este Arrange, Act, Assert: pregătești datele, execuți o singură acțiune și verifici rezultatul. Numele testului descrie comportamentul, nu implementarea. sut (system under test) este o convenție pentru obiectul testat.

Folosirea lui Decimal pentru bani, în loc de Double, evită erorile de rotunjire care ar face un test cu 0.1 + 0.2 să eșueze.

@testable import permite accesul la membrii internal. Testele rulează cu Cmd+U, iar rezultatele apar în Test Navigator. Testele parametrizate din Swift Testing reduc repetarea: același test rulează pentru mai multe seturi de date, iar fiecare caz apare separat în raport.

Ce urmărește intervievatorul: Verifică dacă ai scris efectiv teste și dacă știi structura unui test bun; cunoașterea Swift Testing arată că ești la zi.

79 Junior

Cum depanezi o problemă cu breakpoints și LLDB în Xcode?

Răspuns scurt: Pui un breakpoint pe linia suspectă, inspectezi variabilele în panoul de debug sau cu v, p și po în LLDB și avansezi pas cu pas. Breakpoint-urile pot avea condiții și acțiuni, iar cele de eroare opresc execuția unde apare problema.

Un flux de depanare eficient:

1. Reproduci problema cu pași clari. 2. Pui un breakpoint făcând clic pe marginea editorului, pe linia unde suspectezi problema. 3. Inspectezi starea în Variables View sau în consolă:

(lldb) v user.name          // citește variabila direct, rapid
(lldb) p items.count        // evaluează o expresie
(lldb) po viewModel         // afișează descrierea obiectului
(lldb) expr isLoading = false   // modifică o valoare în timpul rulării
(lldb) bt                   // stack trace-ul thread-ului curent

4. Avansezi cu Step Over (execută linia curentă), Step Into (intră în funcție), Step Out (ieși din funcția curentă) și Continue.

Tipuri utile de breakpoints:

  • condiționale: se opresc doar când condiția e adevărată, de exemplu product.id == 42, util în bucle lungi;
  • cu acțiuni: afișează un mesaj sau rulează o comandă și continuă automat, fără să mai adaugi print și să recompilezi;
  • Swift Error Breakpoint și Exception Breakpoint (din Breakpoint Navigator): opresc execuția exact unde este aruncată o eroare, nu unde este prinsă;
  • Symbolic Breakpoint: se oprește la orice apel al unei metode, chiar fără sursă, de exemplu UIViewAlertForUnsatisfiableConstraints pentru problemele de Auto Layout.

Alte unelte: View Hierarchy Debugger pentru probleme vizuale, Memory Graph pentru leak-uri, Main Thread Checker și Thread Sanitizer pentru probleme de concurență.

Diferența dintre po și v: v citește direct memoria variabilei, fără să compileze cod, deci este mai rapid și mai fiabil; po și p evaluează expresii și pot eșua în contexte optimizate. În build Release, multe variabile sunt optimizate și nu mai pot fi inspectate.

Ce urmărește intervievatorul: Se verifică dacă știi depana sistematic, nu doar cu print; cunoașterea breakpoint-urilor condiționale și de eroare este semn de experiență.

80 Junior

Care sunt pașii pentru a publica o aplicație în App Store?

Răspuns scurt: Ai nevoie de un cont Apple Developer Program, un Bundle ID și aplicația creată în App Store Connect. Arhivezi și încarci build-ul semnat din Xcode, îl testezi în TestFlight, completezi pagina din magazin și confidențialitatea, apoi trimiți la App Review.

Pașii în ordine:

1. Contul: înscriere în Apple Developer Program (taxă anuală), ca persoană fizică sau ca organizație. Pentru organizații este necesar un număr D-U-N-S. 2. Identitatea aplicației: Bundle ID unic (de exemplu ro.firma.aplicatie) și capabilitățile necesare (push, Sign in with Apple, App Groups). 3. Semnarea: un certificat de distribuție și un provisioning profile. Varianta simplă este „Automatically manage signing” în Xcode, care le gestionează pentru tine. 4. App Store Connect: creezi înregistrarea aplicației cu numele, limba principală, SKU-ul și Bundle ID-ul. 5. Build-ul: setezi versiunea (CFBundleShortVersionString, de exemplu 1.2.0) și numărul de build (CFBundleVersion, unic pentru fiecare încărcare), apoi Product > Archive și „Distribute App” din Organizer. 6. TestFlight: build-ul procesat poate fi testat intern imediat de membrii echipei; pentru testeri externi este necesară o revizuire scurtă (Beta App Review). 7. Pagina din magazin: descriere, cuvinte cheie, capturi de ecran pentru dimensiunile cerute, iconiță, URL de suport și politica de confidențialitate, „App Privacy” (ce date colectezi și în ce scop), clasificarea de vârstă, prețul și țările de distribuție. 8. App Review: trimiți versiunea la revizuire. Pentru aplicații cu cont, oferi un cont demo funcțional în notele pentru revizori. 9. Lansarea: manuală, automată după aprobare sau eșalonată (phased release, pe parcursul a 7 zile pentru actualizări).

Cerințe frecvent uitate: posibilitatea de a șterge contul din aplicație dacă aplicația permite crearea de cont, privacy manifest pentru SDK-urile terțe, texte de permisiune (NSCameraUsageDescription) clare și specifice, și compilarea cu SDK-ul minim cerut de Apple la momentul trimiterii.

Ce urmărește intervievatorul: Verifică dacă ai trecut efectiv prin proces sau îl înțelegi complet; diferența dintre versiune și build number este un detaliu des întrebat.

81 Junior

Aplicația dă crash în producție. Cum afli cauza?

Răspuns scurt: Colectezi rapoartele de crash din Xcode Organizer (sau dintr-un serviciu precum Firebase Crashlytics), te asiguri că sunt simbolicate cu fișierele dSYM ale build-ului, citești stack trace-ul thread-ului care a căzut și tipul excepției, apoi reproduci scenariul local și scrii un test care previne regresia.

Etapele:

1. Colectarea: Xcode Organizer, secțiunea Crashes, afișează crash-urile raportate de utilizatorii care au acceptat partajarea datelor de analiză cu dezvoltatorii. Serviciile dedicate (Crashlytics, Sentry) oferă rapoarte mai rapide, grupare și informații de context (versiunea iOS, dispozitivul, pașii anteriori prin breadcrumbs).

2. Simbolicarea: un raport brut conține adrese de memorie. Fișierul dSYM generat la compilare asociază adresele cu numele funcțiilor și liniile din cod. Fără dSYM-ul exact al acelui build, raportul este greu de citit. Pentru serviciile terțe, dSYM-urile se încarcă automat dintr-un script de build sau din App Store Connect.

3. Citirea raportului:

  • Exception Type: EXC_BREAKPOINT (SIGTRAP) în Swift indică de obicei o oprire intenționată a runtime-ului: force unwrap pe nil, index în afara array-ului, fatalError, overflow aritmetic. EXC_BAD_ACCESS indică acces la memorie invalidă (adesea unowned după eliberare sau cod nesigur). Codul 0x8badf00d înseamnă că watchdog-ul a închis aplicația pentru că main thread-ul a fost blocat prea mult.
  • Thread-ul care a căzut (Crashed): primele cadre din codul tău arată unde a apărut problema.
Thread 0 Crashed:
0  Shop   ProductViewModel.price(at:) + 124 (ProductViewModel.swift:48)
1  Shop   ProductView.body.getter + 312 (ProductView.swift:22)

4. Reproducerea: folosești datele de context (versiune, ecran, tipul datelor) ca să reproduci local. Un crash care apare doar în Release poate ține de optimizări sau de date reale de producție.

5. Corectarea: repari cauza, nu simptomul (de exemplu înlocuiești un ! cu tratarea cazului nil și afli de ce lipsea valoarea), adaugi un test și urmărești rata de crash după lansare.

Ce urmărește intervievatorul: Se verifică experiența cu probleme reale de producție; înțelegerea dSYM și a tipurilor de excepții distinge candidații care au lucrat la o aplicație publicată.

82 Mid

Cum testezi un view model care face cereri de rețea?

Răspuns scurt: Injectezi serviciul de rețea printr-un protocol și, în test, folosești o implementare falsă (stub sau mock) care întoarce date fixe sau erori. Apoi verifici că starea view model-ului devine cea așteptată, fără ca testul să depindă de internet sau de server.

Testele care fac cereri reale sunt lente, instabile și depind de date care se schimbă. Soluția este înlocuirea dependenței.

SWIFT
protocol WeatherService {
    func forecast(city: String) async throws -> Forecast
}

@MainActor
@Observable
final class WeatherViewModel {
    private(set) var text = ""
    private let service: WeatherService
    init(service: WeatherService) { self.service = service }

    func load(city: String) async {
        do { text = "\(try await service.forecast(city: city).celsius) °C" }
        catch { text = "Indisponibil" }
    }
}

// dublura de test
struct StubWeatherService: WeatherService {
    let result: Result<Forecast, Error>
    func forecast(city: String) async throws -> Forecast { try result.get() }
}

Testele, cu Swift Testing:

SWIFT
@MainActor
@Test func showsTemperature() async {
    let vm = WeatherViewModel(service: StubWeatherService(result: .success(Forecast(celsius: 21))))
    await vm.load(city: "Cluj")
    #expect(vm.text == "21 °C")
}

@MainActor
@Test func showsFallbackOnError() async {
    let vm = WeatherViewModel(service: StubWeatherService(result: .failure(URLError(.notConnectedToInternet))))
    await vm.load(city: "Cluj")
    #expect(vm.text == "Indisponibil")
}

Terminologia: un stub întoarce răspunsuri predefinite; un mock înregistrează și apelurile primite, ca să poți verifica, de exemplu, că forecast a fost apelat cu „Cluj” o singură dată; un fake are o implementare simplificată funcțională (o bază de date în memorie).

Pentru a testa chiar clientul HTTP (construirea cererilor, decodarea, codurile de status), poți folosi o subclasă de URLProtocol înregistrată într-o URLSessionConfiguration, care interceptează cererile și întoarce răspunsuri controlate. Astfel testezi codul real de networking fără rețea.

Ce urmărește intervievatorul: Intervievatorul verifică dacă scrii cod testabil prin injectare și dacă știi diferența dintre tipurile de dubluri de test.

83 Mid

Prin ce diferă Swift Testing de XCTest și cum testezi cod asincron?

Răspuns scurt: Swift Testing (Xcode 16+) folosește macro-uri: @Test pentru teste, #expect și #require pentru verificări, @Suite pentru grupare, cu teste parametrizate și rulare în paralel implicit. În ambele framework-uri, codul async se testează direct cu metode de test async; pentru callback-uri folosești XCTestExpectation sau confirmation.

Diferențe principale:

  • sintaxă: XCTest cere subclase de XCTestCase și metode cu prefixul test; Swift Testing acceptă funcții libere sau struct-uri marcate @Test.
  • verificări: un singur #expect(expresie) în loc de zeci de XCTAssert...; la eșec, raportul arată valorile fiecărei părți a expresiei. #require oprește testul dacă o precondiție eșuează și poate despacheta optionals: let user = try #require(users.first).
  • parametrizare: @Test(arguments:) rulează același test pe mai multe intrări.
  • organizare: tag-uri, trăsături (.disabled, .timeLimit, .bug), suite imbricate.
  • paralelism: testele rulează în paralel implicit, ceea ce scoate la iveală dependențele ascunse dintre teste (stare globală partajată).
  • limite: testele UI și testele de performanță rămân în XCTest. Cele două pot coexista în același target.

Cod asincron:

SWIFT
// async/await: cel mai simplu caz
@Test func loadsProfile() async throws {
    let profile = try await ProfileLoader(client: StubClient()).load()
    #expect(profile.name == "Ana")
}

// API cu callback, în XCTest
func test_legacyLoad_callsCompletion() {
    let exp = expectation(description: "completion")
    LegacyLoader().load { result in
        XCTAssertNotNil(try? result.get())
        exp.fulfill()
    }
    wait(for: [exp], timeout: 1)
}

În Swift Testing, echivalentul este await confirmation { confirm in ... }, care verifică faptul că un eveniment s-a produs de numărul așteptat de ori.

Greșeli frecvente: folosirea pauzelor fixe (sleep) în teste, care le face lente și instabile; teste care depind de ordinea de rulare; testarea codului care pornește un Task intern fără o modalitate de a aștepta terminarea lui. Pentru ultimul caz, expune funcția async și testeaz-o direct, în loc să testezi efectul unui task lansat ascuns.

Ce urmărește intervievatorul: Se verifică familiaritatea cu uneltele actuale și cu capcanele testelor asincrone; folosirea sleep în teste este un semnal negativ.

84 Mid

Ce sunt testele UI cu XCUITest și cum le faci stabile?

Răspuns scurt: XCUITest rulează aplicația într-un proces separat și o controlează ca un utilizator: găsește elemente după identificatori de accesibilitate, apasă, tastează și verifică ce apare. Le faci stabile prin identificatori dedicați, așteptări explicite în loc de pauze fixe, date de test controlate și independența fiecărui test.

Testele UI verifică fluxuri complete: autentificare, adăugare în coș, finalizarea unei comenzi. Sunt mai lente și mai fragile decât testele unitare, deci acoperă doar câteva fluxuri critice.

SWIFT
final class LoginUITests: XCTestCase {
    func test_successfulLogin_showsHome() {
        let app = XCUIApplication()
        app.launchArguments = ["-uiTesting"]          // aplicația folosește date simulate
        app.launchEnvironment["MOCK_USER"] = "demo"
        app.launch()

        app.textFields["login.email"].tap()
        app.textFields["login.email"].typeText("demo@exemplu.ro")
        app.secureTextFields["login.password"].tap()
        app.secureTextFields["login.password"].typeText("parola123")
        app.buttons["login.submit"].tap()

        XCTAssertTrue(app.staticTexts["home.title"].waitForExistence(timeout: 5))
    }
}

În aplicație:

SWIFT
TextField("Email", text: $email)
    .accessibilityIdentifier("login.email")

Practici pentru stabilitate:

  • identificatori de accesibilitate dedicați, nu texte vizibile, care se schimbă la traduceri sau la reformulări;
  • așteptări explicite: waitForExistence(timeout:) sau expectations pe predicate, niciodată sleep;
  • date controlate: argumentele de lansare comută aplicația pe un server simulat sau pe date locale; testele care depind de un backend real eșuează aleator;
  • independență: fiecare test pornește aplicația dintr-o stare cunoscută (de exemplu șterge datele la lansare în modul de test);
  • Page Object pattern: încapsulezi elementele unui ecran într-un tip (LoginScreen), ca modificările de UI să se repare într-un singur loc;
  • dezactivarea animațiilor în modul de test reduce timpii și variațiile.

Xcode permite înregistrarea interacțiunilor pentru a genera cod, util ca punct de pornire, dar codul generat trebuie curățat. În CI, testele UI rulează pe simulatoare, iar capturile de ecran atașate la eșec ajută mult la diagnostic.

Ce urmărește intervievatorul: Verifică experiența cu testele de UI și cu problema testelor instabile (flaky); identificatorii de accesibilitate și datele controlate sunt răspunsurile așteptate.

85 Mid

Care sunt motive frecvente de respingere în App Review și cum le previi?

Răspuns scurt: Frecvent: crash-uri, funcții incomplete, lipsa contului demo, metadate înșelătoare, plăți digitale în afara In-App Purchase unde regulile îl cer, lipsa ștergerii contului și texte de permisiune vagi. Le previi citind App Review Guidelines și testând build-ul final ca un revizor.

App Review verifică aplicația după App Review Guidelines, document public care se actualizează periodic. Categoriile cu probleme frecvente:

  • Performanță (2.1, App Completeness): crash-uri, butoane care nu fac nimic, conținut placeholder, linkuri moarte. Testează build-ul exact trimis, pe un dispozitiv real, cu un cont nou.
  • Acces pentru revizori: dacă aplicația cere autentificare, oferă un cont demo funcțional în App Review Information și explică funcțiile care nu sunt evidente.
  • Metadate (2.3): capturi de ecran care nu reflectă aplicația, cuvinte cheie cu nume de concurenți, descrieri cu funcții inexistente.
  • Plăți (3.1): conținutul și funcțiile digitale deblocate în aplicație trebuie, în general, vândute prin In-App Purchase. Regulile au excepții și diferențe pe regiuni (de exemplu prevederi specifice pentru UE după Digital Markets Act și pentru SUA după decizii judiciare din 2025), așa că verifică textul actual pentru piața ta. Bunurile fizice și serviciile consumate în afara aplicației folosesc alte metode de plată.
  • Confidențialitate (5.1): texte de permisiune specifice („Folosim camera pentru a scana bonul fiscal”), nu „Avem nevoie de acces”; cererea permisiunii în context, nu toate la pornire; declarații corecte în App Privacy; App Tracking Transparency înainte de orice urmărire între aplicații; privacy manifest pentru SDK-uri.
  • Ștergerea contului (5.1.1): dacă aplicația permite crearea unui cont, trebuie să permită și inițierea ștergerii lui din aplicație.

La o respingere, citești mesajul din Resolution Center, răspunzi clar și politicos, cu explicații sau o versiune corectată. Dacă nu ești de acord, există procedura de apel.

Ce urmărește intervievatorul: Se verifică experiența cu publicarea și respectarea regulilor platformei; cunoașterea cerinței de ștergere a contului și a textelor de permisiune este un semnal bun.

86 Senior

Cum ai organiza strategia de testare pentru o aplicație iOS în creștere?

Răspuns scurt: Urmezi principiul piramidei: multe teste unitare rapide pentru logică și view models, mai puține teste de integrare pentru networking și persistență, câteva teste UI pentru fluxurile critice, plus snapshot tests pentru componente vizuale. Testele rulează automat în CI la fiecare pull request.

Scopul nu este un procent de acoperire, ci încrederea că poți livra modificări fără regresii, cu un cost de întreținere rezonabil.

Straturi:

  • teste unitare (cele mai multe): logica de domeniu, view models, formatări, parsere, reguli de validare. Rulează în milisecunde, fără simulator dacă modulele nu depind de UIKit. Modularizarea ajută: un pachet Core testabil cu swift test este ideal.
  • teste de integrare: clientul HTTP cu URLProtocol și răspunsuri JSON reale salvate ca fixture-uri, persistența cu o bază de date în memorie, migrările de schemă de la versiunile anterioare.
  • snapshot tests (de exemplu cu biblioteca swift-snapshot-testing): capturează imaginea unei componente în mai multe configurații (Dark Mode, Dynamic Type mare, limbi lungi) și semnalează schimbările vizuale neintenționate. Imaginile de referință trebuie generate pe același simulator și aceeași versiune de iOS.
  • teste UI (puține): autentificare, plată, onboarding. Sunt cele mai lente și fragile, deci acoperă doar ce ar produce pagube mari dacă s-ar strica.
  • teste manuale și beta: TestFlight pentru testeri interni, cu un checklist scurt pentru fluxurile care nu se automatizează ușor (notificări push, achiziții, deep links).

Practici care contează la nivel de echipă:

  • CI care rulează testele la fiecare pull request, cu blocarea merge-ului la eșec;
  • politica pentru teste instabile: sunt reparate sau puse în carantină rapid, altfel echipa începe să ignore eșecurile;
  • un test nou pentru fiecare bug reparat;
  • măsurarea duratei suitei, ca să rămână rapidă.

Un senior adaptează strategia la risc: o aplicație bancară investește mai mult în teste de integrare și securitate decât o aplicație de conținut.

Ce urmărește intervievatorul: Întrebare de leadership tehnic; se urmărește un echilibru argumentat între cost și beneficiu, nu dogma „100% acoperire”.

87 Senior

Cum ai automatiza build-ul, testarea și livrarea aplicației (CI/CD)?

Răspuns scurt: Un sistem de CI (Xcode Cloud, GitHub Actions, Bitrise) compilează și rulează testele la fiecare pull request, iar la merge sau la un tag creează o arhivă semnată, crește build number-ul și o încarcă în TestFlight. Semnarea se gestionează centralizat.

Fluxul tipic:

1. La fiecare pull request: rezolvarea dependențelor SPM, lint (SwiftLint, SwiftFormat), compilare și teste unitare pe simulator, eventual snapshot tests. Rezultatul blochează merge-ul dacă eșuează. 2. La merge în main sau la un tag de release: incrementarea automată a numărului de build, arhivarea cu configurația Release, semnarea, încărcarea în App Store Connect și distribuirea către grupuri TestFlight. 3. Opțional, nightly: teste UI complete și verificări mai lungi.

Unelte:

  • Xcode Cloud: integrat în Xcode și App Store Connect, cu semnare gestionată automat; configurare rapidă, mai puțin flexibil pentru pași custom (accepți scripturi ci_scripts).
  • GitHub Actions, GitLab CI, Bitrise, CircleCI: necesită runnere macOS; mai multă flexibilitate.
  • fastlane: automatizează pașii (scan pentru teste, gym pentru build, pilot pentru TestFlight, match pentru certificate).
BASH
xcodebuild test \
  -scheme Shop \
  -destination 'platform=iOS Simulator,name=iPhone 16' \
  -resultBundlePath build/TestResults.xcresult

Semnarea este partea care strică cel mai des pipeline-urile. Opțiuni: fastlane match păstrează certificatele și profilurile criptate într-un repository privat; App Store Connect API Key permite autentificare fără cont personal și fără 2FA interactiv. Secretele stau în managerul de secrete al sistemului de CI, niciodată în repository.

Detalii de senior: cache pentru dependențe și DerivedData ca să reduci durata, versiunea de Xcode fixată explicit (o actualizare silențioasă a runner-ului poate strica build-ul), artefactele .xcresult și dSYM păstrate pentru diagnostic, încărcarea automată a dSYM-urilor la serviciul de crash reporting și notificări clare către echipă la eșec. Scopul este ca o versiune să poată ajunge la testeri fără pași manuali, iar orice build din producție să poată fi reprodus.

Ce urmărește intervievatorul: Verifică experiența cu livrarea continuă și cu semnarea, sursa obișnuită de probleme; menționarea gestionării secretelor este obligatorie la acest nivel.

Git, Scrum și lucrul în echipă

88 Junior

Descrie fluxul tău de lucru cu Git pentru o funcționalitate nouă.

Răspuns scurt: Actualizezi ramura principală, creezi o ramură nouă pentru funcționalitate, faci commit-uri mici cu mesaje clare, publici ramura și deschizi un pull request. După code review și trecerea testelor din CI, ramura este integrată în main, iar ramura de lucru se șterge.

Un flux tipic:

BASH
git switch main
git pull
git switch -c feature/checkout-coupon

# lucrezi, apoi
git status
git add Sources/Checkout/CouponView.swift
git commit -m "Adaugă câmpul pentru cod de reducere în checkout"

git push -u origin feature/checkout-coupon
# deschizi pull request în GitHub, GitLab sau Bitbucket

Practici bune:

  • o ramură pentru o singură funcționalitate sau un bug, cu nume descriptiv, eventual cu id-ul tichetului (feature/APP-123-coupon);
  • commit-uri mici și coerente: fiecare face un singur lucru și lasă proiectul compilabil. Mesajul spune ce și de ce, nu „modificări”;
  • verifici ce intră în commit cu git status și git diff --staged, ca să nu adaugi fișiere personale de configurare, chei sau fișiere generate;
  • sincronizezi des ramura cu main (merge sau rebase), ca să rezolvi conflictele mici devreme;
  • pull request-uri mici, cu descriere, capturi de ecran pentru schimbări vizuale și pași de testare. Un PR de câteva sute de linii primește un review mai atent decât unul de câteva mii.

Comenzi utile când ceva merge prost: git stash pentru a pune deoparte modificările necomise, git restore fișier pentru a anula modificările locale, git commit --amend pentru a corecta ultimul commit înainte de push, git revert pentru a anula un commit deja publicat fără a rescrie istoria.

În proiectele iOS, fișierul project.pbxproj generează des conflicte când mai multe persoane adaugă fișiere simultan, motiv pentru care sincronizarea frecventă este și mai importantă.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat în echipă cu Git și pull request-uri; răspunsurile vagi sau commit-urile uriașe sunt semnale negative.

89 Junior

Ce pui în .gitignore într-un proiect iOS și ce nu trebuie să ajungă niciodată în repository?

Răspuns scurt: Ignori fișierele generate și personale: DerivedData, build/, xcuserdata/, *.xcuserstate, .DS_Store, dependențele descărcate (de exemplu Pods/ dacă așa a decis echipa) și fișierele de configurare cu secrete. Nu adaugi niciodată chei private, certificate, parole sau tokenuri de API.

Un .gitignore de pornire pentru Xcode:

# Xcode
DerivedData/
build/
*.xcuserstate
xcuserdata/
*.xcscmblueprint

# Swift Package Manager
.build/
.swiftpm/xcode/xcuserdata/

# CocoaPods (decizie de echipă)
# Pods/

# macOS
.DS_Store

# Secrete și configurare locală
Secrets.xcconfig
*.p12
*.mobileprovision
fastlane/report.xml

Ce trebuie inclus în repository:

  • fișierul de proiect (.xcodeproj, inclusiv project.pbxproj) și workspace-ul;
  • schemele partajate (xcshareddata/xcschemes), necesare pentru CI;
  • Package.resolved, care fixează versiunile exacte ale dependențelor SPM, astfel încât toți colegii și CI-ul să compileze cu aceleași versiuni;
  • Podfile.lock dacă folosiți CocoaPods.

Secretele: o cheie de API pusă direct în cod ajunge în istoricul Git, iar ștergerea ulterioară nu o elimină din commit-urile vechi. Dacă se întâmplă, cheia trebuie considerată compromisă și regenerată. Abordarea obișnuită este un fișier .xcconfig local, ignorat de Git, cu un șablon (Secrets.example.xcconfig) inclus în repository și valorile reale injectate în CI din managerul de secrete.

Merită reținut că orice cheie inclusă în aplicația livrată poate fi extrasă din binar de cineva motivat. Pentru chei cu adevărat sensibile (de exemplu chei ale unui serviciu plătit), soluția corectă este ca aplicația să apeleze propriul server, iar serverul să folosească cheia.

Ce urmărește intervievatorul: Verifică atenția la securitate și la colaborare; includerea Package.resolved și excluderea secretelor sunt detaliile urmărite.

90 Junior

Cum arată un sprint în Scrum și ce rol ai tu ca developer?

Răspuns scurt: Un sprint este o perioadă fixă, de cel mult o lună, cu un obiectiv clar: Sprint Planning, Daily Scrum, apoi Sprint Review și Retrospective. Ca developer, estimezi, îți asumi munca, comunici blocajele și livrezi conform Definition of Done.

Scrum, descris în Scrum Guide, are trei roluri (responsabilități): Product Owner, care decide prioritățile și gestionează Product Backlog; Scrum Master, care ajută echipa să aplice procesul și să elimine obstacolele; Developers, adică toți cei care construiesc produsul, inclusiv testerii și designerii implicați.

Evenimentele unui sprint:

  • Sprint Planning: echipa alege din backlog elementele pe care le poate livra și formulează obiectivul sprintului. Developerii împart munca în sarcini și estimează.
  • Daily Scrum: o întâlnire scurtă, de cel mult 15 minute, în care echipa verifică progresul spre obiectiv și semnalează blocajele. Nu este o raportare către șef, ci o sincronizare între colegi.
  • Sprint Review: echipa prezintă ce a livrat, de exemplu un build în TestFlight, iar părțile interesate dau feedback.
  • Sprint Retrospective: echipa discută ce a mers bine, ce nu și ce schimbă concret în sprintul următor.

Ca iOS developer, contribuția ta înseamnă:

  • să pui întrebări la planificare despre cazuri limită, stări de eroare și designul pentru toate dimensiunile de ecran;
  • să semnalezi devreme dependențe (un endpoint care nu există încă, un design lipsă);
  • să spui la Daily când ești blocat, nu după trei zile;
  • să livrezi conform Definition of Done: cod revizuit, testat, integrat, eventual disponibil în TestFlight.

O particularitate mobilă: o versiune ajunge la utilizatori doar după App Review, iar actualizarea depinde de utilizatori. Din acest motiv multe echipe separă finalul sprintului de lansarea în magazin și folosesc feature flags pentru a activa funcționalitățile când sunt gata.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat într-un proces agil și dacă înțelegi scopul ceremoniilor, nu doar numele lor.

91 Mid

Care este diferența dintre git merge și git rebase și când îl folosești pe fiecare?

Răspuns scurt: merge combină ramurile printr-un commit de îmbinare și păstrează istoria așa cum a fost. rebase recreează commit-urile tale peste vârful altei ramuri, rescriind istoria într-o linie dreaptă; îl folosești doar pe ramuri pe care nu lucrează și alții.

Să presupunem că ai creat feature din main, iar între timp în main au apărut commit-uri noi.

Cu merge:

BASH
git switch feature
git merge main

Se creează un commit de îmbinare cu doi părinți. Istoria arată exact ce s-a întâmplat, dar cu multe ramificații într-un proiect activ.

Cu rebase:

BASH
git switch feature
git rebase main
# rezolvi conflictele commit cu commit, apoi
git rebase --continue
git push --force-with-lease

Commit-urile tale sunt recreate peste ultimul commit din main, cu identificatori noi. Istoria devine lineară, ca și cum ai fi început lucrul abia acum.

Când alegi:

  • rebase pentru a-ți actualiza ramura personală înainte de pull request și pentru curățarea commit-urilor locale (git rebase -i pentru a combina commit-uri de tip „fix typo”);
  • merge pentru integrarea ramurilor partajate și când vrei să păstrezi contextul exact al istoriei;
  • squash merge la închiderea pull request-ului, practică frecventă: toată ramura devine un singur commit în main.

Regula de aur: nu face rebase pe commit-uri pe care altcineva le-a preluat deja, pentru că rescrierea istoriei îi obligă să-și repare manual ramurile. Dacă trebuie să publici după un rebase, folosește --force-with-lease, care refuză suprascrierea dacă între timp altcineva a împins modificări, spre deosebire de --force.

În proiectele iOS, conflictele din project.pbxproj sunt mai ușor de rezolvat câte un commit pe rând (rebase) decât toate deodată, dar asta depinde de preferința echipei; convenția de echipă contează mai mult decât alegerea în sine.

Ce urmărește intervievatorul: Verifică înțelegerea rescrierii istoriei și a riscurilor; --force-with-lease și regula de a nu rescrie ramuri partajate sunt punctele cheie.

92 Mid

Cum estimezi o sarcină și ce înseamnă Definition of Done pentru o funcționalitate iOS?

Răspuns scurt: Estimezi relativ, de obicei în story points, comparând efortul, complexitatea și incertitudinea cu sarcini cunoscute. Definition of Done este lista comună de condiții pentru „gata”: cod revizuit, testat, accesibil, integrat și verificat pe dispozitiv.

Estimarea relativă pornește de la observația că oamenii compară mai bine decât prezic durate absolute. Echipa alege o sarcină de referință („un ecran simplu cu listă = 3”) și estimează restul prin comparație, de obicei pe o scară Fibonacci (1, 2, 3, 5, 8, 13). Planning poker ajută ca fiecare să estimeze independent, iar diferențele mari deschid discuții utile: cineva știe ceva ce ceilalți nu știu.

Ce iei în calcul la o sarcină iOS:

  • toate stările ecranului: încărcare, gol, eroare, offline;
  • dimensiunile de ecran, orientarea, Dark Mode, Dynamic Type, accesibilitatea;
  • versiunea minimă de iOS și API-urile disponibile;
  • dependențele de backend sau de design;
  • testele și eventualele migrări de date;
  • incertitudinea: dacă e mare, propui un spike, o investigație limitată în timp, înainte de estimare.

O sarcină estimată la 13 sau mai mult este de obicei prea mare și trebuie împărțită.

Un exemplu de Definition of Done pentru o echipă iOS:

  • codul respectă standardele echipei și a trecut code review;
  • testele unitare pentru logică există și trec în CI;
  • funcționalitatea a fost verificată pe dispozitiv real și pe dimensiunea cea mai mică de ecran suportată;
  • textele sunt localizate, iar Dark Mode și Dynamic Type funcționează;
  • etichetele de accesibilitate există;
  • evenimentele de analiză sunt implementate, dacă au fost cerute;
  • nu există avertismente noi la compilare;
  • funcționalitatea este integrată în main, eventual în spatele unui feature flag.

Definition of Done se deosebește de criteriile de acceptare: criteriile sunt specifice fiecărei sarcini, iar DoD se aplică tuturor.

Ce urmărește intervievatorul: Se verifică maturitatea în lucrul de echipă; candidații buni gândesc estimarea ca discuție despre risc și știu diferența dintre DoD și criteriile de acceptare.

93 Senior

Cum gestionezi ramurile, versiunile și un hotfix urgent pentru o aplicație publicată în App Store?

Răspuns scurt: Lucrezi pe main cu feature flags, tai o ramură de release pentru fiecare versiune și pui tag la fiecare livrare. Hotfix-ul pornește de la tag-ul din producție, cu reparație minimă și versiune de patch, apoi reparația se aduce înapoi în main.

Spre deosebire de web, o versiune mobilă nu poate fi retrasă instant: trece prin App Review, iar utilizatorii actualizează în ritmul lor. Strategia de ramificare trebuie să țină cont de asta.

Un model des folosit:

  • main este mereu compilabil și testat; funcționalitățile neterminate sunt dezactivate prin feature flags;
  • la începutul ciclului de release se taie release/2.4.0, unde intră doar reparații de buguri, testate în TestFlight;
  • la publicare se creează un tag: git tag v2.4.0;
  • reparațiile din ramura de release sunt aduse și în main (merge sau cherry-pick), ca să nu reapară în versiunea următoare.

Un hotfix pentru un crash grav în 2.4.0:

BASH
git switch -c hotfix/2.4.1 v2.4.0
# reparație minimă și test pentru bug
git commit -am "Repară crash la deschiderea comenzilor fără adresă"
git tag v2.4.1
git switch main
git cherry-pick <sha-ul-reparației>

Apoi crești versiunea la 2.4.1, încarci build-ul, îl testezi rapid în TestFlight și îl trimiți la revizuire. Pentru probleme critice poți cere App Review o revizuire accelerată (expedited review), justificată.

Măsuri care reduc nevoia de hotfix-uri:

  • phased release pentru actualizări, ca problema să afecteze inițial un procent mic de utilizatori; lansarea poate fi pusă pe pauză;
  • feature flags la distanță, ca o funcționalitate defectă să poată fi oprită fără build nou;
  • monitorizarea ratei de crash imediat după lansare;
  • un mecanism de actualizare obligatorie (versiune minimă verificată la pornire) pentru situațiile în care versiunile vechi devin incompatibile cu serverul;
  • API-uri de backend compatibile cu versiunile vechi, pentru că vor exista mereu utilizatori care nu au actualizat.

Ce urmărește intervievatorul: Întrebare de senior despre procesul de livrare; se urmărește înțelegerea constrângerilor mobile (review, actualizări lente) și a mecanismelor de reducere a riscului.

Comportamentale și HR

94 Junior

Spune-ne puțin despre tine și de ce vrei să lucrezi ca iOS Developer.

Răspuns scurt: Răspunde în 1–2 minute, structurat: cine ești acum, ce ai construit relevant pentru iOS și de ce te atrage meseria și această companie. Leagă motivația de lucruri concrete pe care le-ai făcut, nu de afirmații generale.

Întrebarea deschide aproape orice interviu și stabilește tonul. O structură simplă este prezent, trecut, viitor:

  • prezent: cine ești profesional acum („Lucrez de un an ca tester și de zece luni învăț Swift seara”);
  • trecut: experiența relevantă, cu un exemplu concret („Am construit o aplicație pentru evidența antrenamentelor, cu SwiftUI și SwiftData, pe care o folosesc zilnic”);
  • viitor: de ce acest rol și această companie („Vreau să lucrez la o aplicație folosită de mulți oameni, într-o echipă cu code review, iar produsul vostru are exact provocările de performanță și offline care mă interesează”).

Model de răspuns:

„Am terminat facultatea de economie și am lucrat doi ani în suport tehnic. Am început programarea din curiozitate, apoi m-a atras iOS pentru că pot vedea imediat rezultatul pe telefon. În ultimul an am făcut un curs de Swift, am publicat în TestFlight o aplicație de rețete care consumă un API public și am învățat să scriu teste pentru view models. Caut primul rol de junior într-o echipă unde pot învăța de la oameni mai experimentați. Am citit despre aplicația voastră și mi-a plăcut că o actualizați des, ceea ce înseamnă că aș învăța și procesul de livrare.”

Greșeli frecvente:

  • recitarea CV-ului în ordine cronologică, fără un fir;
  • motivații doar financiare sau generale („IT-ul e viitorul”);
  • prea multe detalii personale fără legătură cu rolul;
  • un răspuns de zece minute.

Pregătește-te să fii întrebat despre orice lucru menționat: dacă spui SwiftData, vei fi întrebat de ce l-ai ales.

Ce urmărește intervievatorul: Intervievatorul evaluează comunicarea, motivația și capacitatea de a sintetiza; un răspuns structurat și concret contează mai mult decât experiența în sine.

95 Junior

Prezintă-ne un proiect iOS de care ești mândru.

Răspuns scurt: Alege un proiect pe care îl cunoști în detaliu și explică problema rezolvată, deciziile tehnice și motivele lor, o dificultate întâmpinată și ce ai învăța diferit acum. Intervievatorul va săpa în detalii, deci nu exagera rolul tău.

Pentru juniori, proiectele personale sunt adesea cea mai bună dovadă de competență. Structura recomandată:

1. Contextul și problema: ce face aplicația și pentru cine. („O aplicație care îmi arată orarul autobuzelor din oraș, pentru că site-ul oficial era greu de folosit pe telefon.”) 2. Deciziile tehnice: SwiftUI sau UIKit, cum ai organizat codul, persistența, networking-ul. Important este de ce, nu doar ce. („Am folosit MVVM ca să pot testa logica de calcul al următoarei plecări fără UI.”) 3. O dificultate concretă: un bug, o limitare, o problemă de performanță, cum ai investigat-o și cum ai rezolvat-o. 4. Rezultatul: e publicată, în TestFlight, o folosesc prietenii, ce feedback ai primit. 5. Ce ai face diferit: arată maturitate („Aș adăuga mai devreme tratarea stării offline; am descoperit-o abia când am folosit aplicația în metrou.”)

Model de răspuns scurt:

„Am construit o aplicație de buget personal în SwiftUI. Datele sunt salvate local cu SwiftData, iar cursul valutar vine dintr-un API public. Cea mai grea parte a fost sincronizarea graficelor cu filtrele de perioadă: la început recalculam totalurile în body și interfața sacada la peste o mie de tranzacții. Am mutat calculul în view model, am păstrat rezultatul și am verificat în Instruments că problema a dispărut. Am scris teste pentru calculul totalurilor pe luni. Codul este pe GitHub, cu un README care explică arhitectura.”

Pregătește-te să deschizi codul la interviu și să explici orice linie. Dacă un tutorial te-a ajutat, spune-o și arată ce ai adăugat tu peste el; onestitatea contează mai mult decât un proiect impresionant pe care nu îl poți explica.

Ce urmărește intervievatorul: Se verifică profunzimea înțelegerii și onestitatea; întrebările ulterioare despre detalii arată rapid dacă proiectul este al tău.

96 Junior

Povestește despre un bug greu pe care l-ai rezolvat.

Răspuns scurt: Folosește structura STAR (Situație, Sarcină, Acțiune, Rezultat): descrie simptomul, cum l-ai reprodus, ipotezele verificate și uneltele folosite, cauza reală, reparația și ce ai făcut ca să nu se repete. Accentul cade pe procesul de depanare, nu doar pe soluție.

Intervievatorul vrea să vadă cum gândești când lucrurile nu merg. Un răspuns bun arată metodă, perseverență și capacitatea de a învăța.

Structura STAR:

  • Situație: contextul pe scurt. („Într-o aplicație de comenzi, utilizatorii raportau că lista apărea uneori cu produse dublate.”)
  • Sarcină: ce aveai de făcut. („Trebuia să găsesc cauza înainte de lansarea următoare.”)
  • Acțiune: pașii concreți, partea cea mai importantă.
  • Rezultat: ce s-a întâmplat după și ce ai învățat.

Model de răspuns:

„Bugul apărea rar și nu reușeam să-l reproduc. Am observat în rapoarte că apărea mai ales pe conexiuni lente. Am folosit Network Link Conditioner ca să simulez o rețea slabă și am reușit să-l reproduc. Am pus breakpoints în funcția de încărcare și am văzut că era apelată de două ori: o dată din onAppear și o dată din pull-to-refresh, iar rezultatele ambelor cereri erau adăugate la listă. Pe o rețea rapidă, prima cerere se termina înainte de a doua și nu se observa problema. Am schimbat logica astfel încât rezultatul să înlocuiască lista, nu să fie adăugat, și am anulat cererea anterioară când pornea una nouă. Am adăugat un test care simulează două încărcări suprapuse. Am învățat să mă uit la ordinea operațiilor asincrone ori de câte ori un bug pare aleator.”

Ce face răspunsul bun:

  • arată cum ai reprodus problema;
  • descrie ipoteze verificate, nu ghicite;
  • numește unelte concrete (breakpoints, Instruments, logging);
  • include prevenția (un test, o regulă nouă).

Dacă ești junior fără experiență profesională, un bug din proiectul personal este perfect valid.

Ce urmărește intervievatorul: Se evaluează gândirea sistematică de depanare și comunicarea; candidații slabi descriu doar soluția, fără proces.

97 Junior

Ce faci când te blochezi la o sarcină și nu știi cum să continui?

Răspuns scurt: Încerci întâi singur, într-un timp limitat: reciți cerința, izolezi problema, cauți în documentație și în codul existent. Dacă nu avansezi, ceri ajutor cu o întrebare bine formulată: ce încerci să obții, ce ai încercat deja și unde anume te-ai blocat.

Întrebarea verifică două riscuri opuse: juniorul care întreabă la fiecare pas, fără să încerce, și juniorul care stă blocat zile întregi fără să spună nimic. Ambele costă echipa.

Un proces echilibrat:

1. Clarifici problema: recitești cerința și formulezi exact ce nu funcționează. Uneori blocajul este de fapt o cerință neclară, iar soluția este o întrebare către Product Owner sau designer. 2. Izolezi: reproduci problema într-un exemplu minim, de exemplu un Playground sau un proiect mic. Adesea, în timp ce faci asta, găsești singur cauza. 3. Cauți: documentația Apple, sesiunile WWDC, codul existent din proiect (poate cineva a rezolvat deja ceva similar), istoria Git, Stack Overflow, forumurile Apple Developer. 4. Îți dai o limită de timp: de exemplu o oră sau două pentru o problemă blocantă, în funcție de convenția echipei. 5. Ceri ajutor bine:

„Încerc să afișez imaginile din API în listă. Cererea reușește, am verificat răspunsul în log, dar imaginile nu apar. Am încercat AsyncImage și o variantă cu URLSession; în ambele cazuri primesc eroarea X. Bănuiesc că e legat de App Transport Security, pentru că URL-urile sunt HTTP. Ai cinci minute să te uiți?”

O astfel de întrebare respectă timpul colegului și arată că ai muncit.

6. Înveți din rezolvare: notezi soluția, eventual o documentezi pentru echipă.

Model de răspuns la interviu: descrie pe scurt acest proces și dă un exemplu real în care ai aplicat-o. Menționează și că semnalezi blocajul la Daily Scrum, ca echipa să știe la timp dacă o sarcină riscă să întârzie.

Ce urmărește intervievatorul: Intervievatorul evaluează autonomia și comunicarea; răspunsul ideal arată echilibru între efortul propriu și cererea de ajutor la timp.

98 Junior

Cum te ții la curent cu noutățile din ecosistemul Apple?

Răspuns scurt: Urmărești sursele oficiale (sesiunile WWDC, documentația și notele de versiune pentru Swift și Xcode, Swift Evolution), câteva surse comunitare de calitate și, mai ales, aplici noutățile într-un proiect mic. Menționează un exemplu concret de ceva nou pe care l-ai învățat recent și l-ai folosit.

Ecosistemul Apple se schimbă anual: la WWDC, în iunie, sunt anunțate versiuni noi de iOS, Xcode și Swift, iar API-uri importante (SwiftUI, Observation, Swift Testing, Swift Concurrency) evoluează de la an la an. Un developer care nu se actualizează ajunge să scrie cod depășit.

Surse utile:

  • WWDC: sesiunile video sunt gratuite în aplicația Apple Developer și pe site; sesiunile „What's new in Swift” și „What's new in SwiftUI” sunt un bun punct de plecare;
  • documentația Apple și notele de versiune pentru Xcode, care listează schimbările și deprecierile;
  • Swift Evolution și forumurile Swift, pentru a înțelege direcția limbajului și motivațiile schimbărilor;
  • newslettere, bloguri și podcasturi din comunitatea iOS; alege câteva consecvente în loc de zeci urmărite superficial;
  • codul open source al bibliotecilor populare, unde vezi cum rezolvă alții problemele;
  • comunitățile locale și meetup-urile de iOS, unde poți discuta cu oameni din industrie.

Mai important decât sursele este modul de lucru: transformi informația în practică. De exemplu, după ce afli de macro-ul @Observable, îți migrezi un ecran din proiectul personal și observi diferențele.

Model de răspuns:

„Urmăresc în fiecare an sesiunile principale de la WWDC și citesc notele de versiune ale Xcode. Anul acesta am încercat Swift Testing: am rescris testele din proiectul meu de buget cu @Test și #expect și am folosit testele parametrizate pentru calculul totalurilor. Am observat că rulează în paralel și am descoperit astfel o dependență ascunsă între două teste, pe care am reparat-o.”

Un răspuns concret, cu ceva aplicat efectiv, valorează mult mai mult decât o listă lungă de surse.

Ce urmărește intervievatorul: Se verifică curiozitatea și capacitatea de învățare continuă; lipsa unui exemplu concret face răspunsul să pară memorat.

99 Mid

Povestește despre o situație în care nu ai fost de acord cu un coleg sau cu un designer. Cum ai procedat?

Răspuns scurt: Descrie dezacordul concret, cum ai înțeles întâi argumentele celeilalte părți, cum ți-ai susținut poziția cu date sau exemple (limitări ale platformei, timp de implementare, impact asupra utilizatorului) și la ce compromis ați ajuns. Încheie cu relația de lucru de după și ce ai învățat.

Dezacordurile sunt normale în echipele de produs; intervievatorul vrea să vadă dacă le transformi în decizii bune fără conflicte personale.

Principii pentru răspuns:

  • separi persoana de problemă: discuția este despre soluție, nu despre cine are dreptate;
  • înțelegi întâi: întrebi care este scopul cerinței; de multe ori designerul sau colegul are un motiv pe care nu îl cunoșteai;
  • aduci argumente verificabile: Human Interface Guidelines, comportamentul nativ al platformei, accesibilitate, timp de implementare, un prototip rapid;
  • propui alternative, nu doar refuzi;
  • accepți decizia odată luată, chiar dacă nu este a ta (disagree and commit).

Model de răspuns:

„Designerul propusese un meniu de navigare custom, cu animații proprii, în locul tab bar-ului standard. Mi-a explicat că vrea o identitate vizuală mai puternică. Eu eram îngrijorat de trei lucruri: accesibilitatea cu VoiceOver, comportamentul la Dynamic Type mare și faptul că implementarea ar fi durat aproximativ un sprint în loc de o zi. Am făcut un prototip rapid cu tab bar-ul standard personalizat prin culori și iconițe proprii și i-am arătat cum arată cu VoiceOver activ și cu text mare. Am stabilit împreună să păstrăm componenta nativă, cu o animație custom doar la schimbarea tab-ului. Am livrat la timp, iar de atunci designerul mă implică mai devreme în discuțiile despre componente, ca să semnalez din timp limitările tehnice.”

Ce să eviți:

  • să-l prezinți pe celălalt ca incompetent;
  • să cedezi fără discuție sau să impui decizia.

La nivel de mid, arată că știi când să escaladezi către Product Owner sau tech lead, cu opțiunile formulate clar.

Ce urmărește intervievatorul: Se evaluează colaborarea, maturitatea și capacitatea de a argumenta tehnic față de colegi non-tehnici; tonul față de cealaltă persoană contează mult.

100 Mid

Cum procedezi când termenul limită este prea strâns pentru tot ce s-a cerut?

Răspuns scurt: Semnalezi riscul cât mai devreme, cu o estimare argumentată, apoi propui opțiuni: reducerea scopului la ce este esențial pentru utilizator, livrarea în etape sau în spatele unui feature flag, ori mutarea termenului. Nu sacrifici în tăcere calitatea, testele sau stabilitatea.

Intervievatorul verifică dacă știi gestiona presiunea fără să ascunzi probleme și fără să livrezi ceva care va produce crash-uri în producție.

Un proces matur:

1. Evaluezi realist: împarți munca în bucăți și estimezi fiecare bucată. Asta transformă senzația vagă de „nu ajung” într-o discuție concretă. 2. Comunici devreme: un risc semnalat în prima zi a sprintului lasă opțiuni; unul semnalat cu o zi înainte de termen, nu. 3. Propui opțiuni, nu doar problema:

  • un MVP: ce trebuie neapărat să funcționeze pentru utilizator în prima versiune și ce poate veni după;
  • livrare în etape, cu feature flags, astfel încât codul să ajungă în main fără să fie vizibil;
  • ajutor din partea unui coleg pentru o parte izolată;
  • mutarea termenului, cu argumente. 4. Lași decizia celui care deține prioritățile (Product Owner), cu compromisurile clar explicate.

Model de răspuns:

„Aveam de livrat un flux nou de plată înainte de o campanie. După planificare mi-am dat seama că implementarea completă, cu salvarea cardului și cu Apple Pay, nu încăpea în timpul rămas. Am explicat Product Owner-ului estimările pe componente și am propus să lansăm întâi plata cu card, cu Apple Pay în versiunea următoare. Am păstrat testele și verificările pe dispozitiv, pentru că o eroare în plată ar fi fost mult mai costisitoare decât o întârziere. Am livrat la timp, iar Apple Pay a urmat două săptămâni mai târziu.”

Specific mobil: o eroare gravă nu poate fi reparată instant, pentru că fiecare versiune trece prin App Review, deci reducerea scopului este preferabilă renunțării la testare.

Ce urmărește intervievatorul: Se verifică responsabilitatea, comunicarea cu partea de business și judecata privind calitatea; ascunderea problemelor până în ultima zi este semnalul cel mai negativ.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru iOS Developer

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de iOS Developer, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de iOS Developer

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.