Controlling Side Effects with Swift

Side effects in your Swift programs are both a blessing and a curse. They can make or break your Swift code, and learning how to effectively control them is one of the most important skills any Swift programmer can acquire.
In this talk, we’ll start with the fundamentals, looking at the differences between pure and effectful functions and how they shape the way we test and reason about our code. Then, we’ll dive into two different approaches to controlling side effects:
One that most Swift developers already use every day but may see in a new light after this talk.
Another, radically different approach that unlocks powerful unit testing that doesn’t require mocks and stubs and makes writing pure and composable programs a joy.
Come away with fresh insights and practical techniques to take your Swift code to the next level!

Close

SparkDI: Swift Dependency Injection for the Concurrent Age

In iOS development, traditional dependency injection containers based on classes face critical thread-safety challenges, leading to potential data races in concurrent environments. This 45-minute presentation introduces SparkDI, a groundbreaking dependency injection framework that leverages Swift Actors to eliminate these threading issues while simplifying the developer experience through a unified registration and resolution API.

SparkDI revolutionizes dependency management through its actor-based architecture, providing built-in thread safety without the complexity of manual synchronization. Unlike traditional solutions, which require separate methods for registration and resolution, SparkDI introduces a streamlined single-method approach that handles both operations elegantly. This simplification, combined with its unique ability to manage both singleton and normal instance scopes, makes dependency injection more intuitive and less error-prone.

The framework’s innovative features include:

• Thread-safe dependency container powered by Swift Actors, eliminating data races by design.
• Unified register/resolve method that simplifies the API while maintaining type safety.
• Advanced circular dependency resolution through DFS (Depth-First Search) algorithm.
• Modular architecture supporting clean dependency segregation across features.
• Comprehensive testing support through Swift Testing framework.

This original presentation, never before shared at other conferences, targets intermediate to advanced iOS developers seeking to modernize their dependency injection approach.

Participants will learn how to:

• Migrate from traditional class-based DI containers to actor-based solutions.
• Implement thread-safe dependency. management without performance overhead
• Leverage the unified API for cleaner, more maintainable code.
• Handle complex dependency graphs with built-in cycle detection.
• Structure their applications for better testability.

By the end of this session, developers will understand how SparkDI not only solves the thread-safety challenges of current dependency injection practices but also significantly simplifies their implementation, setting a new standard for concurrent iOS application architecture.

Close

From Modularization to Clang and Back

This talk presents a unique approach to modularizing large projects that helps to visualize and analyze the project structure, allowing it to be optimally divided into modules with minimal effort. We’ll explore how to use SwiftSyntax to construct a dependency graph between various entities in the code. Special attention will be given to the Periphery tool, which offers functionality for examining entity relationships not just statically but dynamically as well.

We’ll delve into the little-known Swift Index Store, which is key for working with metadata in Swift projects. I

n conclusion, we’ll discuss the results of this approach, including the generation of special files that simplify the understanding and management of project structure.

This talk will be beneficial for iOS developers, architects, and technical leaders interested in improving their project structure and optimizing development processes.

Close

How to Modularize a Monolith: Transforming Legacy Code for the Future

Modularizing a monolithic codebase can seem like an overwhelming task, particularly when working with legacy code. This session shares the journey of transforming ExpressVPN’s 2016 monolithic codebase, focusing on the principles and system design techniques that enabled us to modularize 80% of it. Attendees will gain insights into the architectural challenges and rewards of modularization, learning how to enhance code reusability and scalability across platforms. Join us to explore the “why” and “how” behind our modularization strategy and see how it can be applied to improve the adaptability of your own iOS projects.

Close

Staying Relevant: Cultivating Growth in an AI-Driven Era

Artificial Intelligence is reshaping industries and redefining what it means to develop software, but there’s a risk of stagnation if we rely solely on AI to do our work. This talk explores how to maintain a passion for innovation by leveraging AI as a supportive tool, not a replacement for curiosity and hands-on exploration. We’ll discuss practical strategies to keep your skills sharp while still reaping the efficiency benefits AI provides. We will learn how to integrate AI-driven solutions into daily workflows without losing sight of personal skill development. Through real-world case studies, we’ll highlight engineers and creators who balance smart automation with active engagement, achieving both productivity gains and a deeper understanding of their craft. By the end, participants will be equipped to harness AI without relinquishing their drive to innovate and grow.

Close

Harnessing the Power of AsyncSequence: Streaming Data the Modern Swift Way

Handling continuous streams of data efficiently is a crucial skill for modern Swift developers. Whether processing live event streams, network responses, or real-time user input, AsyncSequence and AsyncStream provide a powerful and structured way to work with asynchronous data. In this talk, we’ll explore how AsyncSequence enables seamless iteration over asynchronous elements, compare it to other concurrency patterns, and demonstrate how AsyncStream can be leveraged to create custom event-driven pipelines. We’ll cover real-world scenarios, such as handling WebSocket connections, processing batched network responses, and integrating real-time user interactions—all while maintaining responsiveness and avoiding common concurrency pitfalls. This session is designed for developers who are familiar with Swift Concurrency and want to take their skills further by mastering asynchronous data streams. Attendees will leave with practical knowledge on efficiently managing dynamic data flows, reducing complexity in async code, and improving app performance using Swift’s latest concurrency tools.

Close

What Video Games can Teach us about Accessibility

Video games are as diverse as their user base. To accommodate all kinds of players, game developers had to come up with creative solutions for complex accessibility problems across motor, cognitive, vision, and hearing needs. In this talk, I’ll share how we as app developers can learn from these solutions and make our apps more inclusive. Drawing from my background in game accessibility research and inclusive app development, I’ll explore practical implementations ranging from topics like accessibility-first onboarding to UI personalization, simplified layouts, and feedback through haptics and audio cues. By the end of this talk, you’ll have a better understanding to tackle complex accessibility challenges in your own apps.

Close

What could possibly go wrong?

Building an app is not easy—especially when we have to safeguard personal data, or perform important tasks for our users. We often see news headlines of the latest bug in this app or that website. While we can’t always avoid making mistakes, we can take precautions to set ourselves up for success. This talk will cover the steps my team has taken to test our apps, automate our processes and most importantly of all: ensure that everyone feels comfortable raising their concerns. This has allowed us to release regular, bug-free updates to grow apps to #1 on the UK App Store and Google Play. You’ll walk away with practical steps to ensure your next commit doesn’t become tomorrow’s headline.

Key topics include:

•  The importance of understanding the business context – regardless of your role.
• Why hypotheses matter more than hours – and how to formulate them effectively without getting bogged down.
• Strategies for breaking down tasks into manageable components for better accuracy.
• How to account for risks – and the cost of overlooking them.
• Communication do’s and don’ts – why knowing your audience matters, and when “just ask questions” might not be the best advice.

This session is designed for anyone involved in software development, from junior engineers to seasoned architects. It’s a practical, straightforward look at a skill we all use but rarely examine, offering tools and perspectives to approach estimation with confidence and clarity.

Close

Heavy Metal in SwiftUI

This talk provides an exploration of the practical use of Metal shaders within SwiftUI applications. It begins with a quick kickstart to the shaders itself, followed by a more comprehensive look at selected use cases. These use cases include transitions, visual effects, animations, and custom shapes (eg Metaballs). Each use case showcases typical implementation and includes a comparison to the alternative (non-Metal) approaches, like a combination of standard view modifiers, graphics context filters, or custom paths, illustrating the strengths and weaknesses (inc. performance) of each method. The talk’s goal is to empower the audience with the understanding of when and how to use Metal in their SwiftUI projects. According to the title, the talk is metal music themed, containing stylized visuals and analogies

Close

How A/B Testing can ruin your codebase

In this talk we’ll take a critical look at the often overlooked engineering challenges and hidden costs of A/B testing. We’ll explore how A/B testing increases code complexity, introduces risks of data corruption, expands the testing matrix, challenges debugging, etc. We’ll shed light on the real impacts on developer experience and user satisfaction. I will provide real-life insights that might reshape your perception of A/B testing and convince you that it’s a tool that needs to be wielded responsibly and requires a high engineering discipline.

Description

In this talk we’ll cover the following topics related to often overlooked costs of A/B testing: 

• Code complexity: Introducing variations and experimentation logic into the codebase can increase complexity, making it harder for developers to understand and maintain the code. Removing A/B test code and related infrastructure once a test is completed requires careful cleanup to avoid introducing technical debt or unnecessary complexity into the codebase. Failing to remove redundant code can clutter the codebase and make future development more challenging.
• Debugging Challenges: Debugging issues related to A/B test variations can be more challenging, especially when trying to diagnose discrepancies in behaviour across different test conditions.
• Expanded Testing Matrix: A/B testing expands the testing matrix, requiring QA teams to test multiple variations of features across different devices, platforms, and user segments, which can be time-consuming and resource-intensive.
• Complicates Test Environment Setup: QA teams may need to set up and maintain separate test environments to accurately test A/B test variations, adding overhead in managing and synchronising test environments with production.
• Data Corruption and Loss: Improperly managing the addition or removal of A/B tests could lead to data loss or gaps in the data stream. Adding and removing A/B tests can challenge user data integrity. Experiments can manipulate data that can’t be undone once the experiment is removed.
• User Consent and Opt-Out: Ensuring that users are informed about A/B testing activities, their data usage, and providing mechanisms for users to opt-out of participation in tests if desired, to respect user preferences and maintain trust in data integrity practices. 

…and more…

Close

Why every SwiftUI developer should care about the environment

The SwiftUI environment is one of the backbones of SwiftUI, yet – in my opinion – it is completely underrated. In this talk, I am going to explain what the SwiftUI environment is, and how it powers SwiftUI. You are going to learn how to use the SwiftUI environment to avoid prop drilling, how to use it do make your views configurable, and what are the commonalities between the environment and SwiftUI preferences. In addition to taking a look behind the scenes, we will also look at some practical use cases.

Close

SwiftTesting ~ Right Swipe or Left Swipe

Apple developers have been waiting for a long long time on a dedicated Swift based Testing framework, at last we got the answer in WWDC24 – SwiftTesting

If you are looking to enhance the quality of your app, if you are an Indie developer and looking to speed up your app releases or if you are the one scratching your head on how to migrate from XCTest to SwiftTesting, this talk covers all the above problems with an interactive demo,

Contents:

• Why do you need Unit testing in your app
• How Indie developers can speed up their app releases using Unit Testing
• Is TDD still a thing?
• Why Apple introduced SwiftTesting
• Build Blocks of SwiftTesting – (@Test, #expect, #require)
• XCTest vs SwiftTesting
• How to migrate your app to SwiftTesting
• SwiftTesting – Pros and Cons
• What happens to XCUITest now?
• Take Aways

Key topics like Tags, @Test, #expect, #require, traits and integration of SwiftTesting with Xcode Cloud will be the major parts of this talk, The aim is to make everyone in the room aware of what is SwiftTesting and whether will it benefit them in any way!

Close

Kotlin Multiplatform for iOS: Myths vs Reality

Kotlin Multiplatform keeps gaining traction with Android developers, while many in the iOS community remain wary. But are these concerns grounded in reality or fueled by age-old cross-platform myths? Join me in exploring the top misconceptions, from “KMP is only for Android devs” to “Adopting it means abandoning Swift.” We’ll clear the fog around UI sharing, development workflows, and creating Swift APIs from shared Kotlin code. By walking through real-world examples, I’ll show how it can seamlessly fit—rather than clash with—your existing iOS workflow.

Close

1,000 Projects Later: How to Approach Estimation Like a Pro

Estimation is a fundamental skill in software development, yet it’s a topic that often gets little attention. Whether you’re scoping out a complex system, designing a new app feature, or planning a personal project, the process involves more than just guessing how many hours it will take. It requires asking the right questions, understanding the bigger picture, and navigating ambiguity with a clear strategy. This talk draws on years of experience evaluating projects and focuses on actionable insights for turning loose ideas into structured plans. It’s not just about numbers – it’s about cultivating the right mindset to build strong teams, establish sound architectures, and set projects on a path to success. And no, scrum poker isn’t on the agenda.

Key topics include:

•  The importance of understanding the business context – regardless of your role.
• Why hypotheses matter more than hours – and how to formulate them effectively without getting bogged down.
• Strategies for breaking down tasks into manageable components for better accuracy.
• How to account for risks – and the cost of overlooking them.
• Communication do’s and don’ts – why knowing your audience matters, and when “just ask questions” might not be the best advice.

This session is designed for anyone involved in software development, from junior engineers to seasoned architects. It’s a practical, straightforward look at a skill we all use but rarely examine, offering tools and perspectives to approach estimation with confidence and clarity.

Close

Mind the Data Gap: Bridging User Trust and iOS Development Challenges

Stop overloading your app like a pizza with too many toppings! Want to learn how to audit your iOS app for privacy, implement transparency, and meet GDPR? Stick around—I’ll show you how to build trust while navigating Apple’s ATT policies

We’ll explore tangible solutions to common problems:
1) How to audit your app for over-collection of data.
2) How to implement privacy-focused features (like limited data collection modes).
3) How to communicate data practices transparently to users.

By the end, you will have practical strategies and tools to align with privacy regulations, enhance user trust, and maintain app functionality in the Apple ecosystem.

Close

Going Solo: Essential Tools for Indie iOS App Developers

Dreaming of launching your own app but feeling overwhelmed by the journey? As an indie developer, you wear many hats: designer, coder, marketer, and even customer support. Thankfully, there’s a wealth of tools, SDKs, and services designed to make your life easier and your app better. In this session, we’ll explore a curated list of essential resources to streamline your app-building process, from development to analytics, CI/CD, and deployment. Whether you’re looking for the best backend-as-a-service or ways to manage user feedback, this talk will equip you with practical insights and actionable recommendations. We’ll also dive into tools and strategies for App Store Optimization (ASO) to ensure your app gets the attention it deserves. If you’re ready to go solo without going it alone, this session is for you.

Close