Discover millions of ebooks, audiobooks, and so much more with a free trial

Only $11.99/month after trial. Cancel anytime.

Mastering Swift 3
Mastering Swift 3
Mastering Swift 3
Ebook741 pages4 hours

Mastering Swift 3

Rating: 0 out of 5 stars

()

Read preview

About this ebook

This book is for developers who want to dive into the newest version of Swift.
If you are a developer that learns best by looking at, and working with code, then this book is for you. A basic understanding of Apple's tools is beneficial but not mandatory.
LanguageEnglish
Release dateOct 25, 2016
ISBN9781786468635
Mastering Swift 3

Read more from Jon Hoffman

Related to Mastering Swift 3

Related ebooks

Operating Systems For You

View More

Related articles

Reviews for Mastering Swift 3

Rating: 0 out of 5 stars
0 ratings

0 ratings0 reviews

What did you think?

Tap to rate

Review must be at least 10 words

    Book preview

    Mastering Swift 3 - Jon Hoffman

    Table of Contents

    Mastering Swift 3

    Credits

    About the Author

    About the Reviewer

    www.PacktPub.com

    Why subscribe?

    Preface

    What this book covers

    What you need for this book

    Who this book is for

    Conventions

    Reader feedback

    Customer support

    Downloading the example code

    Downloading the color images of this book

    Errata

    Piracy

    Questions

    1. Taking the First Steps with Swift

    What is Swift?

    Swift features

    Playgrounds

    Getting started with Playgrounds

    iOS and OS X Playgrounds

    Showing images in a Playground

    Creating and displaying graphs in Playgrounds

    What Playgrounds are not

    Swift language syntax

    Comments

    Semicolons

    Parentheses

    Curly brackets for control statements

    An assignment operator does not return a value

    Spaces are optional in conditional and assignment statements

    Hello World

    Summary

    2. Learning About Variables, Constants, Strings, and Operators

    Constants and variables

    Defining constants and variables

    Type safety

    Type inference

    Explicit types

    Numeric types

    Integers

    Floating-point

    The Boolean type

    The string type

    Optional variables

    Enumerations

    Operators

    The assignment operator

    Comparison operators

    Arithmetic operators

    The remainder operator

    Compound assignment operators

    The ternary conditional operator

    The logical NOT operator

    The logical AND operator

    The logical OR operator

    Summary

    3. Using Swift Collections and the Tuple Type

    Swift collection types

    Mutability

    Arrays

    Creating and initializing arrays

    Accessing the array elements

    Counting the elements of an array

    Is the array empty?

    Appending to an array

    Inserting a value into an array

    Replacing elements in an array

    Removing elements from an array

    Merging two arrays

    Reversing an array

    Retrieving a subarray from an array

    Making bulk changes to an array

    Algorithms for arrays

    Sort

    Sorted

    Filter

    Map

    forEach

    Iterating over an array

    Dictionaries

    Creating and initializing dictionaries

    Accessing dictionary values

    Counting key or values in a dictionary

    Is the dictionary empty?

    Updating the value of a key

    Adding a key-value pair

    Removing a key-value pair

    Set

    Initializing a set

    Inserting items into a set

    The number of items in a set

    Checking whether a set contains an item

    Iterating over a set

    Removing items in a set

    Set operations

    Tuples

    Summary

    4. Control Flow and Functions

    What we have learned so far

    Curly brackets

    Parentheses

    Control flow

    Conditional statements

    The if statement

    Conditional code execution with the if-else statement

    The for loop

    Using the for-in loop

    The while loop

    Using the while loop

    Using the repeat-while loop

    The switch statement

    Using case and where statements with conditional statements

    Filtering with the where statement

    Filtering with the for-case statement

    Using the if-case statement

    Control transfer statements

    The continue statement

    The break statement

    The fallthrough statement

    The guard statement

    Functions

    Using a single parameter function

    Using a multi-parameter function

    Defining a parameter's default values

    Returning multiple values from a function

    Returning optional values

    Adding external parameter names

    Using variadic parameters

    Inout parameters

    Nesting functions

    Putting it all together

    Summary

    5. Classes and Structures

    What are classes and structures?

    Similarities between classes and structures

    Differences between classes and structures

    Value versus reference types

    Creating a class or structure

    Properties

    Stored properties

    Computed properties

    Property observers

    Methods

    Custom initializers

    Internal and external parameter names

    Failable initializers

    Inheritance

    Overriding methods and properties

    Overriding methods

    Overriding properties

    Preventing overrides

    Protocols

    Protocol syntax

    Property requirements

    Method requirements

    Extensions

    Memory management

    How ARC works

    Strong reference cycles

    Summary

    6. Using Protocols and Protocol Extensions

    Protocols as types

    Polymorphism with protocols

    Type casting with protocols

    Protocol extensions

    Summary

    7. Protocol-Oriented Design

    Requirements

    Object-Oriented design

    Protocol-Oriented design

    Protocol inheritance

    Protocol composition

    Animal-protocol oriented design

    Using the where statement with protocols

    Summary

    8. Writing Safer Code with Availability and Error Handling

    Error handling prior to Swift 2.0

    Native error handling

    Representing errors

    Throwing errors

    Catching errors

    The availability attribute

    Summary

    9. Custom Subscripting

    Introducing subscripts

    Subscripts with Swift arrays

    Read and write custom subscripts

    Read-only custom subscripts

    Calculated subscripts

    Subscript values

    External names for subscripts

    Multidimensional subscripts

    When not to use a custom subscript

    Summary

    10. Using Optional Types

    Introducing optionals

    The need for optional types in Swift

    Defining an optional

    Using optionals

    Forced unwrapping of an optional

    Optional binding

    Returning optionals from functions, methods, and subscripts

    Using an optional as a parameter in a function or method

    Optional binding with the guard statement

    Optional types with tuples

    Optional chaining

    The nil coalescing operator

    Summary

    11. Working with Generics

    An introduction to generics

    Generic functions

    Generic types

    Associated types

    When not to use generics

    Summary

    12. Working with Closures

    An introduction to closures

    Simple closures

    Shorthand syntax for closures

    Using closures with Swift's array algorithms

    Standalone closures and good style guidelines

    Changing functionality

    Selecting a closure based on results

    Creating strong reference cycles with closures

    Summary

    13. Using Mix and Match

    What is mix and match?

    When to use mix and match

    Using Swift and Objective-C together in the same project

    Creating the project

    Adding Swift files to the Objective-C project

    The Objective-C bridging header file – part 1

    Adding the Objective-C file to the project

    The Messages Objective-C class

    The Objective-C Bridging Header file – part 2

    The MessageBuilder Swift class – accessing Objective-C code from Swift

    The Objective-C class - accessing Swift code from Objective-C

    Summary

    14. Concurrency and Parallelism in Swift

    Concurrency and parallelism

    Grand Central Dispatch

    Calculation type

    Creating queues

    Creating and using a concurrent queue

    Creating and using a serial queue

    async versus sync

    Executing code on the main queue function

    Using asyncAfter

    Using Operation and OperationQueue types

    Using BlockOperation

    Using the addOperation() method of the operation queue

    Subclassing the Operation class

    Summary

    15. Swift Formatting and Style Guide

    What is a programming style guide?

    Your style guide

    Do not use semicolons at the end of statements

    Do not use parentheses for conditional statements

    Naming

    Custom types

    Functions and methods

    Constants and variables

    Indenting

    Comments

    Using the self keyword

    Constants and variables

    Optional types

    Use optional binding

    Use optional chaining instead of optional binding for multiple unwrapping

    Use type inference

    Use shorthand declaration for collections

    Use switch rather than multiple if statements

    Don't leave commented-out code in your application

    Summary

    16. Swifts Core Libraries

    Apple's URL loading system

    URLSession

    URLSessionConfiguration

    URLSessionTask

    URL

    URLRequest

    HTTPURLResponse

    REST web services

    Making an HTTP GET request

    Making an HTTP POST request

    Formatter

    DateFormatter

    NumberFormatter

    FileManager

    JSONSerialization

    Parsing a JSON document

    Creating a JSON document

    Summary

    17. Adopting Design Patterns in Swift

    What are design patterns?

    Creational patterns

    The singleton design pattern

    Understanding the problem

    Understanding the solution

    Implementing the singleton pattern

    The builder design pattern

    Understanding the problem

    Understanding the solution

    Implementing the builder pattern

    Structural design patterns

    The bridge pattern

    Understanding the problem

    Understanding the solution

    Implementing the bridge pattern

    The façade pattern

    Understanding the problem

    Understanding the solution

    Implementing the façade pattern

    The proxy design pattern

    Understanding the problem

    Understanding the solution

    Implementing the proxy pattern

    Behavioral design patterns

    The command design pattern

    Understanding the problem

    Understanding the solution

    Implementing the command pattern

    The strategy pattern

    Understanding the problem

    Understanding the solution

    Implementing the strategy pattern

    Summary

    Mastering Swift 3


    Mastering Swift 3

    Copyright © 2016 Packt Publishing

    All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

    Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book.

    Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

    First published: October 2016

    Production reference: 1191016

    Published by Packt Publishing Ltd.

    Livery Place

    35 Livery Street

    Birmingham 

    B3 2PB, UK.

    ISBN 978-1-78646-612-9

    www.packtpub.com

    Credits

    About the Author

    Jon Hoffman has over 20 years of experience in the field of Information Technology. Over those 20 years, Jon has worked in the areas of system administration, network administration, network security, application development, and architecture. Currently, Jon works as a senior software engineer for Syn-Tech Systems.

    Jon has developed extensively for the iOS platform since 2008. This includes several apps that he has published in the App Store, apps that he has written for third parties, and numerous enterprise applications. What really drives Jon is the challenges the Information Technology field provides and there is nothing more exhilarating to him than overcoming a challenge.

    You can follow Jon on his two blogs: http://masteringswift.blogspot.com and http://myroboticadventure.blogspot.com.

    Some of Jon’s other interests are watching Baseball (Go Sox) and Basketball (Go Celtics). Jon also really enjoys Tae Kwon Do where he and his oldest daughter Kailey earned their black belts together early in 2014, Kim (his wife) earned her black belt in December 2014, and his youngest daughter is currently working towards her black belt.

    I would like to thank my wonderful wife Kim, without whose support, encouragement, patience, and understanding this book would have never been written. I would also like to thank my two wonderful daughters Kailey and Kara who have both been my inspiration and driving force since the days they were born.

    About the Reviewer

    Jannis Muething works as a freelance developer and designer for mobile applications. He is currently based in Dortmund, Germany and has been developing for mobile devices with a focus on iOS since 2009. Since 2014, he has been working for smartcircles mHealth AG, where he is involved in many projects. Recently he has also been doing security research focused on the protection of private data on mobile devices. Prior to mobile/iOS design and development, he worked at Materna GmbH, where he mainly did Java development. He can be found on the web at http://jannis.co and on Twitter at @j4nnis. 

    www.PacktPub.com

    For support files and downloads related to your book, please visit www.PacktPub.com.

    Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at service@packtpub.com for more details.

    At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters and receive exclusive discounts and offers on Packt books and eBooks.

    https://www.packtpub.com/mapt

    Get the most in-demand software skills with Mapt. Mapt gives you full access to all Packt books and video courses, as well as industry-leading tools to help you plan your personal development and advance your career.

    Why subscribe?

    Fully searchable across every book published by Packt

    Copy and paste, print, and bookmark content

    On demand and accessible via a web browser

    Preface

    Swift is the definitive language of Apple development today. It’s a vital part of any iOS and OS X developer’s skillset, helping them to build the most impressive and popular apps on the App Store—the sorts of app that are essential to iPhone and iPad users every day.

    What this book covers

    Chapter 1, Taking the First Steps with Swift,  shows you how to start and use Playgrounds to experiment with Swift programming. We will also cover the basic Swift language syntax and discuss proper language styles. 

    Chapter 2, Learning About Variables, Constants, Strings, and Operators, will show how to use variables and constants in Swift. We will also look at the various data types and how to use operators in Swift.

    Chapter 3, Using Swift Collections and the Tuple Type, will look at how we can use the Swift collection types to store related data. These collection types are the dictionary and array types. We will also look at how we can use the Cocoa and Foundation data types in Swift.

    Chapter 4, Control Flow and Functions, will cover control flow and functions in Swift. It is essential to understand the concepts in this chapter before going on. Every application that we write, beyond the simple Hello World applications, will rely very heavily on the control flow statements and functions.

    Chapter 5, Classes and Structures, is dedicated to Swift's classes and structures. We'll look at what makes them similar and what makes them different. We'll also look at access controls and object-oriented design. We'll close this chapter out by looking at memory management in Swift.

    Chapter 6, Using Protocols and Protocol Extensions, will cover both protocols and protocol extensions in detail since protocols are very important to the Swift language, and having a solid understanding of them will help us write flexible and reusable code.

    Chapter 7, Protocol-Oriented Design, will cover the best practices of Protocol-Oriented Design with Swift.  It will be a brief overview of what is covered in my Protocol-Oriented Programming (POP) book.

    Chapter 8, Writing Safer Code with Availability and Error Handling, will look at Swift’s error-handling features. This feature is really important for writing safe code. While we are not required to use this feature in our custom types, it does give us a uniform manner to handle and respond to the error. Apple has also started to use this error handling in their frameworks. It is recommended that we use error handling in our code.

    Chapter 9, Custom Subscripting, will discuss how we can use custom subscripts in our classes, structures, and enumerations. Subscripts in Swift can be used to access elements in a collection. We can also define custom subscripts for our classes, structures, and enumerations.

    Chapter 10, Using Optional Types, will explain what optional types really are, what the various ways to unwrap them are, and optional chaining. For a developer who is just learning Swift, optional types can be one of the most confusing items to learn.

    Chapter 11, Working with Generics, will explain how Swift implements generics. Generics allow us to write very flexible and reusable code that avoids duplication.

    Chapter 12, Working with Closures, will teach us how to define and use closures in our code. Closures in Swift are similar to blocks in Objective-C except that they have a much cleaner and easier way of using syntax. We will conclude this chapter with a section on how to avoid strong reference cycles with closures.

    Chapter 13, Using Mix and Match, will explain mix and match and demonstrate how we can include Swift code in our Objective-C projects and Objective-C code in our Swift projects. With all of the apps and frameworks written in Objective-C, it is important to allow Swift and Objective-C code to work together.

    Chapter 14, Concurrency and Parallelism in Swift, will show how to use both Grand Central Dispatch and Operation Queues to add concurrency and parallelism to our applications. Understanding and knowing how to add concurrency and parallelism to our apps can significantly enhance the user experience.

    Chapter 15, Swift Formatting and Style Guide, will define a style guide for the Swift language that can be used as a template for enterprise developers who need to create a style guide, since most enterprises have style guides for the various languages that they develop in.

    Chapter 16, Swift's Core Libraries, will be a chapter on using the Swift core libraries, including reading/writing files, network primitives, and JSON parsing.

    Chapter 17, Adopting Design Patterns in Swift, will show you how to implement some of the more common design patterns in Swift. A design pattern identifies a common software development problem and provides a strategy for dealing with it.

    What you need for this book

    To follow along with the examples in this book, you'll need an Apple computer with OS X 10.11 or higher installed. You'll also need to install Xcode version 8.0 or higher with Swift version 3 or higher.

    Who this book is for

    This book is for developers who want to dive into the newest version of Swift. If you are a developer that learns best by looking at and working with code, then this book is for you. A basic understanding of Apple's tools is beneficial but not mandatory.

    Conventions

    In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

    Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: When we attempt to change the speedOfLightKmSec constant, an error is reported.

    A block of code is set as follows:

    var x = 3.14      // Double type

    var y = Hello  // String type

    var z = true      // Boolean type

    New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this: From this menu, we will want to select the Create a new Xcode project option.

    Note

    Warnings or important notes appear in a box like this.

    Tip

    Tips and tricks appear like this.

    Reader feedback

    Feedback from our readers is always welcome. Let us know what you think about this book-what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of. To send us general feedback, simply e-mail feedback@packtpub.com, and mention the book's title in the subject of your message. If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

    Customer support

    Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

    Downloading the example code

    You can download the example code files for this book from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

    You can download the code files by following these steps:

    Log in or register to our website using your e-mail address and password.

    Hover the mouse pointer on the SUPPORT tab at the top.

    Click on Code Downloads & Errata.

    Enter the name of the book in the Search box.

    Select the book for which you're looking to download the code files.

    Choose from the drop-down menu where you purchased this book from.

    Click on Code Download.

    Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

    WinRAR / 7-Zip for Windows

    Zipeg / iZip / UnRarX for Mac

    7-Zip / PeaZip for Linux

    The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Mastering-Swift-3. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

    Downloading the color images of this book

    We also provide you with a PDF file that has color images of the screenshots/diagrams used in this book. The color images will help you better understand the changes in the output. You can download this file from https://www.packtpub.com/sites/default/files/downloads/MasteringSwift3_ColorImages.pdf.

    Errata

    Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books-maybe a mistake in the text or the code-we would be grateful if you could report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website or added to any list of existing errata under the Errata section of that title.

    To view the previously submitted errata, go to https://www.packtpub.com/books/content/support and enter the name of the book in the search field. The required information will appear under the Errata section.

    Piracy

    Piracy of copyrighted material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works in any form on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.

    Please contact us at copyright@packtpub.com with a link to the suspected pirated material.

    We appreciate your help in protecting our authors and our ability to bring you valuable content.

    Questions

    If you have a problem with any aspect of this book, you can contact us at questions@packtpub.com, and we will do our best to address the problem.

    Chapter 1. Taking the First Steps with Swift

    Ever since I was 12 years old and wrote my first program in the BASIC programming language, programming has been a passion for me. Even as programming became my career, it always remained more of a passion than a job, but over the past few years, that passion waned. I was unsure why I was losing that passion. I attempted to recapture it with some of my side projects, but nothing really brought back the excitement that I used to have. Then, something wonderful happened! Apple announced Swift. Swift is such an exciting and progressive language that it has brought a lot of that passion back and made programming fun for me again.

    In this chapter, you will learn:

    What Swift is?

    What are some of the features of Swift?

    What Playgrounds are?

    How to use Playgrounds?

    What the basic syntaxes of the Swift language are?

    What is Swift?

    Swift is Apple's new programming language, introduced at the Worldwide Developers Conference (WWDC) in 2014 alongside the integrated development environment Xcode 6 and iOS 8. Swift was arguably the most significant announcement at WWDC 2014, and very few people, including Apple insiders, were aware of the project's existence prior to it being announced.

    It was amazing, even by Apple's standards, that they were able to keep Swift a secret for as long as they did and that no one suspected they were going to announce a new development language. At WWDC 2015, Apple made another big splash when they announced Xcode 7 and Swift 2. Swift 2 was a major enhancement to the Swift language. During that conference, Chris Lattner said that a lot of the enhancements were based on the direct feedback that Apple received from the developer community.

    On December of 2015, Apple officially released Swift as an open source project, with the swift.org site dedicated to the open source Swift community. The Swift repository is located on Apple's GitHub page (http://github.com/apple). The Swift evolution repository (https://github.com/apple/swift-evolution) tracks the evolution of Swift by documenting the proposed changes for Swift. You can also find a list of which proposals were accepted and which were rejected in the evolution repository. If you are interested in understanding where Swift is heading, you should check out this repository. It is interesting to note that Swift 3 contains several enhancements that were proposed by the community.

    Swift 3 is a major enhancement to the Swift language that is NOT source compatible with previous releases of the Swift language. It contains fundamental changes to the language itself and to the Swift standard library. One of the main goals of Swift 3 is to be source compatible across all platforms, so the code that we write for the one platform will be compatible with all other platforms. This means that the code we develop for Mac OS will work on Linux, although certain frameworks, such as UIKit, may not be compatible across platforms.

    The development of Swift was started in 2010 by Chris Lattner. He implemented much of the basic language structure, with only a few people being aware of its existence. It wasn't until late 2011 that other developers began to really contribute to Swift and in July of 2013, it became a major focus of the Apple Developer Tools group.

    Chris Lattner started working at Apple in the summer of 2005. He has held several positions in the Developer Tools group and is currently the director and architect of that group. On his home page (http://www.nondot.org/sabre/), he notes that Xcode's Playgrounds (you can read more on Playgrounds a little later in this chapter) became a personal passion of his because it makes programming more interactive and approachable. We will be using Playgrounds a lot in this book as a test and experimentation platform. Starting with iOS 10, we will be able to use Swift Playgrounds on the iPad.

    Note

    To me, being able to use Swift Playgrounds on the iPad is very exciting because it will make it easier for people getting started with programming to learn the Swift language. I am really looking forward to showing my daughters how to use Playgrounds on their iPads.

    There are a lot of similarities between Swift and Objective-C. Swift adopts the readability of Objective-C's named parameters and dynamic object model. When we refer to Swift as having a dynamic object model, we are referring to the ability of types to change at runtime. This includes adding new (custom) types and changing/extending the existing types.

    While there are a lot of similarities between Swift and Objective-C, there are significant differences between them as well. Swift's syntax and formatting are a lot closer to Python than Objective-C, but Apple did keep the curly braces. I know Python people would disagree with me, and that is all right because we all have different opinions, but I like the curly braces. Swift actually makes the curly braces required for control statements, such as if and while, which eliminates bugs, such as goto fail in Apple's SSL library.

    Swift was also built to be fast. At WWDC 2014, Apple showed a number of benchmarks, which proved that Swift significantly outperformed Objective-C. Swift uses the LLVM compiler, which is included with Xcode 7 to transform Swift code into highly optimized native code that is tuned to get the most out of Apple's modern hardware.

    Swift features

    When Apple said that Swift is Objective-C without the C, they were really only telling us half of the story. Objective-C is a superset of C and provides object-oriented capabilities and a dynamic runtime to the C language. This meant that with Objective-C, Apple needed to maintain compatibility with C, which limited the enhancements it could make to the Objective-C language. As an example, Apple could not change how the switch statement functioned and still maintain the C compatibility.

    Since Swift does not need to maintain the same C compatibility as Objective-C, Apple was free to add any features/enhancements to the language. This allowed Apple to include the best features from many of today's most popular and modern languages, such as Objective-C, Python, Java, Ruby, C#, Haskell, and many others.

    The following chart shows a list of some of the most exciting enhancements that Swift includes:

    There is one feature that I did not mention in the preceding chart because it is technically not a feature of Swift; it is a feature of Xcode and the compiler. This feature is Mix and match. Mix and match allow us to create applications that contain both Objective-C and Swift files. This allows us to systematically update our current Objective-C applications with Swift classes and also use Objective-C libraries/frameworks in our Swift applications.

    Before we begin our journey into the wonderful world of Swift development, let's take a detour and visit a place that I have loved ever since I was a kid—the playground.

    Playgrounds

    When I was a kid, the best part of the school day was going to the playground. It really did not matter what we were playing; as long as we were on the playground, I knew it would be fun. When Apple introduced Playgrounds as part of Xcode 6, I was excited just by the name, but I wondered if Apple would be able to make its Playgrounds as fun as the playgrounds of my youth. While Apple's Playgrounds might not be as fun as playing kickball when I was nine years old, it definitely brings a lot of fun back to experimenting and playing with code.

    Getting started with Playgrounds

    Playgrounds are interactive work environments that let us write code and see the results immediately as changes are made to the code. This means that Playgrounds are a great way to learn and experiment with Swift.

    Playgrounds also make it incredibly easy to try out the new APIs, prototype new algorithms, and demonstrate how the code works. We will be using Playgrounds throughout this book to show how our sample code works. Therefore, before we really get into Swift development, let's spend some time learning about and getting comfortable with Playgrounds.

    Do not worry if the Swift code does not make a lot of sense right now; as we go through the book, this code will begin to make sense. We are simply trying to get a feel of Playgrounds right now.

    A Playground can have several sections, but the three that we will be using extensively in this book are as follows:

    Coding Area: This is where you enter your Swift code.

    Results Sidebar: This is where the results of your code are shown. Each time you type in a new line of code, the results are re-evaluated and the results' sidebar is updated with the new results.

    Debug Area: This area displays the output of the code, and it can be very useful for debugging.

    The following screenshot shows how the sections are arranged in a Playground:

    Let's start a new

    Enjoying the preview?
    Page 1 of 1