iOS Inside #007 – SwiftUI na prática: performance, dicas e o que vem por aí

Neste episódio do iOS Inside, vamos explorar com profundidade o uso moderno do SwiftUI com foco em performance, recursos avançados como o TipKit e Actors, além de preparar o terreno para o Swift 6.0. Aqui, o objetivo não é apenas mostrar o que existe — mas te ajudar a entender quando e como usar cada técnica, com exemplos reais e comparativos claros.

---

1. TipKit no SwiftUI — ensinando o usuário no momento certo

O TipKit chegou para substituir abordagens caseiras com Tooltips, Coach Marks ou Views improvisadas para onboarding. Ele é um framework da Apple para mostrar dicas contextuais, que respeita o design do sistema e se integra de forma fluida com SwiftUI.

Exemplo real:

import TipKit

struct FavoritarDica: Tip {
    var title: Text {
        Text("Toque no coração para favoritar")
    }

    var message: Text? {
        Text("Assim você encontra esse item com mais facilidade depois.")
    }

    var image: Image? {
        Image(systemName: "heart.fill")
    }
}

E a exibição:

struct ContentView: View {
    let tip = FavoritarDica()

    var body: some View {
        Button(action: {
            // Ação de favoritar
        }) {
            Label("Favoritar", systemImage: "heart")
        }
        .popoverTip(tip)
    }
}

Você ainda pode controlar a exibição com TipStorage e personalizar a frequência. O ideal é mostrar a dica no momento certo, apenas se o usuário ainda não descobriu a funcionalidade sozinho.

---

2. Swift Macros — geração de código com propósito

As macros permitem gerar código Swift automaticamente, semelhante ao que outras linguagens fazem com metaprogramação. Com elas, você pode criar:

• Validações automáticas

• Logs

• Modelos com CodingKeys

• Builders e propriedades repetidas

Exemplo prático:

@AutoCodable
struct User {
    var name: String
    var age: Int
}

Ao usar uma macro como @AutoCodable, você evita escrever manualmente as conformidades com Codable.

Atenção: hoje, ainda é necessário importar o módulo da macro e usar com cautela. Use em lugares controlados, como libs internas, para evitar dependência excessiva e reduzir complexidade.

---

3. Actors no SwiftUI — concorrência segura no mundo reativo

Concorrência é um tema crítico em apps modernos. Quando lidamos com múltiplas threads e estados mutáveis, erros silenciosos podem surgir. Os actors são a melhor forma atual de proteger dados acessados de forma assíncrona.

Antes: risco de race condition

class Counter {
    var value = 0

    func increment() {
        value += 1
    }
}

Depois: com segurança garantida

actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        return value
    }
}

No ViewModel:

@MainActor
class CounterViewModel: ObservableObject {
    let counter = Counter()

    @Published var count = 0

    func incrementTapped() {
        Task {
            await counter.increment()
            count = await counter.getValue()
        }
    }
}

Resultado: menos bugs, menos crashes, mais clareza na arquitetura.

---

4. Swift 6.0

O Swift 6.0 vem com uma missão clara: tornar a concorrência mais segura por padrão. Hoje, usamos atributos como @Sendable e @MainActor para garantir isso manualmente. A partir do Swift 6.0, isso será implícito em muitos casos — o compilador já vai te avisar sobre acessos potencialmente perigosos em tarefas assíncronas.

Além disso:

• Builds mais rápidos com projetos grandes

• Mais poder para macros com uso em múltiplas fases

• Melhorias na interoperabilidade com C++ e sistemas legados

Se quiser estar pronto, revise seu uso atual de async/await e garanta que seus acessos a estado são protegidos com actor, @MainActor ou isolamento adequado.

---

5. Performance com Equatable — evite renderizações desnecessárias

SwiftUI re-renderiza views sempre que algo muda no estado observado. Mas muitas vezes isso é exagerado — re-renderiza mesmo sem mudanças reais. Uma forma de contornar isso é usar Equatable.

Antes:

struct UserCardView: View {
    let name: String

    var body: some View {
        Text(name)
    }
}

Depois:

struct UserCardView: View, Equatable {
    let name: String

    static func == (lhs: UserCardView, rhs: UserCardView) -> Bool {
        lhs.name == rhs.name
    }

    var body: some View {
        Text(name)
    }
}

Resultado: menos trabalho de renderização e mais fluidez no app, especialmente em listas grandes.

---

Conclusão — conhecendo para aplicar com precisão

Mais do que conhecer novos recursos, o que diferencia um desenvolvedor sênior é saber quando usar cada um.
Neste episódio, vimos como:

• O TipKit ajuda a educar o usuário com timing certo;

• Macros podem automatizar código repetitivo, se usadas com consciência;

• Actors blindam seu app contra race conditions silenciosas;

• O Swift 6.0 vai elevar a barra da segurança e da performance;

• E Equatable pode parecer simples, mas entrega um ganho real quando bem aplicado.

Essas não são só dicas — são ferramentas que, quando combinadas, constroem experiências melhores.

---

#SwiftUI #iOSDev #TipKit #SwiftMacros #SwiftLang #Swift6 #Actors #Equatable #SwiftPerformance #iOSInside