What if learning were part of your daily routine? With DailyDrip's Swift topic, you'll get the best training written by experts. Every weekday, you'll get a bite-sized piece of Swift education delivered to your inbox. This is beginning Swift 3 -- not Swift for beginners. We wont waste your time teaching you basic concepts you already know, just all the things that make Swift awesome.

Meet your expert

Ben Spratling

The day the iPhone app store opened, 3 of its apps were written by Ben, who earned his Ph.D. improving the performance of algorithms for aerospace applications. He’s contributed to lots of apps, from a handful of startups to Wolfram and DOMO. And when he’s not coding, he’s volunteering at his church.

What our customers are saying!

Daily Drip has easily been one of the most helpful resources on my journey to better understand Elixir and the Phoenix web framework.
Taylor Dolezal Software Architect
Taylor dolezal
With any language there are so many details to learn. What functions are built-in? How should I structure my code? What tools are available for improving my workflow? It’s rare to find one source that can answer so many of these questions, but DailyDrip does this and more for Elixir.
James Edward Gray II Developer
James edward gray
Daily Drip is by far the best resource for learning Elm anywhere, and among the very best online learning platforms, period.
Rex van der Spuy Author of 5 books on game development
Rex van der spuy

See what you'll get

The Swift Programming Language

Introduction to the Swift Programming Language.

Playgrounds & Built-in Types

Learn code quickly using Xcode Playgrounds without building an ent...

Details of Built-in Numeric Types

Bitwise concerns of Swift's numeric types.


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

Practice using Arrays and Dictionaries

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

Introduction to Flow Control

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

Basic Flow-Control

Change flow based on Optionals.

Whitespace & Operators

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

Functions Syntax

Argument names, labels and mutability.

Practice writing a function

An exercise exploring basic function construction.

Deeper on Control Flow and Functions

Finish off our reference on control flow.

guard, while and ??

Turning an Optional into a sure thing.

Default Argument Values

Making a single function easy & configurable.

Rounding Out Control Flow

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

Guarding Against Crashes

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

Structs: Composite Values

Getting started with composite value types.

Structs: Properties

Storing and initializing properties.

Read/Write Computed Properties

Accessing your properties in a different way.

Instance Methods & Mutability

Fine-grained control over mutability on properties & methods.

Practicing Structs

Writing multiple initializers for a struct.

Introduction to Classes

The differences between a struct and a class.

Behaviors of a Class

Inheritance, substitution, mutability & identity of reference types.

Type Checking

Checking a class's dynamic type and conditional downcasting.

Class Initializers

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

Practicing Subclassing

Creating initializers for related types.

Classes in Practice

Memory Management and Encapsulation.

Memory Management for Classes

Using Automatic Reference Counting to your advantage

Property Observers

The basis for reactibility.


How to lock down property access and overrides

Practice a Struct Owning a Class

Writing your own copy-on-write optimization.

Introduction to Enums

Representing mutually-exclusive cases.

Enum and Switch

Defining enum types, and using them in switch.

Integers as Enum RawValues

Several ways to back an enum with integers.

Associated Values

Storing different values in enum cases & writing failable initiali...

Practicing Enums

Associating custom types with enum cases.

Introduction to Closures

Functions as a type.

Writing Closures

Associating custom types with enum cases.

Lazy Stored Properties

Using a closure to initialize a property only when needed.

Good Closures

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

Practice Handling Closures

Writing a type that owns and uses a closure.

Introduction to Protocols

Swift is a protocol-oriented language

Protocol Fundamentals

Using protocols as a type.

Default Arguments

Making a function precise and easy at the same time.

Extensions & Protocols

Extending types, and simulating diamond inheritance with protocols.

Practice a Protocol Extension

Add conformance to the Equatable protocol to an enum.

Introduction to Errors

When the normal flow just won't work

Error Types & Syntax

Defining and catching errors.

Protocols and Throws

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

Convenient Throwing

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

Practice Errors

Create your own error type, throw it and catch it

Introduction to Statics

Defining methods and properties on types

Static Functions

Declaring type-members instead of instance-members.

Nested Types

Creating types within types.

Making Use of Statics

Dynamic initialization, and OptionSets.

Practicing Statics

Realistic `init` using statics.

Introduction to Generics

Preserving concrete type information

Reading & Using Generic Types

Preserving concrete type information

Working around Hashable with AnyHashable

Type erasure as a strategy.

Simple Generic Constraints & Conformances

Limiting our generic to only support specific types

Practice Generics

Writing generic type, method and closures

Introduction to Associated Types

Abstractions depending on abstractions

Declaring and Conforming to Associated Types

Abstractions depending on abstractions

No Circular Requirements

Decomposing associated types into a hierarchy.

Generics and Associated Types

Protocol associated types and generics were made for each other

Practice writing an associated type

Parallel problems ask for parallel solutions

Introduction to Foundation

Types that are fundamental to computing, but not the language

Common Foundation Types

URLs, Dates and their Components

Date Formatters

From `Date` to `String` and back again


A common type for abstracting operations on arrays of bytes

Practice Foundation

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

Introduction to the Swift Package Manager

Setup your development environment for package management

Module Layouts

Building our own modules with the Swift Package Manager.

Developing for different platforms

Platform-specific platform directives.

Package Dependencies

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

Practice Using Swift PM

Tying together our own modules, automatic dependency downloading a...

Introduction to Concurrency in Swift

The Dispatch module.

Serial and Concurrent Queues

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

When FIFO queues aren't FIFO

Avoiding synchronization errors when returning to the synchronizat...

Combining Concurrent Work

Synchronizing asynchronous work without blocking.

Practicing Concurrency

Combining multiple recipes into a realistic app

Introduction to Foundation Networking

Using a `URLSession`

Networking with URLSession

Configurations, requests, tasks, and responses.

Survey of Server Side Swift

Addressing incompletions on Linux and unsuitability of the Dispatc...

Common Network File Formats

Parsing JSON and XML files with Foundation types.

Practice Networking

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