Learning Swift

Swift is a programming language developed by Apple to allow developers to continue pushing their platforms forward. It is their attempt to make iOS and OS X app development more modern, safe, and powerful.

Developers have already begun looking for ways to push Swift to do even more than iOS and OS X app development. Some are using it to create command-line scripts to replace/supplement the existing scripting languages, such as Python and Ruby. However, Apple's priority, at least for now, is to make it the best language possible to facilitate app development.

It is important to note that learning Swift is only the first step towards developing Apple's platforms. To develop a device, you must learn the programming language and the frameworks that the device maker provides. Skill in a programming language is the foundation to get better at using frameworks, and ultimately building apps.

Developing software is like building a table. You can learn the basics of woodworking and nail a few pieces of wood together to make a functional table, but you are very limited in what you can do because you lack advanced woodworking skills. If you want to make a truly great table, first, you need to step away from the table and focus on developing your skill set. The better you are at using the tools, the more possibilities open up to you to create more advanced and high quality furniture. Similarly, with very limited knowledge of Swift, you can start to piece together a functional app from the code you find online. However, to really make something great, you have to put the time and effort into refining your language-related skill set. Every language feature or technique that you learn opens up more possibilities for your app.

That being said, most developers are driven by a passion to create things and solve problems. We learn best when we can channel our passions into truly improving ourselves and the world around us. We wouldn't want to get stuck learning the minutia of a language with no practical purpose.

The goal of this book is to develop your skills and confidence to dive passionately into creating compelling, maintainable, and elegant apps with Swift. To do this, we will introduce the syntax and features of Swift in a practical way. You will build up a rich toolset, and see it being put to real-world usage. So, without further ado, let's jump right into setting up our development environment.

In order to use Swift, you will need to have a Mac running OS X. The only piece of software you will need is called Xcode (version 6 and higher). This is the environment that Apple provides to facilitate development for its platforms. You can download Xcode for free from the Mac App Store at www.appstore.com/mac/Xcode.

Once downloaded and installed, you can open the app and it will install the rest of Apple's developer tool components. It is as simple as that! We are now ready to run our first piece of Swift code.

We will start by creating a new Swift playground. As the name suggests, a playground is a place where you can play around with code. With Xcode open, navigate to File | New | Playground from the menu bar, as shown here:

Name it MyFirstPlayground, leave the platform as iOS, and save it wherever you like.

Once created, a playground window will appear with some code already populated inside it for you:

You have already run your first Swift code! A playground in Xcode runs your code every time you make a change and shows you the code results along the right-hand side of the sidebar.

Let's break down what this code is doing. The first line is a comment that is ignored while being run. It can be really useful to add extra information about your code there inline with it. In Swift there are two types of comments: single line and multiline. Single line comments such as the one in the previous code always start with //. You can also write comments that span multiple lines by surrounding them with /* and */. For example:

/*
   This is a multi-line comment
   that takes up more than one line
   of code
*/

The second line, import UIKit, imports a framework called UIKit. UIKit is the name of Apple's framework for iOS development. For this example, we are not actually making use of the UIKit framework, so it is safe to completely remove that line of code.

Finally, on the last line, the code defines a variable called str that is being assigned to the text "Hello, playground". In the results sidebar, next to the last line, you can see that "Hello, playground" was indeed stored in the variable. As your code becomes more complex, this will become incredibly useful to help you track and watch the state of your code as it is run. Every time you make a change to the code, the results will be updated, showing you the consequences of the change.

If you are familiar with other programming languages, many of them require some sort of line terminator. In Swift, you do not need anything like that.

Another great thing about Xcode playgrounds is that they will show you errors as you type them in. Let's add a third line to the playground:

   var str = "Something Else"

On its own, this Swift code is completely valid. It stores the text "Something Else" into a new variable called str. However, when we add this to the playground, we are shown an error in the form of a red exclamation mark next to the line number. If you click on the exclamation mark, you are shown the full error:

This line is highlighted in red and we are shown the error Invalid redeclaration of 'str'. This is because you cannot declare two different variables with the exact same name. Also, notice that the results along the right-hand side turned gray instead of black. This indicates that the result being shown is not from the latest code, but from the last successful run of the code. The code cannot be successfully run to create a new result because of the error. Instead if we change the second variable to strTwo, the error goes away:

Now the results are shown in black again and we can see that they have been updated for the latest code. If you have experience with other programming environments, the reactiveness of the playground may surprise you. Let's take a peek under the hood to better understand what is happening and how Swift works.

A playground is not actually a program. While it does execute code like a program, it is not really useful outside of the development environment. Before we can understand what the playground is doing for us, we must first understand how Swift works.

Swift is a compiled language, which means that for Swift code to be run, it must first be converted into a form that the computer can actually execute. The tool that does this conversion is called a compiler. A compiler is itself a program and it is one way to define a programming language.

The Swift compiler accepts Swift code as input, and if it can properly parse and understand the code, it outputs machine code. Apple developed the Swift compiler to understand the code according to a series of rules. Those rules are what define the Swift programming language and what we are trying to learn when we say we are learning Swift.

Once the machine code is generated, Xcode can wrap up the machine code inside an app that users can run. However, we are running Swift code inside our playground, so building an app is clearly not the only way to run code.

Every time you make a change to a playground, it automatically tries to compile your code. If it is successful, instead of wrapping up the machine code in an app to be run later, it runs the code immediately and shows you the results. If you have to perform this process yourself, you would first have to consciously make the decision to build the code into an app and then run it when you want to test something. This would be a huge waste of time, especially if you write an error that you don't catch until the moment you decide to actually run it. The quicker you can see the result of a code change, the faster you will be at developing the code, and the fewer mistakes you will make.

For now, we will develop all of our code inside a playground because it is a fantastic learning environment. Playgrounds are even more powerful than what we have seen so far, and we will see this as we delve deeper into the Swift language.

We are just about ready to get to the meat of learning Swift, but first let's take a moment to ensure that you can get the most out of this book.

The learning process for this book follows very closely to the philosophy behind playgrounds. You will get the most out of this book if you play around with the code and ideas that we discuss. Instead of just passively reading through this and glancing at the code, put the code into a playground and observe how it really works. Make changes to the code, try to break it or extend it, and you will learn far more. If you have a question, try it out before looking up the answer.

At its core, programming is a creative exercise. Yes, it requires the ability to think logically through a problem, but 9 times out of 10 there is no right way, there is no correct answer. Technology is pushed by those of us who won't settle for the accepted solution, who aren't ok with following a fixed set of instructions, who want to push the boundaries. As we move forward learning Swift, make this book and Swift work for you by not taking everything at face value.

We're off to a good start. We've gone over how Swift is a language designed for app development and we already ran our first code. We learned a little bit about how a computer runs our Swift code indirectly by first compiling it into a form it understands. Most importantly, we've learned that you will learn best from this book by having a goal to work towards and by playing around with the concepts as you read along. So let's get started!