Update December 2015: The conference videos are being released! Where available, the session titles now link to the video posts.
Now that we’re over a year past Swift’s public announcement, you can find more and more Swift content in the usual iOS/Mac conferences.
But for the truly Swift-obsessed, there’s Swift Summit! Their first event in London earlier in 2015 was filled with great content and a killer speaker lineup, which means I had high expectations for the San Francisco edition.
In this article, I’ll share my thoughts on the conference and highlight a few talks that I especially enjoyed. If you have any Objective-C Bad Blood left, Shake it Off and prepare some Blank Space in your mind for this Swift Summit recap!
Everything Has Changed
The conference was packed with content over the two days: a single-track mix of 10-minute lightning talks, 18-minute and 25-minute talks, and two panels.
Among my favorite talks were those I categorized as the “big ideas” ones, where the speakers talked about some of the larger issues around Swift and Swift adoption.
Since we’re still in the early days of the language and many companies out there are being cautious about moving to Swift, these talks were great for getting a sense of what it’s like using Swift on a day-to-day production basis.
Andy Matuschak – Feet in Both Worlds: from Objective-C to Swift
Andy kicked off the conference with his talk on moving from Objective-C to Swift. He started with the question: what would Swift be like without Objective-C? And once Objective-C goes away, what’s the shape of the hole it leaves?
To please the language nerds in the audience, Andy continued with a series of hacks he’s had to use when writing Swift that still supports bridging over to Objective-C. I thought this was a great illustration of the state of the language: still in that liminal space with “feet in both worlds,” as the talk title states.
This was a thought-provoking talk because so many of the language decisions made in Swift come directly from its need to interoperate with Objective-C. There’s a certain opportunity cost paid here that we wouldn’t have if Swift were a complete clean-sheet design, and it’s fascinating to think about where the Swift language could go in the future.
The Lyft app is probably one of the larger and widely-used 100% Swift apps, which means this talk had a wealth of information about making the transition and how Swift performs in production.
From starting small with a single person working on the Swift app, to dealing with issues around long compile times and continuous integration support, the talk covered the trials and tribulations of performing such a substantial re-write.
iOS team member Vincent Ngo really liked hearing about how the Swift app started as a small prototype and grew from there:
Although an Objective-C rewrite would have been an improvement over the aging codebase too, the added benefit of Swift’s safety features and concise syntax was a nice bonus. I’m sure maintaining 25000 lines of code, down from 75000, makes the Lyft team a little happier at work!
Wildest (Coding) Dreams
Next up are the talks that had code, code and more code!
As a technical conference, there were plenty of talks showing off the latest coding techniques and open-source libraries. I don’t always make time to dive into open-source code, and these kinds of talks scratch that itch for me and leave me with a pile of repositories to star and come back to later.
Sam Soffes – Simpler Tables with Values, Enums, & Protocols
If you’ve dealt with tables in watchOS, you know how easy it can be to set up a table without a delegate or data source: just specify the number of rows, and then configure each cell. Sam showed how you can have a similar level of elegance, thanks to the code that wraps the Cocoa complexity with Swift simplicity.
Thomas Visser – Beyond the Block-based API: Building a Simple Future
Thomas pulled off the challenge of live coding to refactor some asynchronous code that fetched data from the network to use futures.
From a starting point of callbacks and completion handlers and a “pyramid of doom” with lots of indentation and/or private helper methods, Thomas was able to refactor the code to use futures, complete with type safety and error handling.
Swift team member Eric Cerney dislikes messy syntax enough to be convinced:
You can check out Thomas’s open-source futures library, BrightFutures, on GitHub.
He also included a binary hex dump, which is always a good sign in any talk:
In contrast to the usual musings about higher-level structs and protocols in Swift, JP’s talk was a nice change in getting down to the byte level.
Chris opened up day 2 of the conference with a live coding demo on value vs reference types, a topic that still generates a lot of discussion and questions.
By wrapping an
NSData instance in a struct, many issues came up that Chris had to resolve:
- How do you handle mutation of a value type?
- How do you mix value types and reference types?
- How do you handle sharing and copy-on-write?
I liked the problem-solving approach here, where Chris would write some code, demonstrate a problem in the implementation, and then fix it.
With much of the Cocoa APIs being class-based, this talk was a great demonstration of how to make the transition to value types and structs to keep thing Swifty.
Eyes Open (to Swift)
Most of the talks didn’t have live coding and were about general topics on Swift—things such as functional programming and dealing with legacy Cocoa APIs. Others drilled down into specific topics such as error handling, tvOS and the wider questions of whether to make a watchOS app.
The breadth of topics at the conference was amazing; I don’t use Cocoapods very often and have never used ReactiveCocoa, which makes hearing about these topics a real eye-opener and lets me step outside my usual comfort zone.
Natasha Murashev – Protocol-Oriented MVVM
Natasha “The Robot” Murashev combined two popular paradigms—protocol-oriented programming and MVVM (model-view-view model)—into the super-initialism POMVVM.
Using the common task of configuring a table view cell, she took us through how to refactor a complex method into smaller pieces with the help of protocols, protocol extensions and view models.
I’ve used protocols and MVVM separately, and putting them together seems like the most natural thing in the world after hearing this talk. The key points here:
- Use protocols to configure your views
- Use protocols extensions for defaults
- Use view models to provide data for the protocols
The combination of protocol extensions with default implementations to override and view models offers a very elegant separation of concerns. I definitely suggest checking out the video for this talk to hear all the details!
I really enjoyed Gwendolyn’s lightning talk about one thing that makes Swift swift: vtables!
With people so used to full dynamic dispatch in Objective-C, this talk was a good reminder of how things have changed in the move to Swift. She covered
objc_msgSend vs vtables, and gave a very clear explanation of how vtables work with class inheritance and why Swift can be faster when calling methods.
OK, I’ll plug my own talk here. ;]
While thinking about how to use protocols, I got the idea to go through all of the protocols in the standard library to see how the Swift team at Apple was using them.
iOS team member Vincent Ngo was kind enough to write the following about my talk:
“Greg split up protocol creation into three categories, the “can do”, “can be”, and “is a” and gave examples of how we can create the different types of protocols. I will definitely be looking at how Apple writes Swift code to learn about their various coding practices. This talk is a good one to watch if you want to learn more about how to use protocols in your projects.”
Two (or more) Is Better Than One
Finally, there were two panel sessions at the conference – one on each day. I usually don’t like panels as they can get unfocused and soapbox-like, but the two panels here were great.
Conflict of interest declaration: I moderated one of the panels, which might skew my opinion a bit. ;]
The first panel dealt with Swift going open-source and what that might mean for cross-platform development and the community as a whole. There were predictions, good old speculation, and a discussion on how open-source Swift could affect regular app developers who might never contribute to the compiler or standard library directly.
The second panel was about Swift in production. The panelists had varying amounts of Swift code in production, and it was fascinating to hear about the range of where people were using Swift, how it worked with their build systems, and general tales of the migration away from Objective-C. I’d suggest checking out the video for this session along with Keith’s talk if you’re thinking about making the jump to Swift in production.
Where To Go From Here?
I had a great time at Swift Summit SF 2015 and enjoyed every minute, from the nervousness of giving a talk to meeting attendees to herding together the raywenderlich.com team members in attendance for a group selfie.
I missed the hands-on interactive nature of a conference like RWDevCon, but I especially enjoyed the single-track format, since this meant I could attend every talk and panel. As a programmer and total nerd, I also liked how the conference is Swift-specific and packed with technical content, in contrast to CocoaConf or 360iDev, where there are also business and design tracks.
If Swift is your thing and you want to dive into a wide variety of technical talks, I highly recommend checking out the videos and attending a future Swift Summit! I think you need at least some Swift experience before attending — the sessions didn’t cover the absolute basics of Swift.
iOS team member Scott Berrevoets had this to say about the overall experience:
Between watching all of the Swift Summit London videos and attending in San Francisco, I’m more excited than ever about coding in Swift and participating in the developer community.
Were you at Swift Summit too, or do you have any questions about the conference? Join the discussion in the forum comments below!