Level Up in Swift

Learn Swift functions, including the syntax with func, name, parameters, and return type, and explore parameter names, argument labels, and default values for cleaner calls.

Level up in Swift teaches how functions have types, can be stored in variables, and passed as parameters, enabling you to build flexible, higher-order code using function types.

Develop Swift function skills through a playful arcade with practice questions, implementing min and last digit helpers using underscores and modulus, and building a first numbers array with loops.

Explore how Swift optionals manage nil values, unwrap safely with optional binding (if let, guard), use nil coalescing and optional chaining, and avoid runtime errors.

Practice unwrapping optionals in Swift using if let and guard to safely access first and last names, print unwrapped values, and understand early exit patterns.

Level up your Swift skills by mastering closures: understand their types, passing around as variables or functions, and using inline, trailing, and inferred closures with map, filter, and reduce.

Learn how closures capture values from surrounding scope to use external variables. Understand that closures are reference types, and how scope and capturing simplify memory management.

Understand escaping closures, which outlive their function and require self for asynchronous work, and recognize that non escaping closures are safer and faster, preventing retain cycles.

Learn how auto closures in Swift act as syntactic sugar that wraps a closure for lazy evaluation and easier calls, passing expressions and messages in debug mode.

Level up in Swift shows how closures power map, filter, and reduce, the three higher-order functions, to transform arrays, filter elements by conditions, and sum results.

Explore Swift closures through hands-on challenges: apply k times, filter multiples of 3, reduce to max, join strings, and apply map, filter, and reduce patterns with trailing closures.

Explore Swift tuples, lightweight data structures that return multiple values from a method, access via index or named labels, and support mutability and decomposition.

Explore Swift tuples by returning and unpacking a status code tuple, print its components, and show how lightweight tuples replace classes for inline data usage.

Explore how Swift enums group related values, enable exhaustive switch handling, and support associated values and raw values through practical examples like compass points, planets, and barcodes.

Discover how Swift enums differ by supporting computed properties, methods, and value-based initializers, plus extensions and generics, all enabling type-safe, expressive representations of related values.

Explore how enums power practical Swift code, from representing errors and guard clauses to state machines and network status, including associated values and equitable conformance.

Level up in Swift covers grid movement with a direction enum updating x and y, and rock paper scissors with enums and a match function to determine the winner.

Explore stored versus computed properties in Swift, including lazy, property observers, and get/set, with examples like a rectangle center, a volume property, and static properties.

Learn how Swift uses computed properties versus methods to expose state and perform calculations, and why properties model state while methods handle processing.

Explore Swift property concepts through hands-on examples: computed properties for dog years and equilateral triangles, didSet observers trimming titles, and circle radius and area calculations with pi.

Level up in Swift introduces property wrappers, a layer of indirection that intercepts get and set for extra processing, including capping values like height at 12 for Swift UI properties.

Level up in Swift teaches how to use a property wrapper to apply consistent, type-safe trimming of strings (title and body) at initialization and on access, contrasting with didSet.

Explore the differences between structures and classes in Swift, learn when to use each, and understand functional programming, heaps, and stacks for practical Swift programming.

Explore functional programming in Swift, emphasizing pure functions, immutability, and higher-order functions, and learn how these ideas influence choosing between struct and class.

Explore how stack and heap memory store values in Swift, with stack storing by value and the heap storing by reference for classes, highlighting structs versus classes and performance implications.

Explore how Swift structs and classes share capabilities like values, functions, subscripts, initializers, extensions, and protocol conformance. Learn copy by value vs copy by reference and how identity checks work.

Explore Swift initialization, learn how init creates fully formed structs and classes, ensure every stored property has a value, and utilize default and memberwise initializers for safer code.

Start with structs in Swift for objects, because they’re faster, cheaper, and easier to reason about, reducing bugs; use classes when integrating with Objective-C, UIKit, or when identity matters.

Explore how Swift extensions add functionality to existing types, including methods and computed properties, and see how protocols and extensions enable protocol oriented programming with mutating and nested types.

Level up in swift explains protocols as interfaces, how to conform via structs or extensions, and how stored or computed properties, mutating methods, and polymorphism shape flexible swift design.

Define an enum direction with left, right, up, and down in Swift. Create a movable protocol with move and coordinates, and extend the player to conform.

Learn how the protocol delegate pattern lets a child control notify its parent by conforming to a protocol and implementing required methods, illustrated with a ui table view.

Learn how the protocol delegate pattern enables asynchronous weather service calls without blocking the main UI thread, using a weak, optional delegate and a did fetch weather callback.

Explore the Swift protocol delegate pattern by building a Death Star cannon service that informs a command center when the cannon is ready to fire.

Discover how to represent and signal errors in Swift using the error protocol, throws, and try-catch. Compare recoverable approaches like optional returns and result type with strategies for unrecoverable errors.

Level up in Swift explores non recoverable errors and how to handle them with assert, assert failure, precondition, and fatal error, highlighting their behavior in debug versus release builds.

Level up in Swift's error arcade teaches you to create and throw errors and call throwing functions with try, try? and try!, comparing recoverable errors with programmer errors.