Optionals and Guard
Write a function that takes a String and returns an Int? only when the value is between 1 and 100. Use guard and optional binding.
Languages / Knowledge library
Swift
a safe compiled language for apple platforms
Why learn Swift?
Swift gives teams a modern, fast language with strong type safety, better memory safety, and clearer syntax than older Apple-platform options, while still interoperating with existing Objective-C/C/C++ code.
Where it came from
2014: Apple announced Swift at WWDC. 2015: Swift became open source and started expanding beyond Apple OS targets. 2019: ABI stability on Apple platforms enabled binary-compatible frameworks. 2021: Async/await shipped, making asynchronous code easier to read and maintain. 2023: Swift 5.9 added macros and major language tooling updates. 2024: Swift 6 focused on stronger compile-time concurrency safety.
- 2014: Apple announced Swift at WWDC.
- 2015: Swift became open source and started expanding beyond Apple OS targets.
- 2019: ABI stability on Apple platforms enabled binary-compatible frameworks.
- 2021: Async/await shipped, making asynchronous code easier to read and maintain.
- 2023: Swift 5.9 added macros and major language tooling updates.
- 2024: Swift 6 focused on stronger compile-time concurrency safety.
Build your understanding
Work through these exercises in order. Try the task before opening a reference.
- Write a function that takes a String and returns an Int? only when the value is between 1 and 100. Use guard and optional binding.
- Create a struct and a class with similar fields. Mutate copies and explain the output difference in 3 short lines.
- Using async/await, model two async calls where the second depends on the first. Handle errors with do/catch and return a fallback value.
- Build an actor-based counter used by multiple tasks. Show why actor isolation avoids data races.
- Describe one repetitive code pattern in your app and sketch how a Swift macro could reduce boilerplate safely.
More ways to practice
Value vs Reference Behavior
Create a struct and a class with similar fields. Mutate copies and explain the output difference in 3 short lines.
Async Fetch Flow
Using async/await, model two async calls where the second depends on the first. Handle errors with do/catch and return a fallback value.
Actor for Shared State
Build an actor-based counter used by multiple tasks. Show why actor isolation avoids data races.
Macro Use Case Design
Describe one repetitive code pattern in your app and sketch how a Swift macro could reduce boilerplate safely.
Documentation and sources
- Swift.org (www.swift.org)
- The Swift Programming Language (Book) (docs.swift.org)
- Swift Evolution Proposals (github.com)
- Swift Package Manager (www.swift.org)
Catalog research notes
- Swift 6 introduced a new language mode with stricter data-race safety checks.
- C++ interoperability has expanded, making mixed Swift/C++ projects easier.
- Macros (from Swift 5.9) are now widely used for safer code generation.
- Swift Package Manager keeps improving build speed, plugins, and cross-platform workflows.
Connect the ideas
Explore next
Real World Example
Legacy C++ Sensor Integration
Industrial IoT manufacturers maintaining legacy C++ firmware for sensor data processing.
The business problem
Frequent memory corruption and data races occur when manual memory management is used to bridge high-speed sensor data into modern application logic.
How this topic solves it
Swift provides native interoperability with C++ types, allowing developers to wrap legacy sensor processing routines in a memory-safe environment without requiring a full rewrite of the existing C++ codebase.
- Identify the existing C++ sensor data structures and processing functions.
- Import the C++ headers into the Swift project using the native C++ interoperability layer.
- Define Swift-side wrappers that utilize Swift's strong type system to encapsulate C++ pointers.
- Implement data processing logic in Swift, leveraging compile-time memory safety guarantees.
- Verify that the Swift-wrapped code interacts correctly with the underlying C++ memory buffers.
The flow shows how raw sensor data moves from legacy C++ into a safe Swift environment.
Raw data source
Legacy memory-unsafe code
Memory-safe interface
High-level processing
- Sensor Hardware → raw buffer → C++ Driver
- C++ Driver → direct import → Swift Wrapper
- Swift Wrapper → safe access → Application Logic
Implementation example
This code demonstrates how Swift directly uses C++ types, mapping them to Swift-safe structures to prevent memory corruption.
import CxxStdlib // Import C++ standard library types
func processSensorData(data: [std.string]) {
// Swift safely iterates over C++ types without manual memory management
for entry in data {
print("Processing sensor: \(entry)")
}
}Expected business outcome
A more robust sensor processing pipeline where memory safety is enforced at compile time, reducing runtime crashes caused by invalid pointer access.
Limitations and checks
Swift's interoperability relies on the compiler's ability to map C++ types; complex template-heavy C++ code may require manual bridging or simplification, which can be verified by checking the compiler's ability to generate the corresponding Swift interface.