Swift Academy

Type Casting with as, as? and as!

Safely inspect and convert types at runtime using Swift's type casting operators.

String Interpolation and Formatting

Build dynamic, formatted strings using interpolation, format specifiers, and custom interpolation.

Nil Coalescing and Default Values

Provide safe fallbacks for optionals using the nil-coalescing operator and sensible defaults.

Optional Binding Patterns

Unwrap optionals safely and expressively with if let, guard let, and multiple bindings.

Swift Array Operations and Algorithms

Everything about Swift arrays: creation, mutation, sorting, searching, slicing and functional operations like map, filter and reduce.

Swift Dictionary and Set Mastery

Learn to use Swift's Dictionary and Set types effectively: CRUD operations, iteration, set algebra and practical use cases.

Switch Statements and Pattern Matching

Use Swift's powerful switch to match values, ranges, tuples, and bindings exhaustively.

Ranges, Stride and Counting

Generate sequences of values with ranges and stride for precise, readable iteration.

Type Inference vs Explicit Annotations

Balance Swift's powerful type inference with explicit annotations for clarity and correctness.

Loop Control: break, continue, labels

Direct loop flow precisely with break, continue, fallthrough, and labeled statements.

Control Flow & Patterns

Master Swift control flow with if/else, switch, loops, and pattern matching.

Swift guard Statement

In this course, we will learn about the guard, an expression we will use frequently. The use of guard statement is similar to if. Let's learn the guard statement in detail.

Parameters in Swift

In this course, we will learn about the useful features of parameters in Swift language.

Swift Collections

In this lesson, we will learn about collection types in Swift, which is one of the most important topics.

Tuple in Swift

It is a type that is used to keep more than one value in a combined form. Consider a function, this function freezes the latitude and longitude information of a coordinate. In this course, we will le…

Collections I

Work with Swift collections: arrays, dictionaries, and sets. Learn creation, updates, iteration, and mutability.

Optionals in Swift

Used to express that an optional variable may not have a value. If a variable of the optional type has a value, this variable is unwrapped and used. Or there is no value. In this course, we will lear…

Strings in Swift

Stored Properties

Property is added to define the properties of an object. In order to add a property to an object in Swift, the variable or constant definition must be added to the type definition.

Range Operators

In this course, we will learn about the range operators provided to us by Swift.

Strings & Unicode

Work with Unicode-correct strings: grapheme clusters, safe indices, substrings, common APIs, and copy-on-write behavior.

Assertions and Preconditions

Assertions and preconditions are the processes of checking the application at runtime. Before running any code, it checks that certain conditions are met and this usually happens with the bool operat…

Enums in Swift

In this lesson, we will learn the subject of Enumeration. Enumeration is used to create user-defined types. In the next step, working with this user-defined associated data allows us to write code wi…

Structs & Classes I

Understand Swift's primary types: structs (value semantics) and classes (reference semantics). Learn properties, observers, initializers, and deinitializers.

Characters, Unicode Scalars and Graphemes

Understand how Swift models text as extended grapheme clusters for correct Unicode handling.

Swift Struct Design Patterns

Build robust value types with Swift structs: custom initializers, computed properties, mutating methods and copy semantics.

Swift Class Inheritance and Polymorphism

Understand Swift classes: inheritance, method overriding, final, type casting with as? and the Liskov substitution principle.

Swift Enum Patterns and State Machines

Use Swift enums to model domain logic: raw values, associated values, recursive enums and finite state machines.

Swift Protocol Composition and Conformance

Compose behaviours with protocol composition, conditional conformance, Self requirements and protocol-oriented design.

Array Slicing and ArraySlice

Work efficiently with portions of arrays using ArraySlice while understanding index semantics.

Mutating vs Non-mutating Methods

Understand value-type mutation rules and write correct mutating methods on structs and enums.

The defer Statement and Scope Cleanup

Guarantee cleanup code runs when a scope exits using defer for resources and rollbacks.

Value Types vs Reference Types in Depth

Understand when to choose structs vs classes, copy semantics, identity operators, and designing APIs around value semantics.

Result Type and Structured Error Handling

Use Swift's Result type to model errors explicitly, transform results with map/flatMap, and bridge to async/await.

SwiftUI Basics: Views, Modifiers and State

Build your first SwiftUI views, understand declarative UI, use @State for local state, and apply view modifiers.

SwiftUI Layout: Stacks, Grids and Geometry

Master SwiftUI layout with VStack, HStack, ZStack, LazyVGrid, LazyHGrid and GeometryReader for adaptive interfaces.

Codable: Encoding and Decoding JSON

Serialize and deserialize Swift types to and from JSON with the Codable protocol.

Higher-Order Functions Mastery

Transform collections expressively with map, filter, reduce, flatMap, and compactMap.

Closures Deep Dive

Master closure capture semantics, escaping closures, autoclosures, and capture lists.

Equatable, Hashable and Comparable

Make your types work seamlessly in sets, dictionaries, and sorted collections.

Working with Dates and Calendars

Handle dates, time zones, and calendar math correctly with Date, Calendar, and DateComponents.

FileManager and File I/O

Read, write, and organize files and directories on disk with FileManager and URLs.

NotificationCenter and Observer Patterns

Broadcast and observe events across your app with NotificationCenter and modern alternatives.

Swift Closures

Closures are self-contained blocks of code. A closure is passed as a parameter to the code, or it can be used inside codes. Let's learn how to use closures in Swift.

Lazy and Computed Properties

In this course, we will learn about lazy and computed properties that we will use frequently in our applications.

Access Control

In this course, we will learn about lazy and computed properties that we will use frequently in our applications.

Subscripts

Subscripts are a shortcut to access member items of a collection, list, or directory. Use subscripts to set and retrieve values ​​according to the index without the need for separate getter and sette…

Error Handling in Swift

While the application is running, some errors may occur depending on the code of our application (logic errors, etc.) or depending on the environment in which the application is running. In this less…

Optionals II & Error Handling

Dive deeper into Optionals with chaining, guard patterns, and combine them with Swift error handling using throws, try, do/catch, and Result.

Closures & Capture

Learn closures in Swift: syntax, shorthand arguments, trailing closure, capture lists, and escaping vs non-escaping.

Properties & Subscripts

Enhance Swift types with advanced properties and subscripts. Learn lazy properties, get/set computed props, observers, and subscript access.

Modules & SPM Basics

Learn Swift Package Manager (SPM): initialize packages, modules, layout, build/test, and import dependencies.

Protocols & Extensions

Learn Swift protocols for shared interfaces, add extensions to types, and provide default implementations. Cover static vs instance requirements.

Enums with Power

Swift enums can hold raw or associated values. Use switch with pattern matching for powerful state modeling.

Structs & Classes II

Dive deeper into Swift's value and reference types: learn about memberwise initializers , mutating methods , inheritance, and access control.

Linting & Style

Keep codebases consistent with SwiftFormat (auto-format) and SwiftLint (static rules). Learn setup, common rules, and team workflows.

Functional Programming in Swift

Apply functional programming techniques in Swift: pure functions, higher-order functions, function composition, and lazy evaluation.

Swift Property Wrappers

Build and use property wrappers to encapsulate property storage logic: @Published, @State, custom wrappers and projected values.

SwiftUI Data Flow: Bindings and Environment

Understand SwiftUI's data flow: @Binding, @ObservableObject, @EnvironmentObject and the single-source-of-truth principle.

Combine Framework Fundamentals

Learn Apple's Combine reactive framework: publishers, subscribers, operators, subjects and integrating with URLSession.

Swift Structured Concurrency

Master Swift's async/await, Task, TaskGroup, Actor model and structured concurrency for safe concurrent code.

Protocol-Oriented Programming Patterns

Design flexible, composable APIs using protocols, default implementations, and protocol composition.

Generic Constraints and where Clauses

Write precise generic code by constraining type parameters with protocols and where clauses.

Codable: Custom Keys and Strategies

Control JSON mapping with custom coding keys, encoding strategies, and manual encode/decode.

KeyPaths and Dynamic Member Lookup

Reference and compose property access with key paths and build expressive dynamic APIs.

Lazy Sequences and Lazy Evaluation

Defer expensive collection work and process large data efficiently with lazy sequences.

CustomStringConvertible and Mirror

Control how your types print and inspect them at runtime with reflection.

Swift Regex and Pattern Matching

Parse and validate text with Swift's modern Regex literals, builders, and matching APIs.

Dependency Injection in Swift

Decouple components and improve testability with constructor, property, and protocol-based injection.

Generics I

Build reusable code with generics : write functions and types that work for many data types while keeping static type safety.

Protocols with Associated Types

Model relationships with associated types in protocols, build generic protocols, and understand how conformers pick concrete types.

Sequences & Algorithms

Nail Swift's iterable hierarchy: Sequence → Collection → BidirectionalCollection → RandomAccessCollection , and pick the right algorithms for each.

Operators & Customization

Create lightweight, readable math-like APIs with operator overloading and custom precedence groups —used sparingly and clearly.

Testing & Diagnostics

Learn XCTest basics: how to set up a test target, write test cases, and use fixtures ( setUp / tearDown ) for reliable unit tests.

Advanced SwiftUI: Animations and Custom Modifiers

Create fluid animations with withAnimation, matchedGeometryEffect, TimelineView, and build custom AnimatableModifiers.

UIKit Integration in SwiftUI

Bridge UIKit and SwiftUI using UIViewRepresentable, UIViewControllerRepresentable, Coordinator pattern and hosting controllers.

Core Data and SwiftData

Persist data with Core Data and Apple's modern SwiftData framework: modelling, CRUD, relationships, migrations and CloudKit sync.

Networking with URLSession and async/await

Build robust networking layers in Swift: URLSession data tasks, async/await APIs, Codable decoding, error handling and retry logic.

Unit Testing Swift with XCTest

Write effective unit tests in Swift: test organisation, XCTAssert family, mocking with protocols, async tests and measuring performance.

Swift Package Manager and Modularization

Build multi-module Swift apps with SPM: Package.swift targets, local packages, binary targets and managing dependencies.

AVFoundation: Audio and Video

Play, record, and process audio and video media with the AVFoundation framework.

Core Location and MapKit

Access device location and present interactive maps with Core Location and MapKit.

Swift on the Server with Vapor

Build type-safe backend APIs in Swift using the Vapor web framework.

MVVM and Coordinator Patterns

Organize iOS apps with the MVVM presentation pattern and Coordinator-based navigation.

Localization and Internationalization

Make your app world-ready with localized strings, plurals, and locale-aware formatting.

Push Notifications and Background Tasks

Deliver timely updates with push notifications and run work in the background reliably.

Keychain Services and App Security

Store secrets securely and protect user data using Keychain and Apple's security APIs.

Widgets, App Extensions and App Intents

Extend your app beyond its main UI with home-screen widgets, extensions, and App Intents.

Property Wrappers

Create reusable behaviors with @propertyWrapper : control wrappedValue , expose extras through projectedValue ( $var ), and configure via initializers.

async/await Basics

Write clear asynchronous code with async/await and structured concurrency : start lightweight tasks, await results safely, and keep lifetimes scoped.

Interop & Scripts

Write quick Swift scripts with a shebang, parse CLI arguments, set exit codes, and build simple command-line tools.

Distribution & CI

Distribute Swift projects with SwiftPM and CI: choose library vs executable packages, tag releases, and ship artifacts reliably.

ARC and Memory Management Patterns

Deep dive into Automatic Reference Counting: retain cycles, weak/unowned, capture lists in closures and debugging leaks.

Memory Management & ARC

Understand Swift ARC: how strong references keep objects alive, and how weak and unowned break cycles safely.

Advanced Generics and Opaque Types

Push generics further with conditional conformance, opaque return types (some), existentials (any) and primary associated types.

Swift Macros

Understand Swift 5.9 macros: freestanding expression and declaration macros, attached macros, and writing macros with SwiftSyntax.

Clean Architecture in Swift

Implement Clean Architecture with SOLID principles in Swift: separation of layers, dependency inversion, use cases and repository pattern.

Performance Profiling with Instruments

Profile Swift apps with Xcode Instruments: Time Profiler, Allocations, Leaks, Main Thread Checker and optimising hot paths.

Sendable and Strict Concurrency

Write data-race-free code for Swift 6 with Sendable, isolation, and strict concurrency checking.

SwiftUI Custom Layout Protocol

Build bespoke layouts beyond stacks and grids using the SwiftUI Layout protocol.

SwiftUI Performance Optimization

Diagnose and eliminate SwiftUI redraw bottlenecks for smooth, efficient interfaces.

Core Animation and Advanced Graphics

Create rich visual effects with Core Animation layers, transforms, and custom drawing.

The Composable Architecture (TCA)

Structure SwiftUI apps with unidirectional data flow using The Composable Architecture.

Advanced Combine: Operators and Schedulers

Compose complex asynchronous pipelines with advanced Combine operators and scheduling.

Unsafe Swift: Pointers and Memory

Work directly with memory using unsafe pointers, buffers, and MemoryLayout when performance demands it.

Generics II: Advanced Constraints

Dive deeper into generics: use conditional conformances and where clauses to make types adopt protocols only when their generic parameters satisfy constraints.

Opaque & Existential Types

Understand opaque result types ( some P ): hide concrete types behind protocols while keeping static dispatch and generics working.

Result Builders & DSLs

Create lightweight DSLs using @resultBuilder : compose nested structures with clean syntax while generating values behind the scenes.

Concurrency Patterns

Apply practical concurrency patterns in Swift: producer/consumer queues, streaming pipelines with AsyncSequence , and cooperative timeouts .

Task Groups & Actors

Run many child tasks safely using TaskGroup : spawn, await, and collect results with structured concurrency guarantees.