A Day in the Life of a SwiftUI View
presented by Chris Eidhof
Chris will take us through how a SwiftUI view is rendered, laid out and updated.
Control your dependencies, don't let them control you.
presented by Brandon Williams
Dependencies are code in your application that talk to the outside, uncontrollable world. They make code difficult to test, they can break previews and simulators, and they can be slow to compile. Learn how to take back control over your dependencies and not let them control you.
Building accessibility into your company, team, and culture
presented by Sommer Panage
We often talk about how we as individual developers can make our apps and software more accessible–how to use the correct labels, colors, keyboard shortcuts, etc. However, very few of us actually work in isolation, owning the end to end production of our own apps. Frequently, rather, we work within companies–from smaller startups to large corporations. This talk discusses what it means for a company to build an accessible product, what models exist for accessibility teams, and how you as an individual developer can go beyond your own code to bring accessibility more deeply into the culture of your workplace.
SwiftUI to destroy the Publishing Industry
presented by Daniel Steinberg
When your controller, view model, or presenter needs to tell a SwiftUI view to refresh itself with updated data, we have used an ObservableObject and @Published. All that changes with the introduction of @Observable. In this session we’ll look at how we adjust data flow in our apps with the new Observable protocol and the @Observable macro.
Easily Reuse Custom SwiftUI Design Elements With Swift Packages
presented by Vui Nguyen
Learn to build your own SwiftUI design library as a Swift package! Apply your own custom fonts and colors to multiple projects with the ease of code modularity and reusability.
Swift Package Manager at Scale (SPM @ DoorDash)
presented by Terry Latanville
DoorDash fully adopted the Swift Package Manager in 2022 after using CocoaPods for quite a while. We have numerous self-published packages and a few internal customizations. Some engineers feel that SPM may not be ready for prime-time, we beg to differ! From practical applications to pitfalls, I'll walk through our adoption and refinements and how they can help others adopt SPM.
Improve your code with the Swift Algorithms package
presented by Danijela Vrzan
You need to iterate over a collection of elements so you write a for loop. It's familiar and it works. You still wonder if that's the best approach. But, there is a better way. We'll go through a practical example of how to make your code faster and more readable using algorithms from the Swift Algorithms package. You'll immediately see patterns and get ideas of how to improve your own code.
Fast and Fluid
presented by Gui Rambo
Users expect our apps to be fast and responsive, but there’s a lot more to making an app feel fast than just optimizing for speed. Learn Swift techniques and tricks you can leverage to reduce glitches and make your apps feel more fluid, regardless of whether you’re using SwiftUI, UIKit, or AppKit.
A better way to build APIs in Swift
presented by Michael Rebello
Imagine a world where we can jump right into building products and focus on the user experience without needing to handwrite REST/JSON endpoints and Codable models — instead using generated idiomatic Swift clients that provide a strongly typed API contract with the server, and integrating generated mocks that make testing a breeze. Let’s dive in to see how this is possible.
All Systems Go! - Architecting the systems of your app
presented by Frank Courville
As teams grow, treating every new feature as one-off development doesn't scale. As features pile onto each other, adding anything new becomes increasingly frustrating. But there is a better way; a way of systems. Smaller in scope than architecture, but larger in scope than design patterns, the system is a critical player in managing complexity.
The Bleeding Edge of Swift Concurrency
presented by Matthew Massicotte
Swift Concurrency is all about succinct, safe code. Yet, it comes with a surprising amount of subtly and new pitfalls. It’s actually quite easy to accidentally introduce races and hangs. Learn about bringing async/await and actors into your code without the pain.
10 tips to making UI design easier
presented by Claudia Maciel
Are you more technical than artistic? Would you rather work on the logic than the UI of an app? Then his talk is for you. I have found that sometimes being artistic is the hardest part of building an app, I don’t want to just do the basic layout, I would like to do have something that looks good and I am sure you would too, let me share some tips and tricks that have helped me out with this.
Unconventional Swift Patterns
presented by JP Simard
Forget best practices, this talk celebrates Swift programming patterns that break the mould. Should you use them everywhere? Heavens no. Should you occasionally colour outside the lines to give your project superpowers? Yes please!
Using Upcoming Feature Flags && A Musical Performance
presented by James Dempsey
Beginning in Swift 5.8 you and your team can flexibly adopt upcoming Swift 6 features using a new compiler flag and compilation condition. This talk describes the problem upcoming feature flags solve, their benefits, which flags are currently available, and how to get started using them in your Xcode projects and Swift packages.
James will also be performing some of his legendary Breakpoints tunes - songs about Cocoa development designed to enlighten and amuse.
Persistence Is My Superpower (and it can be yours too)
presented by Aaron Vegh
In the end, you can only hit what you aim at. Learn from my experience spending 15 years (and counting) trying to become a successful indie app developer: what keeps you motivated, how to survive the failures, and have fun along the way.
Firefox iOS: Open Source Learning
presented by Roux G. Buciu
There's two views of the open source community: the happy-go lucky ideal of open source, and the sometimes unpleasant realities of contribution. Let's explore this discrepancy by looking at a project for which I am a core maintainer, Firefox iOS, and talk about our team's open source experience and learnings from working on a Swift codebase that's filled with spaghetti code and legacy issues.
Batteries Not Included: Beyond Xcode
presented by Kabir Oberai
A confrontation of the notion that Xcode+macOS are the only way to develop apps for Apple platforms. We’ll discover what it takes to build apps in other IDEs like Visual Studio Code, as well as on non-Apple platforms, unveiling the secrets of cross-compilation to build, sign, and deploy iOS apps on Windows and Linux.