0Pricing
Swift Academy · Lesson

Logging, assert/precondition/fatalError

Log state with print/debugPrint , and choose between assert (debug-only), precondition (checked in release), and fatalError (crash) for invariants.

Logging, assert/precondition/fatalError is a free Swift Academy lesson on CoddyKit — lesson 2 of 2. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 2 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Diagnostics toolbox

Use simple logging to see state; enforce assumptions with assert, precondition, and fatalError.

  • assert: debug-only checks
  • precondition: checked in release too
  • fatalError: stop immediately

Lightweight logging

print is readable; debugPrint shows more detail (useful while debugging).

let user = ["name": "Ana", "role": "admin"]
print("User:", user)            // user-friendly
debugPrint("User:", user)       // includes type details when available

let point = (x: 3, y: 5)
print("Point:", point)
debugPrint("Point:", point)

assert (debug-only)

assert stops the program in Debug when the condition is false; it is removed in optimized Release builds.

// Even numbers only (demo)
func half(of x: Int) -> Int {
    assert(x % 2 == 0, "Expected even number, got \(x)")
    return x / 2
}
print(half(of: 8))   // OK in Debug/Release
// In Debug, failing the assert would stop and print the message.
// In Release, assert checks are disabled by default.

precondition (release-checked)

precondition validates critical requirements in Debug and Release. Use it for programmer errors that must never happen.

// Safe divide with required precondition
func safeDivide(_ a: Int, by b: Int) -> Int {
    precondition(b != 0, "Divider must be nonzero")
    return a / b
}
print(safeDivide(10, by: 2))    // 5
// If called with 0, precondition fails in Debug and Release.

fatalError (stop now)

fatalError stops execution immediately and reports a message. Use it for unreachable code paths or unimplemented functionality during development.

enum FileKind { case text, binary }

func open(kind: FileKind) {
    switch kind {
    case .text:
        print("Open text mode")
    case .binary:
        print("Open binary mode")
    // If we ever add a new case and forget to handle it, we could use:
    // default: fatalError("Unsupported file kind")
    }
}
open(kind: .text)

When to use which

Guidelines:

  • print/debugPrint for quick logs (remove or gate behind flags later).
  • assert for debug-only developer checks.
  • precondition when the program must not continue in any build if a requirement fails.
  • fatalError for unreachable/unimplemented paths.

Release-checked diagnostic

Quick check: Which diagnostic is still checked in Release builds?

Recap

Recap: Log with print/debugPrint, guard invariants with assert (debug), precondition (release too), and use fatalError for truly unreachable states.

Frequently asked questions

Is the “Logging, assert/precondition/fatalError” lesson free?

Yes — the full text of “Logging, assert/precondition/fatalError” is free to read here on the web, and the Swift Academy course includes 2 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.

What will I learn in “Logging, assert/precondition/fatalError”?

Log state with print/debugPrint , and choose between assert (debug-only), precondition (checked in release), and fatalError (crash) for invariants. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 2, so you can start here or from the beginning and move at your own pace.

How long does the “Logging, assert/precondition/fatalError” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. XCTest basics (targets, fixtures)
  2. Logging, assert/precondition/fatalError
← Back to Swift Academy