Introduction to the Swift Programming Language.

Learn code quickly using Xcode Playgrounds without building an entire app.

Bitwise concerns of Swift's numeric types.

We're going through built-in types in Swift.

Put `Any`thing in an array, and key by types other than `String`s.

Swifter `if`, `while` and `for`.

Change flow based on Optionals.

How to let Swift know whether your operator is prefix, postfix or infix.

Argument names, labels and mutability.

An exercise exploring basic function construction.

Finish off our reference on control flow.

Turning an Optional into a sure thing.

Making a single function easy & configurable.

Ranges, For-in, & tuples for multiple return.

Using `guard`, and an Optional tuple to avoid crashing

Getting started with composite value types.

Storing and initializing properties.

Accessing your properties in a different way.

Fine-grained control over mutability on properties & methods.

Writing multiple initializers for a struct.

The differences between a struct and a class.

Inheritance, substitution, mutability & identity of reference types.

Checking a class's dynamic type and conditional downcasting.

Swift enforces Obj-C's convention of a "designated initializer"

Creating initializers for related types.

Memory Management and Encapsulation.

Using Automatic Reference Counting to your advantage

The basis for reactibility.

How to lock down property access and overrides

Writing your own copy-on-write optimization.

Representing mutually-exclusive cases.

Defining enum types, and using them in switch.

Several ways to back an enum with integers.

Storing different values in enum cases & writing failable initializers.

Associating custom types with enum cases.

Functions as a type.

Associating custom types with enum cases.

Using a closure to initialize a property only when needed.

Avoiding retain cycles in @ecaping closures and writing small, clean closures.

Writing a type that owns and uses a closure.

Swift is a protocol-oriented language

Using protocols as a type.

Making a function precise and easy at the same time.

Extending types, and simulating diamond inheritance with protocols.

Add conformance to the Equatable protocol to an enum.

When the normal flow just won't work

Defining and catching errors.

How to conform to protocols with `func`s that throw or not.

Other keywords that work well with `throws` for clean control flow.

Create your own error type, throw it and catch it

Defining methods and properties on types

Declaring type-members instead of instance-members.

Creating types within types.

Dynamic initialization, and OptionSets.

Realistic `init` using statics.

Preserving concrete type information

Preserving concrete type information

Type erasure as a strategy.

Limiting our generic to only support specific types

Writing generic type, method and closures

Abstractions depending on abstractions

Abstractions depending on abstractions

Decomposing associated types into a hierarchy.

Protocol associated types and generics were made for each other

Parallel problems ask for parallel solutions

Types that are fundamental to computing, but not the language

URLs, Dates and their Components

From `Date` to `String` and back again

A common type for abstracting operations on arrays of bytes

End-to-end `Data` and `Date`s

Setup your development environment for package management

Building our own modules with the Swift Package Manager.

Platform-specific platform directives.

What makes the Swift Package Manager a "package manager.”

Tying together our own modules, automatic dependency downloading and command line apps.

The Dispatch module.

Accessing a model with concurrent-read / serial-write.

Avoiding synchronization errors when returning to the synchronization queue.

Synchronizing asynchronous work without blocking.

Combining multiple recipes into a realistic app

Using a `URLSession`

Configurations, requests, tasks, and responses.

Addressing incompletions on Linux and unsuitability of the Dispatch and Foundation architectures for servers.

Parsing JSON and XML files with Foundation types.

Round tripping JSON from Swift objects to Data to a server and back.

A brief introduction covering the major features of Xcode 9

Learn how the Source Editor works in Xcode 9

Exploring the Project Editor inside of Xcode 9

Learn how to run Xcode 9s debugger, test systems, and manage automatic tabs

Using the Git SCM navigator inside of Xcode 9