Head First Swift A Learner's Guide to Programming with Swift A Brain-Friendly Guide Series

Swift is a programming language you can rely on. A language you can present to the family. Safe, reliable, speedy, friendly, easy to talk to, it’s the language of choice for Apple’s platforms—iOS, macOS, watchOS, and tvOS. But open source Swift also runs on Linux as well as the server, and it's gaining ground in scientific computing and web apps. Swift for Windows is even in the works. You can build everything from mobile apps to games, web apps, frameworks, and beyond. So jump in and get started!

What's so special about this book?

1. Introducing Swift: Apps, Systems, and Beyond!
   1. Swift is a language for everything
      1. Swift has evolved fast.
   2. The swift evolution of Swift
   3. Swift into the future
   4. How you’re going to write Swift
   5. The path you’ll be taking
   6. Getting Playgrounds
      1. Downloading and installing Playgrounds on macOS
   7. Creating a Playground
   8. Using a Playground to code Swift
   9. Basic building blocks
   10. A Swift Example
   11. Here’s what you need to build
   12. The print function
   13. Building a list of ingredients
   14. Picking four random ingredients
   15. Displaying our random pizza
   16. Congrats on your first steps with Swift!
   17. Swiftcross
   18. Swiftcross Solution
2. Swift By Name: Swift by Nature
   1. Building from the blocks
   2. Basic Operators
   3. Operating swiftly with mathematics
      1. Express yourself
   4. Expressing yourself
   5. Names and types. Peas in a pod.
   6. Swift Safety
   7. Stringing things along with Types
      1. Who am I?
   8. String interpolation
   9. Swiftcross
   10. Swiftcross Solution
3. Collecting and Controling: Going loopy for Data
   1. Sorting pizzas
      1. Swift has a range of special types that can store collections of things. Unsurprisingly, these are called collection types.
   2. Swift Collection Types
   3. Collecting values in an array
   4. How big is that array, exactly? Is it empty?
   5. Collecting values in a set
   6. Collecting values in a dictionary
   7. Tuples
   8. Everyone needs a good alias
   9. Control flow statements
   10. If statements
   11. Switch statements
   12. Building a Switch statement
       1. Start with the switch keyword
   13. Range operators
   14. More complex switch statements
   15. Getting repeatative with loops
   16. Building a For Loop
   17. Building a while loop
   18. Building a repeat-while loop
   19. Solving the pizza sorting problem
   20. Phew, that’s a lot of Swift!
   21. Swift Code Magnets
   22. Pool Puzzle
   23. BE the Swift Compiler
   24. Swiftcross
   25. Swift Code Magnets Solution
   26. Pool Puzzle Solution
   27. BE the Swift Compiler Solution
   28. Swiftcross Solution
4. Functions and Enums: Re-using code on Demand
   1. Functions in Swift let you reuse code.
      1. What can functions do?
   2. Built-in functions
   3. Magnetic Thoughts
   4. What can we learn from built-in functions?
   5. Improving the situation with a function
   6. Writing the body of the function
   7. Using functions
   8. Functions deal in values
   9. Many happy returns (from your functions)
      1. But Swift is meant to make things simple...
   10. A variable number of parameters
       1. Fireside Chats
   11. What can you pass to a function?
   12. Every function has a type
       1. Behind the Scenes
   13. Function types as parameter types
   14. Multiple return types
       1. Fireside Chats
   15. Functions don’t have to stand alone
       1. Nested functions
       2. Anatomy of an Enum
       3. Defining a enum
       4. Associated values and enums
       5. An iterable enum
       6. Initialising from raw value
       7. Adding cases to an enum
       8. Implicitly assigned raw values
       9. Raw values
   16. Switching with enums
       1. Behind the Scenes
   17. Anatomy of a Function
       1. A function with a variable number of parameters and multiple return types
       2. Functioncross
       3. Functioncross Solution
5. Closures: Fancy, Flexible Functions
   1. Meet the humble closure
   2. Closures are better with parameters
   3. Boiling it all down to something useful
      1. The Problem
      2. The Solution
   4. Reducing with closures
      1. Behind the Scenes
   5. What came first, the function or the closure?
   6. Escaping closures the contrived example
   7. Autoclosures provide flexibility
      1. The Situation
      2. The Problem
      3. The Solution
   8. Shorthand argument names
      1. Closurecross
   9. BE the Swift Compiler
      1. Closurecross Solution
6. Structures, Properties, and Methods: Custom types and Beyond
   1. Let’s make a pizza, in all its glory...
      1. A Pizza Struct
      2. Under the hood...
   2. The initialiser behaves just like a function
   3. Access Control and Structs
   4. Functions inside structures Methods
   5. Changing properties using methods
   6. Computed properties
      1. Creating a property observer
   7. Magnetic Thoughts
   8. Getters and Setters for Computed Properties
   9. Implementing a setter
   10. The case for lazy properties
   11. Using lazy properties
   12. Structcross
   13. Structcross Solution
7. Classes, Actors, and Inheritance: Inheritance is always a Thing
   1. A struct by any other name (that name: a class)
   2. Inheritance and Classes
   3. Replacing Overriding Methods
      1. Here’s our Plant class:
      2. Here’s our Succulent child class, overriding a method of the parent:
      3. Under the hood...
   4. Final classes
   5. Automatic Reference Counting
   6. Mutability
   7. Fireside Chats
   8. BE the Swift Compiler
   9. Pool Puzzle
   10. Swiftcross
   11. Pool Puzzle Solution
   12. BE the Swift Compiler Solution
   13. Swiftcross Solution
8. Protocols and Extensions: A Swift lesson in Protocol
   1. THE ROBOT FACTORY
      1. The problem:
      2. A Solution:
      3. Figure out all the possible robot features
      4. Make protocols for each feature
      5. Make the robot types
   2. Protocol Inheritance
   3. Mutating Method
   4. Protocol Types and Collections
   5. Computed Properties in Extensions
      1. Declare an Extension
      2. Use functionality from our Extension
   6. Useful Extensions andYou
      1. Adding an Initialiser (with an Extension)
   7. Extending a Protocol
   8. Useful Protocols and You
   9. Conforming to Swift’s Protocols
      1. Sequences
      2. Conforming to Sequence and IteratorProtocol:
      3. Using your new sequence:
      4. Equatable
      5. The problem:
      6. Conforming to Equatable:
      7. Implementing ==
   10. Swift Code Magnets
   11. Protocolcross
   12. BE the Swift Compiler
   13. Protocolcross Solution
   14. BE the Swift Compiler Solution