This course combines engaging instructor-led presentations and useful demonstrations with valuable hands-on labs and engaging group activities.

Throughout the course you'll learn how to:

• Master Swift Fundamentals: Develop a thorough understanding of Swift's syntax, semantics, data structures, and unique features, laying a strong foundation for all your future iOS and MacOS projects.
• Make Decisions in Code: Understand and apply conditionals to create more interactive and user-friendly apps.
• Loop the Loop: Learn how to work with loops for more efficient data processing and task automation.
• Handle the Unexpected: Master the use of Optionals to elegantly handle missing or uncertain data.
• Write Reusable Code: Dive into Functions and Closures to write clean, reusable, and maintainable code blocks.
• Organize Data like a Pro: Learn how to manipulate Dictionaries for quicker data retrieval and better organizational flow.
• Embrace Modern Syntax: Gain proficiency in Swift's modern and expressive syntax to write code that's both efficient and easy to read.
• Interactive User Interfaces: Learn how to connect your Swift logic to user interface elements, enabling you to create interactive and dynamic iOS applications.
• Error-Handling Smarts: Acquire techniques for robust error-handling to ensure your apps can manage unexpected situations gracefully.
• Get Hands-On with Xcode: Gain practical experience working with Apple's development tool Xcode.

If your team requires different topics, additional skills or a custom approach, our team will collaborate with you to adjust the course to focus on your specific learning objectives and goals.

To ensure a smooth learning experience and maximize the benefits of attending this course, you should have the following prerequisite skills:

• Hands-on experience with another OO programming language, such as Java, C# or C++.
• Understanding of core programming concepts such as variables, loops, and control flow is essential to grasp the fundamentals of Swift swiftly.
• Basic knowledge of data structures like arrays, sets, and dictionaries will be beneficial when learning Swift's powerful data management capabilities.
• Understanding of what functions and closures are and how they work is important, as they're integral to Swift programming.

Please note that this list of topics is based on our standard course offering, evolved from typical industry uses and trends. We'll work with you to tune this course and level of coverage to target the skills you need most. Topics, agenda and labs are subject to change, and may adjust during live delivery based on audience skill level, interests and participation.

1. Getting Started

• Getting Started with Xcode
• Playing in a Playground
• Running Your Code
• Troubleshooting Playgrounds
• Varying Variables and Printing to the Console
• Adding Comments
• You Are on Your Way!

2. Types, Constants, and Variables

• Types
• Constants vs Variables
• String Interpolation

3. Conditionals

• if/else
• Ternary Operator
• Nested ifs
• else if

4. Numbers

• Integers
• Creating Integer Instances
• Operations on Integers
• Integer division
• Operator shorthand
• Overflow operators
• Converting Between Integer Types
• Floating-Point Numbers
• Ranges of Numbers

5. Switch

• Switch Syntax
• Ranges
• Value binding
• where clauses
• Tuples and Pattern Matching
• switch vs if/else

6. Loops

• for-in Loops
• where
• while Loops
• repeat-while Loops
• Control Transfer Statements in Loops

7. Strings

• Working with Strings
• Characters
• Unicode
• Unicode scalars
• Canonical equivalence

8. Arrays

• Creating an Array
• Accessing and Modifying Arrays
• Combining Arrays
• Array Equality
• Immutable Arrays
• Documentation

9. Optionals

• Optional Types
• Optional Binding
• Implicitly Unwrapped Optionals
• Optional Chaining
• Modifying an Optional in Place
• The Nil Coalescing Operator

10. Dictionaries

• Creating a Dictionary
• Accessing and Modifying Values
• Adding and Removing Values
• Looping over a Dictionary
• Immutable Dictionaries
• Translating a Dictionary to an Array

11. Sets

• What Is a Set?
• Getting a Set
• Working with Sets
• Unions
• Intersections
• Disjoint
• Moving Between Types

12. Functions

• A Basic Function
• Function Parameters
• Parameter names
• Default parameter values
• In-out parameters
• Returning from a Function
• Nested Function Definitions and Scope
• Multiple Returns
• Optional Return Types
• Exiting Early from a Function
• Function Types

13. Closures

• Closure Syntax
• Closure Expression Syntax
• Functions as Arguments
• Closures Capture Their Enclosing Scope
• Functional Programming
• Higher-Order Functions
• map(_:)
• filter(_:)
• reduce(_:_:)

14. Enumerations

• Basic Enumerations
• Enumerations with Raw Values
• Methods
• Associated Values

15. Structs and Classes

• A New Project
• Structures
• Instance Methods
• Mutating methods
• Classes
• A Monster class
• Inheritance
• Looking Ahead: What Is the Real Difference?

16. Properties

• Basic Stored Properties
• Nested Types
• Lazy Stored Properties
• Computed Properties
• A getter and a setter
• Property Observers
• Type Properties
• Access Control
• Controlling getter and setter visibility

17. Initialization

• Initializer Syntax
• Struct Initialization
• Default initializers for structs
• Custom initializers for structs
• Class Initialization
• Default initializers for classes
• Initialization and class inheritance
• Required initializers for classes
• Deinitialization
• Failable Initializers
• A failable Town initializer
• Initialization Going Forward

18. Value vs Reference Types

• Value Semantics
• Reference Semantics
• Constant Value and Reference Types
• Using Value and Reference Types Together
• Copying
• Equality vs Identity
• What Should I Use?

19. Protocols

• Formatting a Table of Data
• Protocols
• Protocol Conformance
• Protocol Inheritance
• Protocols as Types
• Protocol Composition
• Mutating Methods

20. Extensions

• Extending an Existing Type
• Extending Your Own Type
• Using extensions to add protocol conformance
• Adding an initializer with an extension
• Nested types and extensions
• Extensions with methods

21. Generics

• Generic Data Structures
• Generic Functions and Methods
• Type Constraints
• Associated Types
• Type Constraints in where Clauses
• Generic Composition and Opaque Type

22. Protocol Extensions

• Modeling Exercise
• Extending Exercise
• Self Types and Type Values
• Protocol Extension where Clauses
• Default Implementations with Protocol Extensions
• Implementation Conflicts

23. Error Handling

• Classes of Errors
• Lexing an Input String
• Catching Errors
• Parsing the Token Array
• Handling Errors by Sticking Your Head in the Sand
• Swift Error-Handling Philosophy

24. Memory Management and ARC

• Memory Allocation
• Strong Reference Cycles
• Breaking Strong Reference Cycles with weak
• Reference Cycles with Closures
• Escaping and Non-Escaping Closures
• Tin Challenge

25. Equatable, Comparable, and Hashable

• Equatable
• Infix operators
• Buy one method, get another free!
• Comparable
• Protocol inheritance
• Hashable
• Custom hashing

26. Property Wrappers

• Defining a Property Wrapper
• Additional configuration
• Accessing the Wrapper Itself
• Projecting Related Values

27. Command-Line Utilities

• Introduction to the Command Line
• Building the Word Finder
• Loading the words from disk
• Retrieving Command-Line Arguments
• Receiving Input Interactively
• Running Your App from the Command Line
• Parsing Command-Line Arguments with ArgumentParser
• Adding ArgumentParser to your project
• Declaring arguments for ArgumentParser to parse

28. iOS and macOS Apps

• Getting Started with TahDoodle
• That is some View
• Displaying Dynamic Data
• Accepting User Input
• Sharing references to value-type data
• Interlude: Troubleshooting with property observers
• Observing Changes to the Store
• Saving and Loading User Data
• Supporting macO