Swift Academy Podcast, Episode 2, Season 3
Performance Is More Than Just Speed
Part two with Artem Mirzabekian and Bogdan Poplauschi, going underneath the abstractions: Swift Concurrency migration, the cost of the tools we use daily, and why application launch is an architecture problem.
Watch the Episode
The Hidden Cost of the Tools We Use Daily
Part one challenged the myths. This one goes underneath them, into Swift Concurrency, abstractions, architecture, application launch, frameworks and dependencies.
The connecting idea is that performance work rarely starts with performance. Migrating an existing codebase to Swift Concurrency tends to expose architectural weaknesses that were always there, and a dependency graph that grew quietly for two years turns into a launch time nobody can explain.
What We Go Through
Migrating an existing codebase to Swift Concurrency
The migration is where most teams meet the model properly for the first time, and where the wrong mental model gets expensive.
- Migration pitfalls, and the mental models that cause them
- What
async/awaitreally means for execution, as opposed to what people assume - Common Swift Concurrency anti-patterns that survive a migration
- The impact of
@MainActoron CPU-heavy work - When
Task.detachedbecomes a problem rather than a solution - Why blocking asynchronous work leads to deadlocks
- How adopting concurrency exposes architectural weaknesses that predate it
Abstraction versus performance
Abstraction makes code easier to read, test and maintain. It also hides what the application is actually doing, and at some point that stops being a good trade.
- Balancing clarity, maintainability, abstraction and performance rather than picking one
- Why understanding what sits underneath an abstraction is part of using it well
- Where protocols help the architecture and where they quietly cost something
Application launch and the dependency graph
- Why a complex dependency graph slows down launch, and how that happens gradually
- The hidden cost of frameworks and of the tools used every day
- Treating launch time as an architectural property rather than a metric to optimise at the end
About the Guests
Artem Mirzabekian & Bogdan Poplauschi
Lead iOS Engineer at Sovcombank • Staff Engineer, iOS Architecture & CI/CD
Artem co-hosts the Mobile System Design Interview series. Bogdan appeared twice in Season 1, on taming legacy code and on refactoring in practice, and both reviewed AI Driven Swift Architecture.
Key Takeaways
- A concurrency migration is an architecture review in disguise. The warnings you cannot silence are usually pointing at a real design problem.
@MainActoris not a safety blanket. Putting CPU-heavy work behind it moves the cost onto the frame budget.Task.detachedis rarely the answer. Reach for it deliberately, not to make a warning disappear.- Abstractions have a price. Use them, but know what they are doing underneath before they become the bottleneck.
- Launch time is architectural. A dependency graph that grew unchecked cannot be optimised away at the end.
Resources & Links
Listen & Subscribe
If your team is midway through a Swift 6 migration and the warnings are multiplying, this pair of episodes is the one to share.