Why iOS Development? Swift, SwiftUI & the Apple Ecosystem

iOS Development Fundamentals

Chapter 1 · Why iOS Development? Swift, SwiftUI & the Apple Ecosystem

"iOS development" today really means three things working together: Swift, the language; SwiftUI, the framework used to actually build what's on screen; and Xcode, the IDE that ties both together and talks to Apple's real build and submission pipeline. This chapter introduces all three, and closes with a real, complete first app.

Three Names, One Toolchain

Swift

Apple's real general-purpose programming language, introduced at WWDC 2014. The current stable release, as of this writing, is Swift 6.3.3.

SwiftUI

Apple's real declarative UI framework, introduced at WWDC 2019 (Xcode 11) — you describe what the interface should look like, not the step-by-step instructions for building it.

Xcode

Apple's real, free IDE. The current version, Xcode 26 (September 2025), added AI-assisted code completion and chat tooling directly into the editor.

A Real Requirement

Xcode only runs on macOS — there's no real Windows or Linux version. Building for Apple platforms genuinely requires a Mac at some point in the workflow, even if most of this course's own reading can be followed on any machine.

One Codebase, Several Real Platforms

Swift and SwiftUI aren't iOS-specific — the same real language and, very often, the same real SwiftUI view code targets iOS, iPadOS, macOS, watchOS, tvOS, and visionOS. This course focuses on iOS specifically, since it's the most common real starting point, but the SwiftUI concepts carry over directly to Apple's other platforms with comparatively small, targeted changes rather than a rewrite.

Coming From Web Development

If you've worked through this site's own React courses, SwiftUI's declarative model will feel genuinely familiar — a view's own body describes what the UI should look like for the current state, and the framework itself figures out what actually needs to change on screen, the same conceptual deal as JSX describing a component's own render output. The real difference shows up immediately in the syntax: no JSX, no virtual DOM — SwiftUI's own view hierarchy is built directly out of real Swift structs and protocols, covered in full starting in Chapter 5.

Installing Xcode

Open the Mac App Store and search for Xcode — it's real, free, and officially distributed only through the App Store or Apple's own developer downloads page.
The download is large (often several gigabytes) — Xcode bundles real iOS/iPadOS/watchOS/tvOS simulators alongside the editor itself.
On first launch, Xcode installs additional real command-line tools automatically — accept the prompt.

Your First App, Broken Down Piece by Piece

Creating a new Xcode project with the "App" template generates real, working code close to this — enough to run immediately in the Simulator, with no changes needed:

import SwiftUI

@main
struct MyFirstApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

struct ContentView: View {
    var body: some View {
        Text("Hello, World!")
            .padding()
    }
}

Piece	What It Actually Does
`@main`	Marks this real struct as the app's own entry point — the equivalent of a `main()` function, applied to a type instead of a free function.
`App`	A real protocol every SwiftUI app's top-level struct conforms to, requiring exactly one computed property: `body`.
`WindowGroup`	A real `Scene` that manages one or more windows showing the same real root view — on iOS, this is simply the app's own single screen.
`View`	A real protocol any SwiftUI screen or UI piece conforms to, also requiring a `body` — this is the piece Chapter 5 covers in full depth.
`some View`	An opaque return type — the real, exact underlying type is hidden, but the compiler still knows and checks it fully at real compile time.

Running It

Choose a real Simulator device (e.g. "iPhone 17") from Xcode's own device menu and press the Run button, or Cmd+R. Xcode builds the app and launches it inside the Simulator — no physical iPhone is needed for this course's early chapters.

Hands-On Exercises

Exercise 1

Install Xcode, create a new iOS App project (SwiftUI interface), and run the default template in the Simulator. Confirm it builds and launches without changes.

📄 View solution

Exercise 2

Change the text inside Text("Hello, World!") to a message of your own, and add a second Text view directly below it inside ContentView's own body. Explain, in your own words, why this alone doesn't yet compile without one further change (a hint: body can only return one view).

📄 View solution

Exercise 3

Explain, in your own words, why App and View both being real Swift protocols — rather than base classes to inherit from — is a meaningful design choice, not just a naming detail.

📄 View solution

Chapter 1 Quick Reference

iOS development = Swift (the language) + SwiftUI (the declarative UI framework) + Xcode (the IDE) — current real versions as of this writing: Swift 6.3.3, Xcode 26
Xcode requires macOS — there's no real Windows/Linux version
The same Swift/SwiftUI code targets iOS, iPadOS, macOS, watchOS, tvOS, and visionOS
@main marks the app's real entry point; App and View are protocols, each requiring a body property
SwiftUI's declarative model is conceptually close to React's own — describe what the UI should look like for the current state, not the steps to build it