Why Swift is designed for safety and speed in iOS Swift - Build It to Prove It

Build: Swift Safety and Speed

This screen explains why Swift is designed to be safe and fast with simple examples.

Target UI

-----------------------------
| Swift Safety and Speed    |
|---------------------------|
| Why Swift?                |
| - Safe code               |
| - Fast performance        |
|                           |
| Example:                  |
| let x: Int = 5            |
| let y = x + 10            |
|                           |
| [Show Explanation]        |
-----------------------------

Display a title at the top

Show two bullet points explaining safety and speed

Show a simple Swift code example

Add a button labeled 'Show Explanation'

When button is tapped, show a short explanation text below the button

Starter Code

iOS Swift

import SwiftUI

struct ContentView: View {
    @State private var showExplanation = false

    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
            Text("Swift Safety and Speed")
                .font(.title)
                .bold()

            Text("Why Swift?")
                .font(.headline)

            // TODO: Add bullet points here

            // TODO: Add code example here

            Button(action: {
                showExplanation.toggle()
            }) {
                Text("Show Explanation")
            }

            // TODO: Show explanation text when button is tapped

            Spacer()
        }
        .padding()
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

Task 1

Task 2

Task 3

Solution

iOS Swift

import SwiftUI

struct ContentView: View {
    @State private var showExplanation = false

    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
            Text("Swift Safety and Speed")
                .font(.title)
                .bold()

            Text("Why Swift?")
                .font(.headline)

            VStack(alignment: .leading, spacing: 8) {
                Text("• Safe code: Swift helps avoid common errors like null pointers.")
                Text("• Fast performance: Swift is optimized to run quickly on devices.")
            }

            Text("Example:")
                .font(.headline)

            Text("let x: Int = 5\nlet y = x + 10")
                .font(.system(.body, design: .monospaced))
                .padding(8)
                .background(Color.gray.opacity(0.1))
                .cornerRadius(5)

            Button(action: {
                showExplanation.toggle()
            }) {
                Text(showExplanation ? "Hide Explanation" : "Show Explanation")
                    .foregroundColor(.blue)
            }

            if showExplanation {
                Text("Swift is designed to catch mistakes early and run your code fast, making apps safer and smoother.")
                    .font(.body)
                    .padding(.top, 8)
            }

            Spacer()
        }
        .padding()
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

This screen uses a vertical stack to organize the content clearly.

We show a title and a subtitle, then two bullet points explaining safety and speed in simple words.

The Swift code example uses a monospaced font and a light background to look like code.

The button toggles showing or hiding the explanation text below it.

This approach keeps the UI simple and friendly, helping beginners understand why Swift is safe and fast.

Final Result

Completed Screen

-----------------------------
| Swift Safety and Speed    |
|---------------------------|
| Why Swift?                |
| • Safe code: Swift helps  |
|   avoid common errors.    |
| • Fast performance: Swift |
|   runs quickly on devices.|
|                           |
| Example:                  |
| let x: Int = 5            |
| let y = x + 10            |
|                           |
| [Show Explanation]        |
|                           |
| Swift is designed to catch|
| mistakes early and run    |
| your code fast, making    |
| apps safer and smoother.  |
-----------------------------

Tapping 'Show Explanation' reveals the explanation text below the button.

Tapping 'Hide Explanation' hides the explanation text again.

Stretch Goal

Add a toggle to switch between light and dark mode for the screen.

💡 Hint

Use SwiftUI's @Environment(\.colorScheme) and a toggle button to switch modes.

Practice

1. Why does Swift use optionals in its design?

easy

A. To allow variables to store multiple types

B. To safely handle the absence of a value and avoid crashes

C. To slow down the app for better debugging

D. To make variables changeable at any time

Solution

1. Step 1: Understand what optionals represent

   Optionals allow a variable to either hold a value or no value (nil), preventing unexpected crashes.

2. Step 2: Recognize safety benefits

   By forcing you to check for nil, Swift avoids runtime errors from missing values.

3. Final Answer:

   To safely handle the absence of a value and avoid crashes -> Option B

4. Quick Check:

   Optionals = Safety from nil crashes [OK]

Hint: Optionals mean value might be missing safely [OK]

Common Mistakes:

• Thinking optionals make variables always changeable
• Believing optionals slow down the app
• Confusing optionals with multiple types

2. Which of the following is the correct way to declare a constant in Swift?

easy

A. var pi = 3.14

B. constant pi = 3.14

C. const pi = 3.14

D. let pi = 3.14

Solution

1. Step 1: Recall Swift syntax for constants

   Swift uses let to declare constants that cannot change.

2. Step 2: Identify the correct syntax

   var declares variables, const and constant are not Swift keywords.

3. Final Answer:

   let pi = 3.14 -> Option D

4. Quick Check:

   Constants use let keyword [OK]

Hint: Use let for constants, var for variables [OK]

Common Mistakes:

• Using var instead of let for constants
• Using const or constant which are not Swift keywords
• Confusing variable and constant declarations

3. What will be the output of this Swift code?

let number: Int? = nil
if let value = number {
  print("Value is \(value)")
} else {
  print("No value found")
}

medium

A. No value found

B. nil

C. Value is 0

D. Compilation error

Solution

1. Step 1: Understand optional binding

   The code uses if let to safely unwrap the optional number.

2. Step 2: Check the optional value

   Since number is nil, the else block runs printing "No value found".

3. Final Answer:

   No value found -> Option A

4. Quick Check:

   Optional nil triggers else block [OK]

Hint: if let unwraps optionals safely [OK]

Common Mistakes:

• Assuming nil prints as 0
• Expecting a runtime crash from nil
• Thinking code causes compile error

4. Identify the error in this Swift code snippet:

let name: String = nil
print(name)

medium

A. print() function is used incorrectly

B. Missing semicolon at end of line

C. Cannot assign nil to a non-optional type

D. Variable name should be var, not let

Solution

1. Step 1: Check variable type and assignment

   The variable name is declared as non-optional String but assigned nil.

2. Step 2: Understand Swift's type safety

   Non-optional types cannot hold nil; this causes a compile-time error.

3. Final Answer:

   Cannot assign nil to a non-optional type -> Cannot assign nil to a non-optional type

4. Quick Check:

   Non-optional = no nil allowed [OK]

Hint: Only optionals can hold nil [OK]

Common Mistakes:

• Thinking semicolon is required
• Believing print() usage is wrong
• Confusing let and var for nil assignment

5. How does Swift's use of constants and optionals together improve app performance and safety?

hard

A. Constants prevent unexpected changes; optionals prevent crashes from missing values

B. Constants slow down the app; optionals allow any type of value

C. Constants allow variables to change; optionals hide errors

D. Constants and optionals both make code longer and slower

Solution

1. Step 1: Understand constants' role

   Constants declared with let ensure values do not change, helping the compiler optimize speed.

2. Step 2: Understand optionals' role

   Optionals force safe handling of missing values, preventing crashes and improving reliability.

3. Step 3: Combine effects on app quality

   Together, they make apps faster by avoiding unexpected changes and safer by avoiding runtime errors.

4. Final Answer:

   Constants prevent unexpected changes; optionals prevent crashes from missing values -> Option A

5. Quick Check:

   Constants + optionals = speed + safety [OK]

Hint: Constants fix values; optionals handle missing safely [OK]

Common Mistakes:

• Thinking constants slow down the app
• Believing optionals allow any type
• Assuming optionals hide errors instead of preventing crashes