Unit 1: Getting Started|Introduction

In this lesson, you'll learn about the origin of Swift and some of its basic syntax.

What You'll Learn

Why Swift is a great language to learn
How to use Xcode playgrounds to run Swift code

Vocabulary

Related Resources

Guide

A Little History

At the Apple Worldwide Developers Conference 2014, Apple introduced Swift as a modern language for writing apps for iOS and macOS. Apple now has new platforms, including watchOS and tvOS, that also use Swift as the primary programming language.

Since the 1990s, most developers have written applications for Apple platforms in Objective-C, a language built on top of the C programming language. Objective-C is more than 30 years old, and C is more than 40 years old. Both languages have served the software developer community well. They won't be going away in the foreseeable future.

However, Objective-C can be challenging to learn. Because technology has been advancing so fast in recent years, Apple saw the opportunity to create a more modern language that was easier to learn and easier to read, write, and maintain.

As you learn Swift, you may see the influence of its C and Objective-C heritage.

A Modern Language

What's a modern language? It's one that's safe, fast, and expressive. As Apple was designing Swift, those three primary goals were at the core of every decision. As you learn programming concepts in Swift, you'll come to appreciate how each decision points to safety, speed, and clarity.

Some of the features that make Swift a modern language include:

Clean syntax, which makes code readable and easier to work with
Optionals, a new way of expressing when a value may not exist
Type inference, which speeds up development and allows the compiler to help identify common issues
Type safety, which enforces code that's less likely to crash your program
Automatic Reference Counting (ARC) for memory management, which automatically handles some of the deeper technical challenges of native programming
Tuples and multiple return values, which allow smaller units of code to do more
Generics, which help developers write code that can be used in multiple scenarios
Fast and concise iteration over collections, making Swift a fast language
Structs that support methods, extensions, and protocols, which allow Swift to optimize for memory use and speed while providing flexibility for developers
Map, filter, reduce, and other functional programming patterns, which simplify code and streamline common actions that previously required multiple lines of code
Powerful error handling, which helps the developer write fewer bugs and better handle scenarios that could cause apps to crash or perform unexpectedly

At the moment, you're probably not familiar with most of the concepts on the list. That's OK. For now, just realize that they make Swift a great language to use for building applications. As you progress through this course, you'll learn what each of these features means and how it's relevant to writing safe, fast, and expressive code.

A Safe Language

A number of features already mentioned make Swift a safe language by helping you write code that is less likely to crash your app. Computer programs are very literal, and so code written to handle one thing may not be capable of handling another. Type safety forces you to be explicit about the "type" of each object that you create, manipulate, and assign, and only lets you write code that the given object can handle. This prevents you from writing code that may crash if it is not designed to work with the "types" of objects you are referencing. Type inference similarly allows the compiler to infer the type of an object, thereby saving you time and again ensuring that the compiler can enforce proper rules regarding what operations and functions can be performed with each type. Optionals are somewhat unique to Swift, and allow you to better express when a value may not exist. This helps you ensure that your code can handle both scenarios where values exist and scenarios where they do not. Swift also provides for sophisticated error handling, which as the name implies, allows you to write code that can handle errors gracefully and simply.

Open Source

In December 2015, Apple released the Swift language and supporting resources on GitHub as an open source project. Open source can mean a lot of things. The most important point to understand is that an open source language is developed in the open, with community input and support. Everyone is welcome to contribute or simply to follow along.

Open development means that Swift is evolving and improving. Over time, syntax may change and support will be added for more platforms, including delivering more Swift technology to Linux. Now that you're learning Swift, you can be confident that your knowledge will become more and more valuable as the language continues to improve and as adoption grows across Apple platforms and beyond.

For more information about how to follow along or participate in building the Swift language, visit the project home page at Swift.org.

Hello World

When you start with a new programming language, it's a time-honored tradition to build a "Hello, world!" app, one of the simplest programs you can write in any language. All this program does is print "Hello, world!" to the screen.

Swift code is written in plain text files with a .swift file extension. Each line in the file represents a statement, and a program is made up of one or more statements. These are the instructions you wish your app to run. Generally, code is executed starting at the top of the file and works its way to the bottom of the file.

As you'll learn, you can control whether specific sections of code are executed using control flow statements (if, else), how many times they're executed using loops (for-in, while), and how to use data that can be passed to different statements.

Some programs are made up of millions of statements spread across thousands and thousands of files. The compiler makes the code executable by combining all the files into a program.

But for now, it's best to keep things simple.

In Swift, the default file is called main.swift. Any Swift code included in the main.swift file will be executed from top to bottom.

So how would you write a "Hello, world!" app in Swift?

print("Hello, world!")

As you might guess from the code above, print() is a function (a smaller unit of code that performs a specific task) that takes a bit of text, called a String, and prints it to the console.

The console is a text-entry and display tool for system administration. Decades ago, all computer interactions were through consoles, or command line interfaces. Today we have graphical user interfaces for most tasks, but developers still use the console to perform many programming or administrative tasks. In fact, almost every system you use has a console behind the scenes, which you may be able to access even when you're using the graphical interface.

Terminal

How do you access the console? macOS comes with a console app called Terminal, and Swift comes with a tool called a REPL, which stands for Read, Eval, Print Loop. The REPL allows you to enter simple commands, evaluate them, and print the result.

Use the Swift REPL in the console to write your first "Hello, world!" program.

Open the Terminal application on your Mac. You can search "Terminal" in Spotlight or find the application in the system Applications/Utilities folder.
Enter the Swift REPL by typing swift and pressing Return.
Type the command print("Hello, world!") and press Return to execute it.

Note that "Hello, world!" was printed on screen just below your print command. If you are entirely new to programming, this may be the first time you have ever provided a computer with written instructions for it to execute. Congratulations!

You can now exit the Swift REPL and Terminal by doing the following:

Type :quit and press Return to exit the Swift REPL.
Quit Terminal.

Playground

One of the most important things announced with Swift was playgrounds, a special Xcode document type that runs Swift code in a simple format with easily visible results.

Working in playgrounds is preferable to working in a REPL for many reasons. For starters, they make writing Swift code fun and simple. Using a more familiar interface, you can type in a line of code and the results appear immediately in the sidebar. If your code runs over a period of time, you can watch the progress in the timeline.

Playgrounds can also be extremely useful for Swift developers. They make it easy to manage more code in one place and to see multiple results in the results sidebar. Developers often use playgrounds for prototyping their Swift code, then move it into an Xcode project after testing.

On a technical level, a playground is a file wrapper around a main.swift file. Every time you edit the code, the playground runs the results. You can include additional files and resources, which you'll do in a future activity.

Empty Xcode playground file that shows the Source Editor and the Results panel

To view printed results from your Swift code, you can open a special debug console area right inside a playground.1

Remember, every time you edit the Swift code, the code is run from top to bottom. For every expression, results are shown on the right side.2.

Open playground debug area

To view results that are "richer" than the plain text you see in the sidebar or debug area, you can use the Quick Look tool1.

Turning on Quick Look for a specific result

To view more details inline,1 you can use the Show Results button.2

Enabling Show Results on a specific expression

Now go and build your first "Hello, world!" using an Xcode playground.

Open Xcode.
Create a new playground file by choosing File > New > Playground from the menu bar.
Choose the iOS platform and the Blank template.
Name your playground "Hello, world!" and save it to your course resources folder.

Did you notice that the default playground comes with an import statement and the variable var str = "Hello, playground"?1 Open the results sidebar (if it's not already displayed) and note that the string value is printed in the sidebar.2

The import UIKit statement allows you to use anything from the UIKit framework. This will become more important as you work through the labs in this course. You should typically leave the import statement in all of your playgrounds.
Earlier, using the Swift REPL, you wrote print("Hello, world!") to print "Hello, world!" to the console. Try that in the playground now. Start a new line and type print("Hello, world!").

You should now see "Hello, world!" in the results sidebar and in the debug console.

What's going on in this playground? The code var str = "Hello, playground" in the playground file template created a variable named str and set it equal to a string of text containing "Hello, playground." Because the str value is a String, you can pass that value to the print function just like you did with "Hello, world!"
Update your code to print the str variable instead of your "Hello, world!" text by replacing "Hello, world!" with str.

Pause for just a moment and consider why this works. The print function takes a String parameter and prints it to the console. Both of these examples work because "Hello, world!" is a String and str is a variable that holds a String.

You'll learn more about strings and variables in the next lesson.

Lab

Open and complete the exercises in Lab - Introduction.playground.