Por que a conversa sobre arquitetura muda quando o time passa de 15 engenheiros
Em um aplicativo mantido por três ou quatro desenvolvedores iOS, quase qualquer padrão minimamente organizado funciona bem. Todo mundo conhece cada tela, resolve dúvidas em cinco minutos no chat e ajusta convenções sem atrito. A realidade muda completamente quando o produto escala para vinte, quarenta ou sessenta engenheiros distribuídos em várias squads mexendo no mesmo repositório ao mesmo tempo.
Nesse ponto, a arquitetura deixa de ser uma preferência pessoal de estilo e vira um contrato de coordenação entre pessoas que nunca trabalharam juntas. Se cada squad decide por conta própria onde formatar valores monetários, onde disparar eventos de analytics e quem controla a pilha de navegação, as revisões de PR ficam lentas e o onboarding de um novo integrante leva semanas.
No mercado iOS corporativo, duas arquiteturas dominam esses projetos de grande porte: Clean Swift (VIP: View, Interactor e Presenter) e MVVM-C (Model, View, ViewModel e Coordinator). Já trabalhei anos com as duas em aplicativos financeiros e de varejo, e posso afirmar que nenhuma resolve todos os problemas sozinha. Cada uma cobra um preço diferente.
Critério real de escolha: escolha a arquitetura pelo tipo de erro que o seu time mais precisa evitar. O VIP reduz ambiguidade estrutural ao custo de mais arquivos; o MVVM-C entrega velocidade e encaixe natural com SwiftUI, mas exige disciplina constante no code review para impedir ViewModels inchados.
Comparando o fluxo de dados lado a lado
A diferença prática entre os dois modelos fica evidente quando olhamos para o trajeto de uma ação do usuário, como tocar no botão de carregar o extrato mensal. No VIP, o ciclo é sempre unidirecional e passa obrigatoriamente por três fronteiras de protocolo. No MVVM-C, a View observa o estado exposto pelo ViewModel e a navegação sai da cena por meio do Coordinator.
Clean Swift (VIP) na prática: previsibilidade acima de concisão
O grande mérito do VIP em empresas com alta rotatividade ou dezenas de squads é a previsibilidade absoluta. Se um desenvolvedor abre um módulo de fatura que nunca viu na vida para corrigir um bug de formatação de moeda, ele sabe em dois segundos que o código está no Presenter. Se o bug está na validação de saldo ou na chamada ao serviço, o código está no Interactor ou no Worker.
Veja como um caso de uso real de consulta de extrato fica estruturado em VIP sem misturar responsabilidades:
import Foundation
enum StatementModels {
enum Load {
struct Request { let month: Int; let year: Int }
struct Response { let entries: [StatementEntry]; let totalCents: Int }
struct ViewModel { let rows: [Row]; let formattedTotal: String }
struct Row { let title: String; let amountText: String; let isDebit: Bool }
}
}
protocol StatementBusinessLogic {
func loadStatement(request: StatementModels.Load.Request)
}
protocol StatementPresentationLogic {
func presentStatement(response: StatementModels.Load.Response)
}
@MainActor
protocol StatementDisplayLogic: AnyObject {
func displayStatement(viewModel: StatementModels.Load.ViewModel)
}
final class StatementInteractor: StatementBusinessLogic {
private let presenter: StatementPresentationLogic
private let worker: StatementFetching
init(presenter: StatementPresentationLogic, worker: StatementFetching) {
self.presenter = presenter
self.worker = worker
}
func loadStatement(request: StatementModels.Load.Request) {
Task {
let entries = (try? await worker.fetchEntries(month: request.month, year: request.year)) ?? []
let total = entries.reduce(0) { $0 + $1.amountCents }
presenter.presentStatement(response: .init(entries: entries, totalCents: total))
}
}
}
final class StatementPresenter: StatementPresentationLogic {
weak var viewController: StatementDisplayLogic?
private let currencyFormatter: NumberFormatter
init(currencyFormatter: NumberFormatter) {
self.currencyFormatter = currencyFormatter
}
func presentStatement(response: StatementModels.Load.Response) {
let rows = response.entries.map { entry in
StatementModels.Load.Row(
title: entry.merchantName,
amountText: format(cents: entry.amountCents),
isDebit: entry.amountCents < 0
)
}
let viewModel = StatementModels.Load.ViewModel(
rows: rows,
formattedTotal: format(cents: response.totalCents)
)
Task { @MainActor in
viewController?.displayStatement(viewModel: viewModel)
}
}
private func format(cents: Int) -> String {
let value = Decimal(cents) / 100
return currencyFormatter.string(from: value as NSDecimalNumber) ?? "R$ 0,00"
}
} Testar esse Presenter dispensa rede, banco e UIViewController. Basta passar uma struct Response com valores em centavos (incluindo negativos e zero) e conferir as strings entregues ao StatementDisplayLogicSpy. Por outro lado, note o custo: mesmo uma tela simples acaba gerando cinco ou seis arquivos entre cena, modelos, interactor, presenter, worker e router.
MVVM-C com SwiftUI e UIKit: velocidade com risco de inchaço
O MVVM-C encaixa de forma muito mais natural no modelo declarativo do SwiftUI (usando @Observable ou ObservableObject) e também funciona bem em UIKit com Combine ou closures. Em vez de quebrar uma tela pequena em seis arquivos, você define um estado explícito de tela e delega a lógica pesada de negócio para UseCases injetados.
import Foundation
@MainActor
protocol StatementCoordinating: AnyObject {
func openEntryDetail(entryId: String)
}
@MainActor
final class StatementViewModel: ObservableObject {
enum State: Equatable {
case idle
case loading
case loaded(rows: [String], total: String)
case failed(message: String)
}
@Published private(set) var state: State = .idle
private let fetchStatement: StatementFetching
private weak var coordinator: StatementCoordinating?
init(fetchStatement: StatementFetching, coordinator: StatementCoordinating) {
self.fetchStatement = fetchStatement
self.coordinator = coordinator
}
func load(month: Int, year: Int) async {
state = .loading
do {
let entries = try await fetchStatement.fetchEntries(month: month, year: year)
let titles = entries.map(\.merchantName)
state = .loaded(rows: titles, total: "\(entries.count) lançamentos")
} catch {
state = .failed(message: "Não foi possível carregar o extrato.")
}
}
func didSelectEntry(id: String) {
coordinator?.openEntryDetail(entryId: id)
}
} O problema que vejo acontecer com frequência no MVVM-C não está no padrão em si, mas na falta de uma camada de domínio por baixo do ViewModel. Sem UseCases claros, o ViewModel começa com 120 linhas e seis meses depois já tem 950 linhas misturando chamadas HTTP, regras de validação, persistência em cache, tracking de eventos e formatação de data. Quando isso acontece, você trocou o antigo Massive View Controller por um Massive ViewModel igualmente difícil de manter.
Em ambos os padrões, controlar corretamente cancelamento de tarefas e isolamento da main thread evita crashes de concorrência; vale combinar essa arquitetura com as práticas descritas em concorrência moderna em Swift com async/await e Actors.
Tabela comparativa para decisão de engenharia
| Critério | Clean Swift (VIP) | MVVM-C (com UseCases) |
|---|---|---|
| Direção do fluxo de dados | Unidirecional estrito (View → Interactor → Presenter → View) | Reativo / observável (View observa estado do ViewModel) |
| Encaixe com SwiftUI | Requer adaptador de estado (ObservableObject ou @Observable) na ponta da View | Nativo e direto, com pouca fricção |
| Testabilidade unitária | Muito alta; formatação e regra de negócio já nascem separadas | Alta, desde que lógica pesada fique em UseCases e formatação em helpers puros |
| Cerimônia e arquivos por tela | 5 a 6 arquivos por cena, além de structs Request/Response/ViewModel | 3 a 4 arquivos por tela, reduzindo atrito em features pequenas |
| Risco arquitetural principal | Over-engineering em telas triviais e excesso de pass-through | ViewModel acumular regra de negócio, rede e UI no mesmo arquivo |
| Previsibilidade com 25+ devs | Muito alta; cada responsabilidade tem endereço fixo | Média a alta; depende de linter, templates e revisão rigorosa de PR |
Armadilhas de memória e navegação que aparecem nos dois modelos
Independentemente da sigla escolhida no quadro branco, três bugs de runtime aparecem com regularidade nas revisões que faço:
No VIP, esquecer weak na referência do Presenter para a ViewController fecha um ciclo forte de retenção (View → Interactor → Presenter → View). A tela fecha visualmente, mas toda a árvore de objetos continua presa na memória até o encerramento do aplicativo. Um teste unitário de vazamento usando addTeardownBlock com referência weak pega esse bug em segundos no CI.
No MVVM-C com UIKit, o vazamento mais comum acontece nos childCoordinators. O usuário abre um fluxo filho via push na UINavigationController e volta usando o gesto nativo de arrastar da borda esquerda da tela. Se o coordinator pai não escuta o delegate da navigation controller (navigationController(_:didShow:animated:)), o coordinator filho nunca é removido do array e acumula na memória a cada visita. Em apps grandes, cruzar essa navegação com o modelo de arquitetura modular e deeplinks em apps iOS ajuda a manter o ciclo de vida limpo entre módulos.
Por fim, evite dogmatismo cego. Já vi time criar seis arquivos VIP completos para uma tela estática de "Termos de Uso" que só exibia texto e um botão de fechar. Criar exceções documentadas para telas puramente apresentacionais poupa tempo sem abrir brecha para desorganização.
Quando escolher cada um e checklist de revisão de PR
Adote Clean Swift (VIP) quando a base principal ainda estiver majoritariamente em UIKit, quando o time tiver mais de vinte engenheiros rodando em múltiplas squads e quando regras complexas de formatação e compliance exigirem fronteiras rígidas e fáceis de auditar. Prefira MVVM-C com UseCases quando o aplicativo estiver migrando ou nascendo em SwiftUI, quando a equipe precisar de menor cerimônia por entrega e quando houver maturidade de engenharia para manter os ViewModels enxutos.
Use este checklist nas revisões de código independentemente do padrão adotado:
- A camada de View não contém regras de negócio, formatação de moeda/data nem chamadas diretas de rede.
- Nenhuma dependência concreta de infraestrutura (
URLSession, Keychain, banco) é instanciada dentro do Interactor ou ViewModel sem injeção por protocolo. - Referências de volta para a View ou para o Coordinator pai estão marcadas como
weake há teste de desalocação de memória para fluxos críticos. - Tarefas assíncronas em andamento são canceladas quando a tela é descartada, evitando atualizações tardias de estado.
- A navegação entre módulos passa por abstração de rota ou Coordinator, sem acoplar diretamente duas cenas de features distintas.
