Schedule

The best time to talk with speakers and attendees

Okay, it turns out there is an actual human being behind the Siri voice: Susan Bennett, singer, voice actor, and the original voice of Siri on the iPhone 4S and beyond. In her presentation, Susan will give you a peek behind the scenes of the Siri recordings, how they were done, and how the scripts should probably become part of the Smithsonian collection! Susan also talks about the voiceover business, which is how she became the voice of Siri in the first place; she does a lot of different character voices and describes how technology dramatically changed the face of voice recording over the last couple of decades. Finally, Susan discusses the very human emotional challenge of being the voice of Siri, and becoming “Accidentally Famous” as well. Susan’s presentation takes a look at technology from an artist’s point of view…from a human point of view, so relax, bring your lunch and your sense of humor!

• How the Siri recordings were done
• Where Siri and other digital voices come from
• Insight into the voiceover and recording businesses
• How to take the “high road” when faced with a challenge!

From the onset, Swift was designed to take over the world — or at least the programming world. So it’s no surprise that the development community is excited to bring it’s power to as many platforms as possible. Our eager community was given Swift on Apple platforms, but no sooner than it was open sourced did we get the power to write Swift on Linux (and some people have even figured out how to run it on Android)! In this workshop, we’re going to focus on the first two. Together we’ll build the foundations of a restaurant reservation service. We’ll start by making a server, written in Swift, for our app to interact with. Once we have the server and the app in place, we’ll build a watchOS app so you can use our service without having to dig out your phone!

• How to build and deploy a Swift server, using the Perfect framework
• How to build a simple iPhone app that will interact with data from our server
• How to more easily debug cross-platform issues
• How to build a simple Apple Watch app to expand upon already rich features

For a topic so fundamental to the practice of software engineering, designing test suites and measuring their efficacy remains difficult. For example, how does one determine the origin of a test failure in the codebase, or know if they’re designing testable components? Beyond that, what are common indicators of an over-tested codebase? Questions like these become more challenging given particular domains and applications, and usually require non-obvious testing strategies.

To help you answer these questions, this presentation will go through the development process of a thoroughly tested audio synthesizer and demonstrate patterns and methodologies that can help you build a better test suite. By the end of the presentation, you’ll have developed a toolkit for building an effective, easy-to-use, and understandable test suite.

• What metrics to consider when measuring the efficacy of your test suite
• How to intentionally indicate a specific part of your codebase is the source of a failure
• How a test suite guides your system’s design & eases re-factoring
• How system boundaries influence a codebase’s testability
• About collaboration, contract, integration, journey & white box/blackbox tests
• About system & feature-level testing

iOS technologies are rapidly evolving with every WWDC announcement, and it is increasingly challenging for iOS developers to keep up with the features, innovations, and best practices. It is especially difficult for those preparing for job interviews to navigate the breadth of information available and focus on the most critical topics and skills. Whether you’re a beginner developer seeking that dream job or a seasoned veteran who is ready for a better one — this talk will prepare you to succeed in your next technical iOS interview.

This presentation will give an overview of the most important topics and skills covered in a technical iOS interview including

• typical questions during the various interview stages from phone screens to onsites
• critical components of the iOS tech stack: UI, networking, storage, design patterns, etc
• contemporary best practices
• best resources for preparing for technical interviews

At the end of this session, the audience will be fully ready to tackle their next iOS interview and know where to go to improve their skills and knowledge in specific topics.

Understanding Auto Layout is your best chance to write UI code you can be proud of. Its power often underestimated, its features easily misused, I find it overall less appreciated than it could be, if more widely understood.

This talk is aiming to show how relying heavily on Auto Layout makes you move faster and be more confident writing UI code. Working with the safe area, showing off custom UILayoutGuides and making use of the controversal UIStackViews, we will walk through the simple code of a more complex interface together.

• How to express layout fast and simple, without touching Interface Builder
• How Auto Layout helps to reduce state in your views / view controllers
• Why the safe area is great and how to rely on it without knowing what device your code is running on
• When to use custom UILayoutGuides and how they help to avoid using numeric values all around
• UIStackViews: why they are great, but controversial. How to work with stack views in scrollable layouts

A lot of developers are quick to say that designers should learn to develop. To me, being able to design is an important skill to have as a developer. We all know that there is a significant divide when it comes to designers and developers. This split limits us to be better developers because sometimes we do not want to see the other side of things. Sometimes we as developers do not understand the designer’s point of view. Developers and designers have different specialties that we can leverage from each other.

In this talk, I will discuss the different specialties we can take advantage of from both sides. Additionally, I will cover why you should start picking your designer’s brain today. Finally, I will discuss how to get started and what tools designers are using today for doing wireframes to iOS app designs.

• How design helps you as a developer and how each of us can take advantage of both sides
• Why you should start picking your designer’s brain
• How to get started and what tools designers are using today

My talk will tell our 3 year story as a 2 person independent developer team making the two popular photo and video editing apps Typorama and Videorama, reaching 6M downloads worldwide, generating 1M+ annual revenue on the App Store. I’ll be talking about both the technical and the business tactics and strategies we used to drive downloads and create products loved and used by millions.

Learning and using the latest programming technologies and trends is cool, but if you combine that with a business and marketing know-how, developers have a huge potential in their hands to create super profitable micro businesses just on their own. Making a living off the App Store is getting harder each day, and I’ll help the audience learn how to hack their way to success.

Writing Swift, I have a strong preference for immutable objects, why? Because immutability leads to simplicity and clarity since implicit in an object’s creation, is a guarantee that it will never change.

It is remarkable how much this single, seemingly, simple fact, can make programs easier to verify, and reason about.

But, in object-oriented environments, blindly defaulting to immutable objects can lead to unintended consequences.

• Why immutability.
• Walk through how I chose an immutable object to solve a problem, how that lead to a perplexing bug, and how I resolved it.
• Establish when to consider using immutable objects.

Known as “Apple-sanctioned man-in-the-middle attacks,” the NSURLProtocol class is a powerful Foundation abstraction that intercepts network requests at runtime before they hit the URL loading system. It has been used to implement proxy-like functionality, stub HTTP responses, eavesdrop on your 3rd party libraries’ network activity during production deployments, arbitrarily transform URLRequests on the fly, or implement custom protocol schemes. Using this class well requires understanding of how it behaves at runtime, and there are a few runtime gotchas that you must know to handle!

• How to simplify test suites involving API calls by using NSURLProtocol to stub server responses
• The ability to see HTTP data that 3rd party libraries and frameworks share with their hosts
• A refresher on the few different method dispatch types in Swift
• The dark magic that is method swizzling (exchanging method implementations of function pointers at runtime)
• How to swizzle their way around a critical bug (Apple erroneously sets all HTTP Bodies to nil) in NSURLProtocol
• The ability to implement API versioning, synthetic responses, remote cache invalidation, and API rerouting on the client (a lighter weight HAProxy or Varnish)

Let’s be honest here: forms are probably not the shining star of your app. But they’re one of the first things a user sees, and can huge stumbling blocks to user trust if you don’t give them some thought.

So take your forms from 😡 to 😍! We’ll cover UI basics, implementation details, and UX strategies for building the best forms on the App Store, all with real-world details you can take right back to your desk and start using.

After this, your users might even wish for more forms.

• Building forms that let your users quickly and easily give you information.
• Understanding how to get the data your app needs.
• Learning how to get the user back to the app they love.

The beginning will be a discussion on the struggle/arguments that iOS developers have over which way is better for creating UIs: Storyboards or Programmatic.

Then, I’ll present a middle ground that is the main topic: building UIs in Playgrounds. This is a technique that the Kickstarter team uses in their app (which is open source), and I use that as a starting point, but I have developed practices around it to make it more accessible.

We’ll talk about some of the benefits you get that neither Storyboards or traditional programmatic UI have (access to app behavior, animations, TDD style, very fast edit/run cycles for prototyping)

There will be some live-coding to give the feel of what it’s like to do this in the context of an app (a playground that is part of a larger app project).

• Understanding how to work in a hybrid environment with the visual experience you get in a Storyboard, but the benefits you get from a programmatic UI (creating the UI in a playground).
• Learning all the tips and tricks to improve your efficiency while working in hybrid mode.
• Mastering programmatic UI will be easier because you can see the effect immediately without running the app.

Code signing ensures that all mobile apps come from known, trusted sources and haven’t been tampered with while in transit to a user’s device. Though an integral part of keeping the iOS ecosystem secure, for many developers Apple’s code signing methodology remains somewhat cryptic.

We’ll begin by defining code signing at a fundamental level-covering the basics of hashing and public-key cryptography-in order to gain a clear understanding of code signing before diving into Apple’s implementation on iOS. Unlike other mobile platforms, code signing on iOS involves additional layers of security; we’ll describe the functionality of provisioning profiles, certificates and keychains. We’ll dive into why Apple’s code signing is mandatory, and how it extends the concept of the chain-of-trust from the operating system to the apps, and prevents third parties from loading any potentially harmful code.

• Attendees can expect to walk away with a more firm understanding of why code signing is necessary, what it accomplishes, and how it protects you and your users.
• Attendees can expect answers to questions such as:
• What’s a keychain for? What are certificates and provisioning profiles?
• How do these objects interact during the code signing process?
• How does code signing protect me and my users?
• We will equip attendees with the knowledge they need to build more complex applications and successfully release apps by creating clarity around Apple’s code signing methodology.

Accessibility is an often ignored part of iOS development, partly because much of it is “baked in” to the OS and “just works” most of the time. However, building custom UI elements and interactions can lead to a breakdown of accessibility. In this talk, we’ll explore VoiceOver, the screen reader that allow many disabled users to interact with your app. We’ll walk through a non-accessible app and optimize it for VoiceOver users. Finally, we’ll go over common pitfalls and solutions to keep in mind when designing and building accessible experiences.

• Having a better understanding of VoiceOver.
• Understanding how run a quick accessibility audit to find places in your app that could use improvement.
• Being able to argue why it’s important to invest in accessibility and have concrete steps on how to make an app easier to use.

As developers we often take the text rendering system for granted. As a fundamental part of both iOS and macOS we often don’t give it a second thought. It’s just there. This session will explore: the transition from 7 segment LED text to the beautiful fonts we use today, translate the vocabulary designers use when describing text layout, and conclude by examining TextKit and how to get direct access to font paths.

A better understanding of

• Fonts and font formats.
• Text layout vocabulary.
• A deeper understanding of text rendering in iOS and macOS.

As a developer who’s been bitten time and time again by Daylight Saving Time and related bugs, by now you’ve mastered the art of wrangling dates and times in Swift. Or have you? This talk will cover some of the more inscrutable topics of dates and times: how many seconds are there in a particular year? How do I get a notification to fire at exactly 9:00 AM on the user’s phone? What if my user isn’t using the Gregorian calendar and I want to draw a calendar? In this talk, we’ll cover all this and more, drawing on the Swift standard library and Apple’s system SDKs to manipulate the very fabric of time itself… or at least it’ll feel that way by the time we’re done.

This session covers more advanced date and time code. An attendee will be able to reliably schedule notifications in the user’s local time, find dates in the future, and even work with calendars with different numbers of months, days in the week, and more!

Security is hard. It’s filled with complex math and obscure system details, but that isn’t why it’s hard. Security is hard because it requires a different way of thinking. It’s about what systems really do rather than what they’re supposed to do. It’s about making things fail rather than succeed. It’s about controls and response more often than code and algorithms. And at its best it’s invisible and thankless. You never know all the bad things that didn’t happen. Security is critical. In our hyper-connected systems filled with sensitive information, we need developers who understand how to think about security and how to implement secure systems. Security requires expertise, but it can’t just be left to experts. It has to be a part of every stage of development. No one wants to be the next company listed under an embarrassing headline.

• How to think about security and apply it at each stage of development
• What problems security can and can’t solve
• The basic tools and techniques attackers use
• How to make your systems resilient against attack
• The difference between encryption and obfuscation and how to use each correctly
• How to authenticate users and handle passwords

Do you find yourself creating messy code in order to transform Swift optionals? Do you wish you harnessed the functional power of Swift more? This talk is for you! Come learn about creating elegant code with map, flatMap, filter, and reduce through some cupcake magic. Let’s make your code more Swifty!

• Functional programming building blocks
• Manipulating collections with four functions: map, flatMap compactMap, filter, and reduce
• Have good examples of how to use them in their code

Part of making an iOS app an enjoyable experience involves some magic… err illusion. One of those illusions is that if a user leaves your app and it goes to the background, when they return everything will be exactly as they left it. The reality is that, with few exceptions, your app will actually be suspended, then deallocated by the operating system. Without a little trickery, when users come back to your app they’ll be greeted with a launch screen and have to start their navigation experience from scratch. Join me as we talk about some of the tricks you can use to ensure that when users come back to your app everything appears as if they never left.

• Why state restoration is important.
• How to set up basic state restoration using Storyboards.
• Best practices for restoring scroll position in TableView and UICollectionViews.
• How to leverage the state restoration API for custom situations.
• When to forego state restoration and just start over.
• A few tricks for improving app launch speed.

In this hands on session you will build a simple iOS app using Firebase Cloud Firestore. We will include topics like getting setup with Firebase, storing data, and advanced queries.

• Read and write data to Firestore from an iOS app
• Listen to changes in Firestore data in realtime
• Use Firebase Authentication and security rules to secure Firestore data
• Write complex Firestore queries

The evolution of user interfaces in mobile apps continues with the most natural way of expressing the user’s wishes - their voice. Understanding what the users say is not an easy task.

In this talk, you will learn about several speech analysis approaches that help you in this challenging task, from Apple’s brand new Core ML and SiriKit, to Google’s Dialogflow and Facebook’s Wit.ai, along with some well known Natural Language Processing algorithms like the TF-IDF.

• Introduction to Conversational Interfaces
• Getting to know several approaches to understanding language on iOS with Swift
• Learn what are the challenges we face when we develop voice responsive apps

Wayfair has one of the largest iOS teams in Boston, with around 40 developers all working on a single product. Our codebase is large, it has a sizable amount of legacy code, and it is extremely active and constantly changing. Because of our size and scale, we are starting to encounter problems that impact our entire iOS team. These include:

• Code ownership and code quality are tough to define and keep consistent.
• Our transition to Swift, while having many benefits, has caused compile times to become a bottleneck for our developers.
• As our team and codebase grow, effectively defining and pushing new best practices, architectures, and strategies is becoming more difficult.

In order to help combat these problems, we decided to start the process of modularizing our codebase. I believe our work to solve these issues can be applied to teams and organizations of any size. I’m confident that everyone will be able to take something away from my talk, be it big or small, and apply it to their own teams to help them work more efficiently and build great apps.

• How to define code ownership to reduce side effects
• How to promote well structured APIs for all areas of our codebase
• How to reduce the effects of Swift’s compile times
• How to push large scale changes across our team and codebase

Development does not exist in a vacuum. Society is the biggest system we can impact and everything you do is a part of that system, good and bad. Ultimately we must judge the weight and value of our work based on that impact.

We should have a code of ethics in whatever we do because it allows us to measure our decisions against our values. An engineer is first and foremost a human being, but sometimes engineers ignore ethics and ship unethical features or outright products to users. With this talk I will answer some questions such as

• What’s the code of ethics of an engineer?
• Why many of the engineers that are working on products tend to not follow this code and push “unethical” code to production?
• What are some examples of unethical features pushed to production?
• What we can do as a community to persuade people to follow this code of ethics?

The talk will kick off by outlining some of the basic principles an ethical engineer should follow

1. A engineer is responsible for the work they put into the world. Engineering is a discipline of action. You are responsible for what you put into the world. It has your name on it.
2. An engineer values impact over form. Engineering does not exist in a vacuum. Society is the biggest system we can impact and everything you do is a part of that system, good and bad.
3. Accept full responsibility for their own work. If you write code that is unethical you should expect that you will have consequences for your actions.
4. Work to develop software and related documents that respect the privacy of those who will be affected by that software. As an engineer you should write software and push code to production that doesn’t violate the privacy of the user. We have a duty as people building products for people on the other end of the screen, to build a product that they can love and trust. But we can only do that if we ourselves are transparent and straightforward in the way we do so and the route we take to get there.

• How we’re in this situation where many companies push unethical features into production
• What we can do as a community to prevent that from happening

At Arc Publishing, a new venture that is a part of The Washington Post, we have begun building native mobile applications for other news publishers, like The LA Times, The Salt Lake Tribune, and The Globe and Mail, to name a few. We’re now in the process of scaling to 50 iOS apps, that have millions of users, wildly different feature sets, and that have to be kept synchronized with each other. To achieve this feat with a small team, we’ve had to template our architecture and automate our entire development and deployment process. Come learn how we built a scalable white label iOS app architecture in Swift that powers some of the App Store’s top 150 news apps.

• How to think about abstract and meta-type-heavy architecture
• How to build modular plug-and-play architecture using Swift
• How to properly perform a cost-benefit analysis when choosing open source projects for high visibility apps
• How to make optimal use of CocoaPods, BuddyBuild, Jenkins, Fastlane, and custom shell scripts to automate everything and keep all of your codebases synchronized

Ever wonder why a website is recommending that hot pink dress shirt to you? What happens when you’re browsing and tap into a product you like? It’s all part of the fine tuned machine which is data science. This talk will detail how Rue La La has used data science to drive revenue, enhance personalized shopping and provide an engaging mobile app experience. We hope that by the end of this talk all attendees will have an understanding of big data, machine learning and the impact it is having on eCommerce at large.

• Basic understanding of data science
• Why combining UX with data science is so important
• How mobile and data science are powering the future of ecommerce

Writing code is a combination of creativity and logic. Every developer wants to make sure their work is feature-perfect, bug-free, and provides a delightful experience to the end user. But how do they make sure that their code maintains the quality they consistently strive for? How can they write code that is maintainable, stable, and offers a learning opportunity to other team members? In this presentation, Jayesh Kawli will describe the process of reviewing code and how it helps to write high quality, crash-free code that is confidently written and thoroughly assessed.

When asking “When should my code go through code review?”, the answer should be “Every time you change the codebase!”. A change to even one line of code can cause catastrophic effects to app quality and customer satisfaction, which has a direct impact on company revenue. “What is the process for code review?” There are many answers to this question and we will discuss some of the more successful strategies that have been used to date.

• What is code reviewing?
• Why is it important and how should it be incorporated into the development lifecycle?
• Identification of key factors that the reviewer should look into while reviewing code
• Essential skills for better communication and sharing of ideas

Swift is in a unique position at this moment in AI technology.

First, machine learning models can run in iOS and with only a few lines of Swift Code. We will discuss 1) what machine learning is good for in local apps 2) what a machine learning model is, 3) how it gets packaged by CoreML, the new iOS format for deploying ML in your app, and 4) how to leverage it in your Swift-based apps - without needing to build a lot of specific code!

Then we will take a look into the future with Swift for Tensorflow, the brand-new technology by Google that would let us leverage our Swift knowledge to create and train new machine intelligence!

• What a machine learning model is, why it is useful and why it is not scary
• A background on how CoreML packages machine learning models for easy deployment in apps
• Methods to apply CoreML models in your apps to leverage machine learning to live analysis (like machine vision!)
• Practices for creating new CoreML models custom to your users’ situations and needs
• A hint of the future- why Swift may be central to the future of deep learning

Design patterns are reusable solutions to common development problems. They aren’t project specific, so you can use them in countless apps. But which design pattern should you use for a particular problem? How do you know if one is better suited than another? If you wrestle with these questions in your own apps, you’re in luck! This is exactly what you’ll learn in this workshop. You’ll first review a few common and niche design patterns. Specifically, you’ll go over design patterns that solve similar problems but in different ways. Along the way, you’ll learn a thing or two about design patterns, but most importantly, you’ll learn a strategy for picking one pattern over another. This will be a hands-on workshop, so make sure you bring your laptop with you!

• How design pattern use cases often overlap
• How to use class diagrams to model real-world app problems
• How to judge if a design pattern is a good fit for a problem
• How to evaluate one pattern versus another

This will be a collaborative experience - come help David pick some objects to train a CoreML model on stage! We’ll use an iPhone camera to take some photos, then we’ll use IBM Watson to train the model. After that, with (literally) one line of code, we’ll deploy the model into an iOS framework called Lumina to test the model on stage with all of the different objects!

• How to create a Core ML model with nothing but photos and text labels
• How to integrate a Core ML model into an iOS app
• How to integrate continuous learning into the above two points for an app that gets smarter as you go

SwiftSyntax is the Swift project’s library for working with Swift source code. In this workshop, you can learn how to rapidly prototype linting and formatting tools from the library’s author. No prior knowledge of SwiftSyntax is required, but a good grasp of Swift itself will be necessary. Note that SwiftSyntax is only available in developer snapshots of the Swift toolchain; please install the latest Trunk development (master) toolchain snapshot before the workshop from https://swift.org/downloads.

• The structure of SwiftSyntax and how to use it to parse and generate Swift
• How to use SyntaxVisitor to write linting/analysis tools that find real-world issues
• How to leverage SyntaxRewriter to automatically enforce code styles

A 16 year old inspired me to learn to code.

This lit the fuse that would take me on an amazing journey through challenges and victories while creating an app to help victims escape domestic violence and abuse.

This is my story.

This is the story of how someone with no coding experience got their app approved for the app store. There were challenges along the way which were far outweighed by the success, impact and achievements. Since its release, the social impact of the application has been incredible. Then a global technology giant came knocking, which brought a new life of excitement as well as being completely overwhelming. This story serves as an example of why women should be recognized as an equal and important part of the tech community.

Come meet the Oprah of technology.

Juggling is often used as a metaphor to represent the idea of dividing your attention between multiple tasks at once. But not this time! This is a talk about actual juggling, the math behind it, and the exercise of representing that math in Swift.

More speakers coming soon!

Each workshop is at least 90 minutes

No talk or workshop in this time slot.

Welcome to SwiftFest! Start the day with a few opening remarks and announcements from Giorgio Natili, SwiftFest team lead.