iOS Development Explained — Beginner's Guide with Swift

iOS development with Swift lets you build applications for iPhone, iPad, Apple Watch, and Apple TV using a safe, fast, and expressive language designed by Apple for creating polished, high-performance native apps.

What You’ll Learn

You’ll understand the ViewController lifecycle, the difference between Storyboards and SwiftUI, create table views, and build a simple “Hello World” iOS app with Swift code examples.

Why iOS Development Matters

The Apple App Store generates over $700 billion annually in developer billings and sales. iOS users tend to spend more on apps and in-app purchases than Android users. At DodaTech, we’re building mobile versions of our security tools for iOS. Learning iOS development opens access to a premium user base and the Apple ecosystem.

iOS Development Learning Path

    flowchart LR
  A[Mobile Development Overview] --> B[iOS Development]
  B --> C[Swift Language Basics]
  C --> D[UIKit & Storyboards]
  D --> E[SwiftUI]
  E --> F[Data Persistence]
  F --> G[Networking]
  G --> H[App Store Submission]
  B:::current

  classDef current fill:#f90,color:#fff,stroke:#333,stroke-width:2px
  

UIKit vs SwiftUI — Which Should You Learn?

Apple provides two frameworks for building iOS interfaces:

UIKit (since 2008) uses Storyboards and XIB files. It’s mature, with thousands of tutorials and enterprise apps built on it. You drag and drop UI elements in Interface Builder, then connect them to Swift code.

SwiftUI (since 2019) uses a declarative syntax — you describe what the UI should look like, and SwiftUI handles the rest. It’s newer, requires less code, and updates automatically when data changes.

Think of UIKit like cooking with a printed recipe (you follow exact steps), while SwiftUI is like ordering from a menu (you describe what you want and the kitchen handles the process).

For this tutorial, we’ll start with UIKit since it’s still the standard for professional iOS development, then show you SwiftUI equivalents.

The ViewController Lifecycle

Every screen in an iOS app is managed by a UIViewController. Like Android’s Activity, it has a lifecycle:

    stateDiagram-v2
  [*] --> viewDidLoad: View loaded into memory
  viewDidLoad --> viewWillAppear: About to appear on screen
  viewWillAppear --> viewDidAppear: Now visible
  viewDidAppear --> viewWillDisappear: About to leave screen
  viewWillDisappear --> viewDidDisappear: No longer visible
  viewDidDisappear --> viewWillAppear: Coming back
  viewDidDisappear --> deinit: View removed from memory
  deinit --> [*]
  

Key methods and when to use them:

Building Your First iOS App

Let’s build a simple app that greets the user and shows a list of items.

Step 1: Create a New Project

Open Xcode and choose File > New > Project. Select iOS > App and name it “HelloDodaTech”. Choose Storyboard as the interface and Swift as the language.

Step 2: Design the Main Screen

Open Main.storyboard. You’ll see a blank canvas. From the Object Library (the + button in the top toolbar), drag these elements onto the canvas:

1. A Label (position it near the top)
2. A Text Field (below the label)
3. A Button (below the text field)
4. A Table View (below the button)

Your storyboard represents the visual layout of your app. Each element on the canvas is a view that will appear on screen.

Step 3: Connect UI to Code

To make the interface interactive, we need to connect the storyboard elements to Swift code. This is called creating outlets (references to UI elements) and actions (functions triggered by UI events).

Open ViewController.swift and update it:

import UIKit

class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {
    
    // MARK: - Outlets (connected from Storyboard)
    @IBOutlet weak var nameTextField: UITextField!
    @IBOutlet weak var greetingLabel: UILabel!
    @IBOutlet weak var tableView: UITableView!
    
    // MARK: - Properties
    var items: [String] = ["Learn iOS Development", "Build an App", "Submit to App Store", "Make Millions!"]
    
    // MARK: - Lifecycle
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Set up the table view
        tableView.dataSource = self
        tableView.delegate = self
        
        // Register a basic cell type
        tableView.register(UITableViewCell.self, forCellReuseIdentifier: "Cell")
        
        // Initial greeting
        greetingLabel.text = "Welcome to iOS Development!"
        greetingLabel.textAlignment = .center
    }
    
    // MARK: - Actions
    @IBAction func greetButtonTapped(_ sender: UIButton) {
        // Get the text from the input field
        let name = nameTextField.text ?? ""
        
        if name.isEmpty {
            // Show an alert if no name entered
            let alert = UIAlertController(
                title: "No Name",
                message: "Please enter your name first.",
                preferredStyle: .alert
            )
            alert.addAction(UIAlertAction(title: "OK", style: .default))
            present(alert, animated: true)
        } else {
            greetingLabel.text = "Hello, \(name)! 🎉"
            nameTextField.resignFirstResponder() // Dismiss the keyboard
        }
    }
    
    // MARK: - Table View Data Source
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return items.count
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
        cell.textLabel?.text = items[indexPath.row]
        cell.accessoryType = .disclosureIndicator
        return cell
    }
    
    // MARK: - Table View Delegate
    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        tableView.deselectRow(at: indexPath, animated: true)
        
        let selectedItem = items[indexPath.row]
        let alert = UIAlertController(
            title: "Selected",
            message: "You tapped: \(selectedItem)",
            preferredStyle: .alert
        )
        alert.addAction(UIAlertAction(title: "OK", style: .default))
        present(alert, animated: true)
    }
}

Breaking down the code:

• @IBOutlet — This tag tells Xcode that this property is connected to a UI element in the storyboard. Think of it as a bridge between the visual layout and your code
• @IBAction — This marks a function as connectable from the storyboard. When you drag from a button to this function in the Assistant Editor, Xcode creates the connection
• UITableViewDataSource — A protocol (a set of required methods) that provides data to the table view. It answers “how many rows?” and “what goes in each row?”
• UITableViewDelegate — A protocol that handles user interaction with the table view, like tapping a row
• tableView.dequeueReusableCell(withIdentifier:) — This is a performance optimization. Instead of creating a new cell for every row, iOS reuses cells that scrolled off screen. Think of it like a taxi queue: when a passenger leaves a taxi, it goes to the back of the queue for the next passenger
• nameTextField.resignFirstResponder() — This dismisses the on-screen keyboard. resignFirstResponder means “this text field no longer wants to be the first thing responding to keyboard input”

Step 4: Connect Storyboard Outlets

Open Main.storyboard with the Assistant Editor (the interlocking rings icon in the toolbar). Control-drag from each UI element to the ViewController.swift code:

1. Control-drag from the Label to the @IBOutlet weak var greetingLabel line
2. Control-drag from the Text Field to @IBOutlet weak var nameTextField
3. Control-drag from the Table View to @IBOutlet weak var tableView
4. Control-drag from the Button to the @IBAction func greetButtonTapped function

Expected Output

When you run the app on the iOS Simulator (select iPhone 15 or later):

1. A label says “Welcome to iOS Development!”
2. A text field lets you type your name
3. Tapping “Greet Me” updates the label to “Hello, [Name]!”
4. Below, a table view shows four pre-defined items
5. Tapping any row shows an alert with the item name

The SwiftUI Alternative

If you prefer SwiftUI (iOS 13+), here’s the same app in dramatically less code:

import SwiftUI

struct ContentView: View {
    @State private var name: String = ""
    @State private var greeting: String = "Welcome to iOS Development!"
    let items = ["Learn iOS Development", "Build an App", "Submit to App Store", "Make Millions!"]
    
    var body: some View {
        VStack(spacing: 20) {
            Text(greeting)
                .font(.title)
                .padding()
            
            TextField("Enter your name", text: $name)
                .textFieldStyle(.roundedBorder)
                .padding(.horizontal)
            
            Button("Greet Me") {
                if name.isEmpty {
                    greeting = "Please enter a name!"
                } else {
                    greeting = "Hello, \(name)!"
                }
            }
            .buttonStyle(.borderedProminent)
            
            List(items, id: \.self) { item in
                Text(item)
            }
        }
        .padding()
    }
}

SwiftUI differences:

• @State tells SwiftUI to watch this variable and redraw the UI when it changes. Think of it like a sensor that triggers a refresh
• $name uses the $ prefix to create a two-way binding — the TextField can both read and write the name variable
• VStack arranges views vertically (like a vertical LinearLayout in Android)
• List automatically creates the table view cells from the array

Security Angle: Input Validation

iOS apps commonly face security threats through text input. In our code, we check name.isEmpty before using the value. For production iOS apps:

• Use UITextField delegate methods like textField(_:shouldChangeCharactersIn:) to restrict input characters
• Never store sensitive data in UserDefaults without encryption
• Use the Keychain (SecItemAdd, SecItemCopyMatching) for passwords and tokens
• Enable App Transport Security (ATS) to enforce HTTPS connections
• Sanitize any input before displaying it to prevent injection attacks

DodaTech’s security tools scan iOS apps for these exact vulnerabilities, checking for insecure data storage and improper input handling.

Common Mistakes Beginners Make

1. Forgetting to connect outlets: If you see nil crashes when accessing a UI element, check that the outlet connection exists in the storyboard.
2. Not registering table view cells: Your table will crash with “unable to dequeue a cell with identifier” if you skip the register() call.
3. Blocking the main thread: Like Android, iOS UI updates must happen on the main thread. Network calls on the main thread freeze the UI.
4. Strong reference cycles (retain cycles): When two objects hold strong references to each other, they never get deallocated. Use weak for delegate references.
5. Not handling the keyboard: When the keyboard appears, it can cover text fields. Implement keyboard notifications or use IQKeyboardManager.
6. Hardcoding strings: Use NSLocalizedString for all user-facing text to support internationalization.
7. Ignoring Safe Area: Not accounting for the notch, status bar, or home indicator on modern iPhones causes layout issues.

Practice Questions

1. What method is called when a ViewController’s view first loads into memory?
2. What’s the difference between @IBOutlet and @IBAction?
3. Why do we use dequeueReusableCell instead of creating new cells?
4. What does resignFirstResponder() do?
5. In SwiftUI, what does @State do?

Answers:

1. viewDidLoad() — it’s called once when the view is first created.
2. @IBOutlet connects a UI element to a property; @IBAction connects a UI event to a function.
3. It recycles off-screen cells for performance instead of creating new ones each time.
4. It dismisses the keyboard by telling the text field it no longer wants input focus.
5. @State makes SwiftUI watch the variable and automatically redraw the UI when it changes.

Challenge

Add a “Delete” feature to the table view. Implement swipe-to-delete by adding the tableView(_:commit:forRowAt:) method. When the user swipes left on a row, show a “Delete” button that removes that item from the array and updates the table.

Real-World Task

Create a simple to-do list app with a text field to add items and a table view to display them. Each row should show a checkmark button that toggles between completed and not completed states. Save the list to UserDefaults so it persists between app launches.

Featured Snippet

What is the iOS ViewController lifecycle?

The iOS ViewController lifecycle is a sequence of methods — viewDidLoad, viewWillAppear, viewDidAppear, viewWillDisappear, viewDidDisappear, and deinit — that manage a screen’s appearance, state saving, and resource cleanup.

FAQ

Try It Yourself

What’s Next

What’s Next

Congratulations on completing this Ios Development tutorial! Here’s where to go from here:

• Practice daily — Consistency is more important than long study sessions
• Build a project — Apply what you learned by building something real
• Explore related topics — Check out other tutorials in the same category
• Join the community — Discuss with other learners and share your progress

Remember: every expert was once a beginner. Keep coding!