Adam Bell, @b3ll
As we enter a new decade of iOS, apps are transitioning from looking pretty to being highly interactive. Building apps where everything feels interactive and interruptible is crucial to making things feel magical, but pulling it off can be rather difficult. We'll go into a deep dive on some advanced techniques on how to build apps that use lots of motion, animations, and gestures to make them stand out as first class citizens on iOS.
Alan Zeino, @alanzeino
In September Uber debuted a complete rewrite of its iOS app. In addition to a whole redesign we shipped a new architecture, powered by Swift. Along the way we learned a lot about ourselves, and we’d love to share some of our stories and insights with you. In this talk we’ll talk about how we undertook such a large rewrite while grappling with growing compilation times, Xcode performance, and hundreds of engineers in one codebase.
Ash Furrow, @ashfurrow
Different programming commununities have different approaches to how they handle asynchronous programming. Some use callbacks, others use promises, and they all seem to have really strong opinions. This talk will focus on popular approaches to async programming used outside the Swift community, exploring how those approaches could fit in with the Swift language. Some paradigms are encapsulated in existing libraries, while others would need changes to the Swift compiler.
Harlan Haskins, @harlanhaskins
Compilers are treated with a fearful reverence that betrays how fascinating and approachable they really are. In this talk, we'll discuss LLVM and how it works by building a real compiler for a toy language called Kaleidoscope. We'll implement many of the fundamental building blocks of compilers and see how certain Swift features make it a great compiler language.
- Slides
- Demo Source Code
- In Depth Blog Posts
Chris Bailey, @chris__bailey
Chris Eidhof, @chriseidhof
In this talk, we’ll look at mutation in Swift. Mutation gets a bad rap, but together, we’ll look at the reasons behind that and debunk some myths surrounding mutation.
Note: This was a live demo, there are no slides for this talk
Dennis Pilarinos, @dennispilarinos
A Swift developer's time is valuable. Ideally, it should be spent crafting an application that their users will love - not focused on the tedious tasks involved in setting up and maintaining infrastructure. Two years ago, in the process of building an iOS app, a couple of friends realized that they were spending more time fighting with their build and deployment system than actually building their app. They put that iOS project on hold to try and build a better CI / CD platform for mobile developers.
Today, buddybuild provides the platform that thousands of mobile teams use to build apps that their users love. Its continuous integration, continuous delivery and user insight platform streamlines the process of building mobile apps. It also eliminates the friction development teams often face when involving their end users as part of their development workflow.
This talk will dive into what's involved in designing, building, scaling and operating one of the most popular CI/CD platforms for mobile developers. We'll also share some the best practices and trends we've gathered in the process.
After this talk, the audience will be equipped with of a set of best practices to improve their Swift development, and some fun stories of building and operating a high scale, highly available distributed build system.
Erica Sadun, @ericasadun
Style rules aren't enforced by the compiler. They aren't mandated by any specification. They're not official. Style rules are personal or organisational opinion on specific styling choices that make your code Swiftier. Here's why you should adopt style guidelines to support better and more maintainable code.
Felix Krause, @krausefx
I'll be talking about the different stages of open source projects, how handling PRs and support change with scale and how to keep innovating with a bigger user base. With that in mind, I'll go into detail on how developers can solve those problems, in particular automating workflows, staying in closer contact with contributors and improving your product and documentation.
Greg Heo, @gregheo
Object-oriented, functional, procedural…do we really need another programming paradigm to take up space in our brains? In this talk, you’ll learn the basic concepts of reactive programming and why they’re useful. As a motivating example, you’ll see a traditional Cocoa app transformed into its reactive counterpart.
More importantly you’ll come away with some new patterns and paradigms to expand your programming toolbox, whether you make a complete conversion to RxSwift or borrow some ideas to use in your existing object-oriented project.
Hector Matos, @allonsykraken
Jason Brennan, @jasonbrennan
Everybody knows of Swift Playgrounds, Apple's interactive programming environment for learning Swift, now on the iPad. But did you know Apple had an interactive programming environment 30 years ago, also called Playgrounds?
This talk explores Apple's Playgrounds, an interactive graphical programming environment, designed by Alan Kay and his team, for young children to learn programming and complex systems. We'll look at the design principles that went into this 1980s environment and see what it was capable of.
Playgrounds of the 1980s were capable of realtime, interactive, live-programmed objects (for example, in an underwater ecosystem simulation). We'll look at how things have changed from the Playgrounds of yesteryear to the Swift Playgrounds of today.
Marin Usalj, @_supermarin
Every iOS developer has hit the wall of trying to publish an iOS app. Code signing is one of the most hated topics in the field: it's obscure, complicated and not well understood.
This talk is intended to clarify all the components in the code signing process, and should save you some time in the future.
The talk will go over private keys, .p12 export, certificates, certificate requests, provisioning profiles, teams, and finally provide a couple words about automatic provisioning. Most importantly, it'll cover common mistakes people are doing when trying to fix issues.
Matt Comi, @mattcomi
Big Bucket's game Space Age can be described as a mashup of an Real-time strategy and an adventure game. Space Age has units and missions, but also inventory and dialogue. When a unit needs to navigate between map locations, it uses the A* pathfinding algorithm. As well as A*, Space Age employs some novel techniques to ensure that units don't bump each other while also ensuring that their navigation appear natural and ad-hoc, not coordinated or precognitive. I will be discussing some of these techniques.
Matt Gallagher, @cocoawithlove
By default, Swift aims to be a simple-to-use language that protects the programmer from the details of memory management, type implementations and function invocation strategies. However, when we need high performance, we need to understand the details of what Swift does at a low level so we can use that knowledge to help Swift produce code that performs optimally.
This talk will look at how Swift implements generics, protocols, modules, reference counting, closures, copy-on-write and inheritance and look at how each of these features can have performance that varies by as much as a factor of 10, depending on how you use them. I will look at how to read profiling information in Instruments to identify which of these features is the source of performance problems and how to restructure code to solve these problems. I'll talk about which Swift features can be used at different scales from 10,000 iterations per second through to 1 billion iterations per second.
Rachel Bobbins, @bobbins
Refactoring existing code can be hard. You can recognize your existing pain points, and might have an idea for how to solve them. But, that journey from point A to point B can be fraught with compilation errors. These compilation errors can stop you from making incremental progress.
In this talk, I'll talk about some of the strategies you can use for incrementally refactoring your Swift code, by leaning heavily on the compiler. You'll be able to keep your app functioning and your tests passing, even while gutting your app from the inside out!
Samuel Giddins, @segiddins
Strings are usually the first or second data type we learn to work with as programmers. Despite appearing deceptively simple, misunderstanding and misuse of strings abound in the code we write every day. From performance problems to unicode correctness issues to complex APIs and the challenges of displaying strings on screen (and storing them on disk), we'll look at ways to wrangle our favorite data type. Swift forced many of us to question how strings really worked for the first time, so we'll use Swift's String interface to understand what makes strings so slow and difficult, and explore some ways to make working with them fast and easy.
Soroush Khanlou, @soroush
Sequence and Collection are two of the deepest and most interesting and deepest protocols in the Swift standard library. We’ll take a deep dive into these protocols and their related protocols and types, like Index, Sliceable, and RangeReplaceableCollection, and how they each interplay.. We'll build a LinkedList implementation to explore Sequences and how Iterators interact with them. We'll talk about Collection, and build a few extensions using the abstractions that Collection gives us. By the end, you'll know everything you ever wanted to know about Sequence and Collection.
Tamar Nachmany, @tamarshmallows
Unit testing is a driving force in the way many iOS engineers architect codebases. It is a vehicle for change, opening up opportunities to make changes without breaking everything. It also pushes codebases to be more modular. But modularity presents tradeoffs, sometimes making it more challenging to introduce new functionalities to an app.
In this talk, I will discuss why even though unit tests are not user facing in any way, they are the perfect technical topic to teach the designers on your team about. I will highlight engineering concepts that support unit testing, like state and dependency injection, and share lightweight ways of bringing designers into the unit testing process, like running and sharing snapshot tests.
I hope this will be a talk iOS engineers can share with the designers and product folks they work with to break down barriers and start a conversation about architecting apps that support both unit testing and bold design iteration.
Wendy Lu, @wendyluwho
At Pinterest, we recently completed a rewrite our iOS app for a faster, cleaner experience. Speed is something that has always been very important to us. I’ll share some techniques we used to achieve large gains in app startup time and scroll performance. Another of the goals of our re-architecture was to move to a completely immutable model layer. I'll discuss the motivation behind our migration, and explore how our new system handles updating models, loading new information from the API and other data integrity concerns.