This module explores how closures enhance Swift's flexibility, including their syntax, use with arrays, and handling multiple trailing closures. Learners will also discover how result builders enable the creation of expressive and maintainable domain-specific languages in Swift. By the end, you'll be able to write more concise and powerful Swift code using these advanced features.

This module explores how Swift protocols and protocol extensions enable flexible, reusable, and maintainable code. Learners will discover how protocols facilitate polymorphism, enforce consistency with enumerations, and interact with the Any type. By the end, you'll understand how to leverage these features to write more robust Swift programs.

This module introduces the concept of generics in Swift, demonstrating how they enable developers to write flexible, reusable code. Learners will explore generic functions, types, conditional extensions, and subscripts, gaining practical skills to enhance code adaptability and type safety.

This module explores the differences between value and reference types in Swift, including their behavior, memory management, and use cases. Learners will examine concepts such as inout parameters, recursive data structures, inheritance, and copy-on-write optimization. Practical examples, like implementing a queue, help solidify understanding of these foundational programming concepts.

This module explores how Swift leverages enumerations to organize related values, enhance code clarity, and manage associated data. Learners will discover how to define enums with associated values and iterate over their cases to perform useful operations. By the end, you'll be able to utilize Swift's powerful enum features to write more expressive and maintainable code.

This module explores how programs can inspect and modify their own structure at runtime using reflection. Learners will discover how to leverage the CustomReflectable protocol to control what information is exposed during runtime inspection, enhancing debugging, logging, and security practices.

This module explores how to anticipate, handle, and recover from errors in Swift applications to ensure robust and reliable software. Learners will discover techniques for throwing and catching errors, customizing error messages, and managing multiple error types efficiently.

This module introduces the fundamentals of regular expressions, demonstrating how to create and use regex patterns for text searching and manipulation. Learners will explore both traditional regex literals and the more readable RegexBuilder format, gaining practical skills for implementing pattern matching in code.

This module explores how to define and implement custom subscripts in Swift, enabling more flexible and intuitive access to elements within your custom types. Learners will discover how to create subscripts for reading and writing data, as well as how to use external names to differentiate between multiple subscript signatures. By the end, you'll be able to enhance your Swift types with powerful, tailored subscripting behavior.

This module explores how Swift's property observers and property wrappers can be used to monitor and manage changes in property values, enhancing code reusability and maintainability. Learners will also discover how projected values extend the functionality of property wrappers for more flexible state management.

This module explores how Swift enables dynamic access to properties and methods using dynamic member lookup and key paths. Learners will discover how these features enhance flexibility and type safety when working with data structures. Practical examples will illustrate how to implement and utilize these tools effectively in Swift programming.

This module introduces the fundamentals of Grand Central Dispatch (GCD) for managing concurrent and serial tasks in application development. Learners will explore how to create and use dispatch queues, execute code on the main queue, and schedule tasks with DispatchTime. By the end, you'll understand how to efficiently handle asynchronous operations and UI updates in your apps.

This module introduces Swift's modern concurrency features, including async/await, tasks, task groups, and global actors. Learners will explore how to coordinate multiple asynchronous operations, manage task cancellation, and adapt legacy completion handlers to the new concurrency model. By the end, you'll be able to write safer and more efficient concurrent code in Swift.

This module explores how Swift manages memory automatically and the importance of efficient resource handling in application development. Learners will investigate common pitfalls such as strong reference cycles and discover how weak references help prevent memory leaks. By the end, you'll understand key strategies to ensure your Swift applications remain robust and efficient.

This module delves into advanced operator concepts in Swift, including bitwise and overflow operators, and demonstrates how to extend operator functionality for custom types. Learners will gain hands-on experience manipulating binary data and implementing operator overloading to enhance their code's expressiveness and efficiency.

This module explores how access control mechanisms in Swift help developers manage code visibility and maintain secure, well-structured applications. Learners will discover how to set and enforce access levels, particularly with enumerations, to ensure proper encapsulation and interaction between components.

This module introduces the fundamentals of unit testing in Swift, including key testing components, new features like exit tests, and practical application through building and testing a calculator app. Learners will gain hands-on experience organizing and executing tests to improve code quality and reliability.

This module introduces the principles of object-oriented programming by guiding learners through the design and implementation of a vehicle system for a game. Learners will explore how to define object types, use enumerations, and organize collections of objects to meet specific requirements. By the end, participants will understand how to create modular and reusable code structures.

This module introduces the principles of protocol-oriented programming in Swift, highlighting how protocols can be used to define flexible and reusable code structures. Learners will explore the differences between protocol-oriented and object-oriented paradigms, implement protocol-based designs, and leverage protocol composition for modularity.

This module introduces the foundational concepts of functional programming in Swift, including higher-order functions and currying. Learners will explore how these techniques can lead to more modular, reusable, and maintainable code. By the end, you'll be able to apply functional programming principles to enhance your Swift development skills.