WWDC 2016

I had the opportunity to go to my 3rd WWDC (Apple’s World Wide Developers Conference). WWDC is a great place to learn about the new things Apple is introducing in upcoming versions of their products as well as to talk with Apple engineers and others who are developing for their platforms.

All of the content from the sessions delivered at WWDC is available online.

High-Level Summary

New features in iOS 10
- SiriKit
- New user notification framework with more ways to display and manage notifications
- New extension points in iMessage
- Improvements in UIKit animations and transitions
- Improvements in collection views and table views
New features in watchOS 3
- Button modified to bring up a dock of active apps. Glances removed in favor of docked view of app.
- Background app refresh
- Changes to navigation by using the digital crown to navigate between elements at the same level.
- Access to the digital crown.
Swift 3
- The API design guidelines were applied to the language and Cocoa/CocoaTouch frameworks.
Networking
- HTTP/2 Server Push is now supported
- Network statistics

Evaluation

The changes in the notification system and in watchOS can really improve the user experience for presenting notifications.

The changes to Swift continue to improve the safety provided by the language to reduce the occurrence of bugs.

Good info on improving the performance of table and collection views.

HTTP/2 Server Push can significantly improve the responsiveness of mobile apps.

Apple made some really nice changes in watchOS (notifications, background refresh, navigation) that should make the watch a lot easier to use.

Sessions

What's New in Swift

Swift API Guidelines

Using Store Kit for In-App Purchases with Swift 3

What's New in Cocoa Touch

What's New in watchOS 3

Introduction to Notifications

Advanced Notifications

Quick Interaction Techniques for watchOS

Designing Great Apple Watch Experiences

Improving Existing Apps with Modern Best Practices

Visual Debugging with Xcode

Advances in UIKit Animations and Transitions

What's New in UICollectionView in iOS 10

NSURLSession: New Features and Best Practices

Making Apps Adaptive, Part 1

Architecting for Performance on watchOS 3

A Peek at 3D Touch

Using and Extending the Xcode Source Editor

Making Apps Adaptive, Part 2

Iterative UI Design

Understanding Swift Performance

Video

Understanding the implementation to understand the performance

Dimensions of Performance

Allocated on the stack or the heap
How much reference counting
Statically or dynamically dispatched

Allocation

Stack – very fast

Decrement stack point to allocation
Increment stack pointer to deallocate

Heap

Advanced data structure
Search for unused block of memory to allocate
Reinsert block of memory to deallocate
Thread safety overhead

Structs are allocated on the stack

Class references are allocated on the stack, instances on the heap. It also allocates more memory than is needed

Changing an instance of a class will also change other instances.

Reference Counting

There’s more to reference counting than incrementing, decrementing

Indirection
Thread safety overhead

There’s no reference count overhead with a struct that has only value type members

A struct incurs reference counting overhead proportional to the number of reference type members

Foundation added UUID type in iOS 10 that’s a value type (struct)

An enum backed by a string doesn’t require heap allocation

Method Dispatch

Static

Jump directly to implementation at run time
Candidate for inlining and other optimizations

Dynamic

Look up implementation in table at run time
Then jump to implementation
Prevents inlining and other optimizations

Marking a class as final will allow the compiler to statically dispatch functions on that class

Performance Types

Polymorphism without inheritance or reference semantics
Protocol Witness Table (PWT)
Dynamic dispatch without a V-Table
The Existential Container
Boxing values of protocol types
- Inline Value Buffer – currently 3 words
Large values stored on heap
- The Value Witness Table (VWT)
- Allocation, Copy, Destruction of any Value
Reference to Value Witness Table
Reference to Protocol Witness Table

// Protocol Types
// The Existential Container in action
func drawACopy(local: Drawable) {
    local.draw()
}
let val: Drawable = Line()
drawACopy(val)
// Generated code
func drawACopy(val: ExistContDrawable) {
    var local = ExistContDrawable()
    let vwt = val.vwt
    let pwt = val.pwt
    local.type = type
    local.pwt = pwt
    vwt.allocateBufferAndCopyValue(&amp;local, val)
    pwt.draw(vwt.projectBuffer(&amp;local))
    vwt.destructAndDeallocateBuffer(temp)
}

Protocol Type Stored Properties

struct Pair {
    init(_ f: Drawable, _ s: Drawable) {
        first = f
        second = s
    }
    var first: Drawable
    var second: Drawable
}

var pair = Pair(Line(), Point())

Expensive Copies of Large Values

let aLine = Line(1.0, 1.0, 1.0, 3.0)
let pair = Pair(aLine, aLine)
let copy = pair

References Fit in the Value Buffer

Indirect Storage with Copy-on-Write

Use a reference type for storage

class LineStorage { var x1, y1, x2, y2: Double }
struct Line: Drawable {
    var storage: LineStorage
    init() { storage = LineStorage(Point(), Point()) }
    func draw() { ... }
    mutating func move() {
        if !isUniquelyReference(&storage) {
            storage = LineStorage(storage)
        }
        storage.start = ...
    }
}

Summary – Protocol Types

Dynamic polymorphism
Indirection through Witness Tables and Existential Container
Copying of large values causes heap allocation

Generic Code

protocol Drawable {
    func draw()
}
func drawACopy(local: T) {
    local.draw()
}

let line = Line()
drawACopy(line)
// ...
let point = Point()
drawACopy(point)

Generic code implements static polymorphism – one type per call context

Type substituted down the call chain

Implementation of Generic Methods

One shared implementation
Uses Protocol/Value Witness Table
One type per call context – passes tables instead of using existential container

Specialization of Generics

Static polymorphism – uses type at call-site
Creates type-specific version of method
Version per type in use
Can be more compact after optimization

When does specialization happen?

Infer type at call-site
Definition must be available

Whole Module Optimization

Increases optimization opportunity
Now enabled by default in Xcode 8

Specialized Generics – Struct Type

Performance characteristics like struct types
- No heap allocation on copying
- No reference counting
- Static method dispatch

Specialized Generics – Class Type

Performance characteristics like class types
- Heap allocation on creating instance
- Reference counting
- Dynamic method dispatch through V-Table

Unspecialized Generics – Small Value

No heap allocation – value fits in Value Buffer
No reference counting
Dynamic dispatch through Protocol Witness Table

Unspecialized Generics – Large Value

Heap allocation (use indirect storage as a workaround)
Reference counting if value contains references
Dynamic dispatch through Protocol Witness Table

Summary

Choose fitting abstraction with the least dynamic runtime type requirements
- Enables static type checking, allows compiler to ensure correctness at compile time
- struct types – value semantics
- class types – identity or OOP style polymorphism
- Generics – static polymorphism
- Protocol types – dynamic polymorphism
Use indirect storage to deal with large values