The Building Blocks of SwiftUI

Josh Garnham

Ever wondered how the closures of SwiftUI's View, VStack, List and so on come together to build an actual interface? Well this is the session for you, we'll explore function builders, the magic that exists behind each of those types, and see how we can use them not just within SwiftUI but for our own gains too — did someone say easy to build NSAttributedStrings?

Let’s analyze Swift struct

Ellie Shin

Most of the standard library types are written in struct and Apple recommends using it over class for performance reasons. But what’s the downside? One of them is a binary size impact. This talk will go over the analysis of Swift struct. It will go into details of its behavior and how the struct size can have a limiting impact on some of the compiler optimizations and the reasons why. It will also cover when to choose struct vs class when writing your own code.

The system of type inference

omochimetaru

I've been interested in the mechanism of type inference since I started using Swift. When Swift2 came out, I studied Hindley-Milner (HM) type inference and implemented it myself. However, with HM-type inference, the advanced inference of Swift could not be realized, and I was worried about how to extend it to realize a language like Swift. Over the past year, I have been reading the inside of the compiler a little bit and giving a talk on type inference through participation in the Swift compiler workshop. Based on this experience, in this talk, I will explain the overall flow of type inference in Swift and the contents of inference processing. Through my talk, I'm hoping the beginners will be a good starting point for getting started with type inference and hope that the Swift community will have more developers who understand type inference.

Let’s make a Collection

Curtis Colly

The collections that come with Swift are usually good enough for your needs. Most of your types will be stored in arrays and dictionaries. You might even use sets and tuples. I'm sure you can make create your own type but there will come a day where you would like to make your own collection. When that day comes, you’ll be glad that you listened to this talk. Come with me. We are going to make our own collection from scratch. We’ll talk about the requirements our newly created collection must meet and the promises it makes in order to conform. While doing that we will reinforce our understanding of protocols and use the methods it rewards us for our conformance.

Sign in With Apple Challenges

Anat Gilboa

Sign in with Apple hit us with full force with unknown timelines, missing documentation, and a whole slew of User Profile merging woes that left team to their own implementation and UX questions. This talk will cover some of those conversations we had and decisions we made along the way to implement this feature.

What is Modelessness?

Manabu Ueno

From my 20 years of experience as a design consulting, I believe "modelessness" is the most fundamental principle of user interface design. Understanding the concept of modeless user interface helps you develop truly usable and empowering apps. There is no silver bullet in design methods, except this simple approach - getting your app modeless. In my perspective, 90 percent of business apps have serious usability problems because they are composed of functional modes. You can dramatically improve or innovate them by getting rid of modes. In this presentation, I will talk about the philosophy and technique of modeless design that turns your product much more meaningful.

Deep dive into "Optimizing and Diagnostic" by Swift Compiler

freddi(Yuki Aki)

Through my talk, you can understand deeply about “Optimizing and Diagnostic” of Swift Compiler phase which is a very interesting phase in compiler. We learned many compiler knowledge in past try! Swift. For example, we learned how to read Swift Intermediate Language（SIL）and how our code is treated by Swift Compiler in Tokyo 2018(https://www.youtube.com/watch?v=sT0SNp-Tw-8). Is it okay to only know how to read SIL? No, we can also understand “Optimizing and Diagnostic” phase in Swift Compiler. And, we can learn following things through learning “Optimizing and Diagnosing” How compiler grantees the safety of our Swift Program How optimizer would destroy our Program. This would occur when we set an optimize option on the release build. I will talk about Easy “Optimizing and Diagnostic” tutorial through my talk. You can learn how SIL is optimized by Swift compiler which from our swift code, and “Diagnostic” phase which we are touching unconsciously many times. I’ll show you the demonstration with compiler to make your understanding very deep. Of course, I’ll show you easy tutorial of SIL and overview of Swift Compiler, so don’t be afraid to listen my talk!

Continuous visual regression testing

Ryo Aoyama

The larger the development scale, the more time-lapsed regression will be, but it will be costly to maintain this with QA / QC. In order to solve this problem, like the Storybook in web application development, while generating and distributing the catalog application of the component, not only asserting with the difference of UI with Snapshot test, but also the change that the implementer did not intend has occurred by visual regression tests that enable visualization from CI.

Introduction to Machine Learning with TensorFlow and Swift

Khanh LeViet

Learn the ‘new’ paradigm of machine learning, and how models are an alternative implementation for some logic scenarios, as opposed to writing if/then rules and other code. This session will guide you through understanding many of the new concepts in machine learning that you might not be familiar with including neurons, training loops, optimizers, and loss functions. You will learn how to train a machine learning model with TensorFlow, convert it to TensorFlow Lite and deploy to your iOS application, all without leaving the comfort zone of Swift.

Augmented Reality in Real Estate

Roxana Jula

Embrace the future and use augmented reality to bring a new way to interact with real estate. In this session we will have a look at how you can make a useful app powered by AR. People occlusion, AR coaching UI, AR Quicklook with USDZ files and many more will be covered.

Interview with Confidence

Alex Karp

Interviews are stressful. The questions are tricky. You don’t immediately know the answers, so you nervously rush to figure something (…anything) out. It’s almost like the interviewer is rooting for you to fail… or are they? Come find out how to walk into your next interview full of confidence!

Build Swift Web Playground for Fun and Profit

Katsumi Kishikawa

Playground is one of the most useful tools for understanding programming languages. Swift provides a very easy-to-use Playground so we can easily try out the Swift code and see the results. Looking at other programming languages, modern languages have some kind of Playground mechanics. In addition, there are many languages where the Web Playground is provided. Unfortunately, the official Swift Web Playground is not yet available, but you can create your own Web-powered Playground using Swift and Web technology!

As Cute as a Button

Janina Kutyn

Buttons, buttons, buttons! Buttons are the key component of any iOS app. Let’s talk about different ways we can make buttons in our apps look cool, stand out, and engage our users. From images, to shapes, to animations, let’s make those buttons pop!

How We Fail

Soroush Khanlou

What causes our code and processes to fail? Complex systems fail in complex ways, and Soroush Khanlou will discuss some examples of catastrophic failures, what caused them, and how we can hope to avoid them in the future.

Xcode Project Generation

Yonas Kolb

Motivations, challenges, and learnings from building and using XcodeGen

Effective UIKit-based app development with Xcode Preview

Kentaro Matsumae

Much of the time in iOS app development is spent implementing views. The display contents and layout of the view change dynamically depending on the state of the application. Therefore, while developing a view, it is necessary to frequently launch iOS Simualtor and actually operate the app to check whether the displayed content is as expected. In addition, when displaying on a small screen terminal, when dark mode is enabled, or when enlarging characters with Dynamic Type, it is troublesome to check whether the layout is collapsed. It is very difficult because every time you change something, you need to start iOS Simulator and check the operation. Xcode Preview introduced in Xcode11 solves this problem. It is a function to preview the display result of the view in various situations on the editor. If you change the View implementation, it will be reflected in the preview immediately, so you do not need to launch the iOS simulator many times to confirm. And while Xcode Preview has the impression that it supports development using SwiftUI, it can actually be used for application development based on conventional UIKit! You can start using Xcode Preview today as a tool to streamline your existing app development. No more waiting for SwiftUI to spread. In this talk, I will show you how to introduce Xcode Preview to existing UIKit-based app development and how to use it with demos.

Property Wrappers or How Swift decided to become Java 🙃

Vincent Pradeilles

Swift 5.1 brought a new construct to the language: Property Wrappers. SwiftUI, for instance, relies heavily on it to provide its system of data-binding through annotations like @State, @EnvironmentObjects, etc. Unlike other language improvements, Codable for instance, Apple hasn’t restricted the use of this new feature to its own frameworks: any codebase is free to leverage it to implement custom property attributes that will suit its own specific needs. While this is a great opportunity to factorise common behaviours throughout a project, one can still wonder: won’t it hurt code readability and predictability on the long run? Keeping code short is good, but if it’s achieved through a collection of arcane annotations, it might end up defying the original intent. In this talk, I want to introduce what Property Wrappers are, give some example of how they can be leveraged, and try to provide some guidelines on when we they should or shouldn’t be use.

Practical Dependency Injection with Legacy Codebase

Suyeol Jeon

We already know what Dependency Injection is. But we don't do it. Because we are living in the real world with tons of legacy code. This talk introduces a practical way to do Dependency Injection in iOS projects.

The multiple faces of an unidirectional data flow

Fabio

At WWDC '19 Apple released Swift UI: a new UI framework to easily build user interfaces for all Apple platforms. Besides its powerful Swift API and internals, this framework adopted innovative and well known programming paradigms designed by the industry and the open source community to create captive, efficient and scalable UI. We will dive into some of these paradigms, ethos of Swift UI and most of the major UI frameworks to understand the mindset of their APIs, analyzing the tradeoffs and challenges to consider during development and finally build the skills to drive an educated decision of what fits best for the scale and priorities of your products.

Pattern Matching Superpowers

Olivier Halligon

Most of us use pattern matching every day when writing Swift: we all know `switch` and `if let` for example. But did you know that pattern matching can be way more powerful than this and that you can extend them for your own benefit? Embark in a deep dive into Swift pattern matching syntax to discover how far it can go and how powerful they can get, and learn how to create your own custom matching logic to give your `switch` and other pattern matching expressions some more superpowers.

Ultrasonic communication: Bus Ticketing Use-Case

Soaurabh Kakkar

We all exchange data over the internet, but what if we have unreliable internet connectivity? Ultrasonic communication can exchange data reliably via inaudible sound waves. It’s practically hardware-agnostic and requires nothing more than a microphone and speaker. Let’s discuss the concept, implementation, practical use cases and our journey to solve bus-ticketing via sound.

Break Up and Bounce Back: On Working Well While Distributed

Alaina Kafkes

Though it can be advantageous for small startups to retain a separate iOS engineering team, growth forces even the most tight-knit of iOS teams to disperse. This can often isolate iOS engineers, leaving them all alone in their efforts to maintain the integrity of the iOS codebase on a multi-platform product team. In this talk, I’ll share how my iOS engineering teammates and I navigated the transition from working together on one team to spearheading shared infrastructural projects and communicating effectively across multiple teams.

Getting Started with Combine

Shai Mishal

In the last WWDC, Apple has finally released it's very own framework for declarative processing of values over time, making the skill of Reactive Programming a must for your toolset. But what does it actually mean, and why is it at all helpful for you as a developer? What are the tools and constructs Apple provide for us as developers? In this talk you'll learn: * What _is_ Reactive Programming? * How Combine differs from other Reactive Declarative frameworks * Basic building blocks: Publisher, Subscriber, Subscription, Subjects and more * The anatomy and lifecycle of a Combine event * Combine vocabulary: Operators - the 'words' that make up your Combine chain * Combine & Foundation: Apple-provided APIs to ease your day-to-day development with Combine and existing Swift APIs * Combine's role in SwiftUI * What is Backpressure? * And much more ...

A/Bout Testing: The Learnings, The Pitfalls and why it matters

Carola Nitz

A/B Testing has become a staple in our industry to validate assumptions. In fact each one of us has unknowingly conducted an A/B Testing when we rolled out a new version and compared metrics from our old App with our newly released version. This talk is going over different ways to conduct A/B tests, what to consider and how to read results and avoiding certain pitfalls.

The Science of Learning

Frank Courville

Have you ever watched a WWDC talk, and only a few days later, not remember what it was about? Why does this happen? In this talk, we'll look at how adult humans learn new things, and how to apply this to the workplace. We'll survey the different techniques we have at our disposal to transmit new information within teams and how they stack up to each other.

Making own movie player in iOS

Tomoya Hirano (noppe)

In iOS, we can play movie easily by using AVFoundation. In this workshop, you will understand how AVFoundation plays videos together and show you how to develop your own video player.

Things to prepare:
Laptop with Xcode 11, iPhone, Lightning cable

Getting Started with iOS Accessibility

Frank Courville

Have you ever wanted to make your app more accessible, but didn't know where to start? In this workshop, we'll learn about the different accessibility features of iOS, the tools we have at our disposal, and the API we can use to make sure everyone can use your app. You'll quickly realize that with only a little effort, you'll be able to create a great accessibility experience in your app.

Things to prepare:
Laptops with the latest Xcode

Leveraging KeyPaths to their full potential

Vincent Pradeilles

KeyPaths yield a tremendous potential when it comes to creating short and readable custom syntaxes.
In this workshop I want to introduce you some ways you can use KeyPaths on your projects, to perform tasks like data-manipulation, data binding or even unit tests.

Things to prepare:
Having the latest stable release of Xcode installed

Type Inference Implementation Workshop

omochimetaru & Iceman & kateinoigakukun

When learning an algorithm, it is best to actually write the code. In this workshop, we will implement a simple Swift type inference unit to better understand type inference. Since prepared fill-in-the-blank code is modified so that it passes through the test case, it can be completed in a short time. The code is written in Swift of course, which you are all familiar with and, to some extent, corresponds to the code of the real Swift compiler, so it will be a good starting point for contributing to the compiler for you.

Things to prepare:
- Laptops with the latest stable Xcode
- Please listen The system of type inference session in the conference.

Migrating to XcodeGen

Yonas Kolb

Learn how to migrate your Xcode project to an XcodeGen spec, and remove it from git! You'll learn how to get started, as well as some advanced tips and configuration options.

Things to prepare:
Bring a work or personal project you want to migrate

Open Source Swift Workshop

Yusuke Kita & Sho Ikeda & giginet

In this workshop we will look at the Swift compilation process and what those parts are, learn a bit about LLVM, how to find a bug to work on using bugs.swift.org and then making a build with our changes and running tests.A merged pull request is not the goal of this workshop, but after attending this workshop you should have enough knowledge to get started and know where to look to learn more.If you are proficient in C++ or even have some experience with LLVM, then you can start working with the Swift compiler right away. If you do not have former C++ knowledge fear not, the Swift standard library or SwiftSyntax are written mostly in Swift and the python / swift hybrid '.gyb' files.

Things to prepare:
- Laptops with the latest stable Xcode
- Building the Swift compiler is preferred. Instruction will be provided beforehand.

Make your own Home app-compatible Homekit accessories!

Sam Akada

In this workshop, you will learn how to make HomeKit accessories without being a hardware designer. Use the iPhone or iPad home app to create a simple input / output HomeKit accessory that controls accessory devices. Let's increase your own HomeKit accessories!

Things to prepare:
- Mac with Xcode11 installed
- iPhone or iPad

Declarative UI with Firestore and SwiftUI

Morgan Chen

Explore building a declarative UI with Cloud Firestore and Swift. This workshop will focus on strategies for separating effectful Firestore code from a stateless UI and managing complexity when propagating changes from Firestore to the UI layer.

Things to prepare:
standard iOS toolchain, so Xcode 11 or higher, CocoaPods 1.8.0 or higher

Peer Labs

You!

Peer Labs is your chance to get hands on with things you learned from try! Swift presentations, discuss any issues with the speakers, connect with your peers, work on open source projects, organize impromptu learning sessions and more! Peer labs do not have a strict structure, and are open-ended instead. It is what you and your peers make of it! We will ask everyone to introduce themselves in the beginning, and then it is up to you to ask questions and work together with others on projects that interest you.