No history yet

Introduction to Swift and SwiftUI

Meet Swift

Swift is the programming language created by Apple to build apps for all of its platforms, from iPhones to Macs. It was designed to be powerful, but also safe and easy to read. Think of it as a modern tool built to solve modern problems, replacing older, more complex languages.

At its heart, Swift is straightforward. If you want to print a message to the screen, the code looks almost like plain English.

print("Hello, world!")

Let's touch on a few core building blocks. In Swift, you store information using either constants or variables. A constant, declared with let, is a value that never changes. A variable, declared with var, is a value you can change later.

// A constant for a value that won't change
let pi = 3.14159

// A variable for a score that might change
var currentScore = 0
currentScore = 10 // This is okay

Swift handles many different types of data, like text (String), whole numbers (Int), decimal numbers (Double), and true/false values (Bool). Most of the time, Swift can figure out the data type on its own, which keeps your code clean.

Like any language, Swift lets you control the flow of your program. You can make decisions with if statements and repeat actions with loops. For example, you can print a message only if a condition is true.

let isRaining = true

if isRaining {
  print("Bring an umbrella!")
}

You can also package up code into reusable blocks called functions. A function can take in some data (parameters) and can return a new value.

// This function takes a name and returns a greeting
func greet(person: String) -> String {
  let greeting = "Hello, " + person + "!"
  return greeting
}

// Call the function and print the result
print(greet(person: "Alice"))

Building Interfaces with SwiftUI

While Swift is the language, SwiftUI is the toolkit you use to build the user interface—the buttons, text, and images a person sees and interacts with. SwiftUI is what’s known as a declarative framework.

Declarative syntax means you describe what you want the UI to look like, and SwiftUI figures out how to make it happen. It’s like ordering a pizza by saying "I want a large pepperoni" instead of giving the chef step-by-step instructions on how to knead the dough and place the toppings.

In SwiftUI, every piece of your UI is a View. A piece of text is a Text view. An image is an Image view. You build complex interfaces by combining these simple views.

import SwiftUI

struct GreetingView: View {
    var body: some View {
        // A vertical stack of views
        VStack {
            Text("Hello, SwiftUI!")
            Text("Welcome to macOS development.")
        }
    }
}
Lesson image

The VStack in the example above arranges the two Text views vertically. This is view composition in action. You combine small, reusable views to create a larger, more complex screen.

Making Views Interactive

Static views are great, but apps need to respond to user input. This is where state management comes in. State is just data that can change over time, like the number for a counter or a toggle that's switched on or off.

In SwiftUI, you tell the framework to watch a piece of data for changes by marking it with @State. When that data changes, SwiftUI automatically rebuilds any part of the view that depends on it. This makes your UI stay in sync with your data automatically.

Think of @State as telling SwiftUI: "Hey, pay attention to this value. If it ever changes, redraw the screen to reflect the new value."

Here is a simple example of a button that increments a number. When you tap the button, the tapCount state changes, and the Text view updates itself to show the new number. No manual screen refreshing required.

struct CounterView: View {
    // A state variable to store the count
    @State private var tapCount = 0

    var body: some View {
        VStack {
            Text("You have tapped the button \(tapCount) times")

            Button("Tap Me") {
                // This action changes the state
                self.tapCount += 1
            }
        }
    }
}

This direct link between data and the UI is what makes SwiftUI so powerful and efficient. You define the rules, and the framework handles the rest.

Time to check what you've learned.

Quiz Questions 1/6

In Swift, which keyword is used to declare a value that cannot be changed after it's been set?

Quiz Questions 2/6

SwiftUI is described as a "declarative" framework. What does this mean in practice?

With these fundamentals of Swift and SwiftUI, you have the core knowledge needed to start building simple, interactive applications.