A Major
iOS Conference
in New York City

Welcome to Dynamic Island! As the mayor of the island, it’s up to you to make sure you bring all kinds of residents and supply them with Live Activities. With a whole island at your disposal, how do you build the best of the best? How can we avoid pitfalls to keep residents happy? Let’s find out!

The goal of this talk is to make the Dynamic Island development into a very friendly and even humorous experience. We’ll talk about the Live Activity place in the hierarchy of Widgets and hosting apps, and we’ll discuss some best practices and things we should definitely try to avoid. By the end of the talk, attendees should have formed strong associations to the material through examples and analogies.

This talk is themed in such a way that it takes a lot of inspiration from the Animal Crossing (and other farm/sim titles, for that matter) games. The Dynamic Island and Live Activity APIs are really fresh, so it makes sense to have some modern fun. By likening the process of building Live Activities to that of building a village-based island, it is my hope that we leave attendees feeling like they can easily recall the nuts and bolts of the API much like several of us have a muscle memory for UIKit, SwiftUI, and other existing frameworks that we are so familiar with.

Get ready to add flavor to your app with expert tips on creating tasty #SwiftUI animations!
In this talk, Pavel will present a selection of recipes for creating animations, transitions, and eye candies, and discuss their use cases and performance impact on the UI.

We will squeeze the juice out of Shape APIs and AnimatableData. We will peek under the lid of Canvas and off-screen rendering, and we will make our life easier by implementing handy view modifiers.
Let’s get cooking!

His talk is about the mistakes I made when building iOS applications using SwiftUI framework. It will cover the architectural decisions which led me to work against the framework instead of harnessing the true power of the SwiftUI framework.
You will also learn how and when SwiftUI decides to re-render views, how to slice environment objects, previewing UIKit controllers in Xcode previews and much more.
After watching this talk, you will have a better understanding of how to organize and structure your SwiftUI apps and be comfortable using the built-in architecture provided by SwiftUI.

I was listening to a Swift by Sundell podcast episode and Sommer Panage said: „Autolayout is actually an accessibility feature”. And I thought, of course! Pixel perfect is dead! There was only a brief period early in my career as an iOS developer, where I could roughly hardcode UI dimensions to perfectly reproduce a design in a 320×480 pixel display. Those days are long gone! iPhone 4 came out with a higher density screen, iPhone 5’s screen had a different aspect ratio -breaking a good chunk of the apps in the market-, and then there was the iPad, and bigger iPhones, and smaller iPads, and split screen… You name it! This small but considerable fragmentation revealed a not-so-hidden truth. User interfaces are not static. They’re alive! And flow and change to adapt to the user’s needs and preferences. They come in dark mode, configurable text sizes, different languages, increased contrast, different orientations, and bolder text… all to make our apps more accessible to everyone! We’ll see, together, how you can develop adaptive apps in UIKit (and SwiftUI!). Pixel perfect is dead, long live to adaptive iOS apps!

The Composable Architecture (TCA) is a popular framework that unifies your architecture for Swift apps.
In this talk, we’ll look at lessons learned from using it on large codebases, potential gotchas to be aware of and improvements & dev tools you can add on top of vanilla TCA

A while ago, someone gave me feedback that “anything infra-related” was one of my biggest weaknesses. So, logically, I decided to switch from working on ios feature development and embark on a journey to transform myself into a mobile infrastructure engineer. This leap outside of my comfort zone taught me so much about my fear of failure, how I approach my learning journey, and how to start swimming when you willingly jump in the deep end. In this talk, I want to demystify what “mobile infra” actually is, and share with engineers what steps they can take to put themselves in the right mindset to learn something that scares them deeply.

A kickstart on how to use Xcode Cloud completely from scratch and with no prior knowledge required. It will be a live coding session showing how Xcode Cloud can help you automate your app’s delivery, run tests on CI and even run certain fastlane actions and scripts!

We will take a demo iOS/macOS app and we will integrate Xcode Cloud from scratch to:
* Run all its test plans at different points – on PR, push to main.
* Submit builds to TestFlight.
* Show how it integrates with App Store Connect and how to handle releases.
* Show its pros/cons compared to other alternatives such as Github Actions.
* Show how it can run 3rd party scripts and integrate with Fastlane. I will also show to slowly migrate fastlane actions and plugins.

This talk is for anyone who’s curious about Xcode Cloud and wants to learn more about it, regardless of their experience!

In this talk, we’ll take a look at the current state of Swift on the Server – there have been a lot of developments over the last 2 years that have really solidified Swift as a true contender for teams building apps on the backend. We’ll also take a look at some of the upcoming language changes that are going to really propel Swift ahead of many of the traditional and new languages currently popular on the backend.

ExtensionKit is the underlying system powering all extension types on iOS and macOS. In macOS Ventura, it was quietly opened up to 3rd party developers. This means you can now create extension points for your own apps, and also extend others. And the ways apps that do this comes with enormous flexibility and power. In addition to inter-app communication based on XPC, you can also construct fully-remote views using SwiftUI.

In this talk, you will learn exciting bits and details on how Swift Concurrency requires a different way of thinking than you might be used to.

Often, we look at Quantitative Data as the ruler of all information. Just add an analytics library and now, behold, all the statistics! The averages, means, and medians! We think we know it all: user retention, stickiness, where our users drop off and why. But… what about the silent sibling, Qualitative Data? Learn why and how to master it in this session. Expect fun and chaos!

Dependencies are the types and functions in your application that need to interact with outside systems that you do not control. Classic examples of this are API clients that make network requests to servers, but also seemingly innocuous things such as UUID and Date initializers, file access, user defaults, and even clocks and timers, which can all be thought of as dependencies.

You can get really far in application development without ever thinking about dependencies, but eventually, they can cause many problems in your code base and development cycle:

Uncontrolled dependencies make it difficult to write fast, deterministic tests because you are susceptible to the vagaries of the outside world, such as file systems, network connectivity, internet speed, server uptime, and more.

Many dependencies do not work well in SwiftUI previews, such as location managers and speech recognizers, and some do not work even in simulators, such as motion managers, and more. This prevents you from being able to easily iterate on the design of features if you make use of those frameworks.

Dependencies that interact with 3rd party, non-Apple libraries (such as Firebase, web socket libraries, network libraries, etc.) tend to be heavyweight and take a long time to compile. This can slow down your development cycle.

For these reasons, and a lot more, it is highly encouraged for you to take control of your dependencies rather than letting them control you.

But, controlling a dependency is only the beginning. Once you have controlled your dependencies, you are faced with a whole set of new problems:

How can you propagate dependencies throughout your entire application that is more ergonomic than explicitly passing them around everywhere, but safer than having a global dependency?

How can you override dependencies for just one portion of your application? This can be handy for overriding dependencies for tests and SwiftUI previews, as well as specific user flows such as onboarding experiences.

How can you be sure you overrode all dependencies a feature uses in tests? It would be incorrect for a test to mock out some dependencies but leave others as interacting with the outside world.

In this talk, we will learn how to take control of dependencies instead of letting them control you, and in the process fix all of these problems and more.

When you push a button to call an elevator, what happens next? You’ll see lots of modern Swift code on the screen as we work through the problem. 

🛗What’s the best way to model all the components for a time-dependent, asynchronous simulation like an elevator bank?

🛗 How do we write the logic to get the elevators to service anyone on any floor? 

🛗 What optimizations can we add to our code to make the elevators faster or more efficient? 

🛗 What other features do modern elevators have that we might want to include?

Attendees will walk away with a deeper understanding of how elevators work, as well as their algorithms, and will learn some great Swift tricks as well.

2022 saw mass layoffs in tech companies of all sizes, and 2023 isn’t looking so stable. Searching for a job can be an intensely stressful process, especially if you just lost yours, and especially if every few weeks there’s a high-profile news story about several thousand more people suddenly looking for software engineering jobs too.

But this talk isn’t just about job searching. We’ll talk about setting healthy boundaries and goals, taking care of ourselves, and ultimately acknowledging that getting laid off is not a simple problem that can be solved by simply figuring out a solution that runs in O(n)

More and more web and mobile developers are using local storage to ensure good response times and that applications continue to work in the absence of a network connection. But how do you sync local storage with the backend? How do you resolve conflicts? In this talk, I present to you an open source framework (Amplify DataStore) that allows you to develop modern web and mobile applications that answer these questions with a minimum of a line of code.

Pietro will share his insider information on how app aggregators work, present case studies of app exits and partnerships, and provide insights on how to increase the value and valuation of an app.