Swift Academy · Lesson

Mutation, Sharing and Unexpected Aliasing

How shared references cause bugs and how value types prevent them.

Lesson 2 of 412 steps

Mutation, Sharing and Unexpected Aliasing is a free Swift Academy lesson on CoddyKit. This is lesson 2 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, and your progress syncs across the web and the CoddyKit app. The Swift Academy course includes 4 lessons in total.

Welcome

Aliasing occurs when two variables refer to the same object. With value types it's impossible; with reference types it leads to surprising bugs. Understanding this distinction is key.

Value Types Have No Aliasing

```swift var a = [1,2,3] var b = a // independent copy a.append(4) print(b) // [1,2,3] — unchanged ``` Every assignment of a value type creates an independent copy.

Reference Types DO Alias

```swift class Counter { var value = 0 } let a = Counter() let b = a // SAME object a.value += 1 print(b.value) // 1 — b sees the change! ``` Both `a` and `b` point to the same heap object.

Aliasing in Function Parameters

```swift func increment(_ c: Counter) { c.value += 1 } let shared = Counter() increment(shared) print(shared.value) // 1 — mutated by the function ``` Classes are passed by reference — the function mutates the original.

The Problem: Shared Mutable State

```swift class Cache { var items: [String] = [] } var cache = Cache() var cache2 = cache // aliased! cache.items.append("data") print(cache2.items) // ["data"] — unexpected! ``` This is how seemingly unrelated parts of code affect each other.

Solving with Value Types

```swift struct Cache { var items: [String] = [] } var cache = Cache() var cache2 = cache // independent copy cache.items.append("data") print(cache2.items) // [] — unaffected ```

Solving with Copying Classes

```swift func process(_ c: Counter) { var local = Counter() local.value = c.value // copy values, not reference local.value += 1 } ``` When you need reference semantics but not aliasing, copy the values explicitly.

Thread Safety and Aliasing

Aliasing becomes especially dangerous across threads: ```swift // Thread 1: cache.items.append("a") // Thread 2 simultaneously: cache.items.append("b") // ❌ data race! ``` Value types in Swift Concurrency prevent this by default — only actors can share mutable state.

Detecting Accidental Aliasing

Xcode's Thread Sanitizer (TSan) detects data races at runtime. Enable it under Scheme > Diagnostics > Thread Sanitizer. Swift Exclusivity Enforcement catches single-threaded aliasing violations for `inout` parameters at runtime.

Intentional Aliasing Patterns

Sometimes aliasing is intentional — e.g. a global cache: ```swift class AppCache { static let shared = AppCache() // intentional shared reference var data: [String: Any] = [:] } ``` Document intentional sharing clearly; avoid accidental aliasing by defaulting to value types.

Quick Check

What happens when you assign a class instance to a new variable?

Answer it in the interactive lesson

Recap

Key takeaways: • Value types (struct) — assignment copies; no aliasing possible • Reference types (class) — assignment shares reference; aliasing possible • Aliasing across threads = data race • Default to structs; use classes only when shared identity is needed • Use TSan and Swift Exclusivity to detect issues Next: mixed value/reference graphs.

Free to start

Learn Swift with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 122
Lessons: 409

Start learning free View the full course

Frequently Asked Questions

Is the “Mutation, Sharing and Unexpected Aliasing” lesson free?

Yes — any 3 lessons of the Swift Academy learning path, including “Mutation, Sharing and Unexpected Aliasing”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Swift Academy course includes 4 lessons in total.

What will I learn in “Mutation, Sharing and Unexpected Aliasing”?

How shared references cause bugs and how value types prevent them. 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, so you can start here or from the beginning and move at your own pace. This is lesson 2 of 4.

How long does the “Mutation, Sharing and Unexpected Aliasing” 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

Stack vs Heap: Where Values Live
Mutation, Sharing and Unexpected Aliasing
Mixed Value/Reference Graphs
Designing APIs for Value Semantics

← Back to Swift Academy