A thorough exploration of SwiftUI with a focus on practicality and real-world applications. Key topics include declarative UI, data flow, animations, composition, error handling, and more. This course equips you with the skills and knowledge to harness the full potential of SwiftUI and join the UI revolution on all Apple platforms.
Chapters
View basics
Views take the center stage in SwiftUI. In this chapter, we'll explore the core principles of SwiftUI, its API, and various tools and techniques that help with the implementation, preview, and debugging of our views.
Animation
Animations are a valuable addition to any modern app, and SwiftUI provides numerous options to implement them. Let's take a look.
Composition
View composition is crucial in establishing a robust architecture. In this chapter, we'll reveal some strategies for mixing views while keeping them extendable and easy to maintain.
Typography
Typography serves as a powerful tool for crafting visually captivating and user-centered user experiences. SwiftUI has a comprehensive suite of typographic features that meet the majority of your design needs. However, there are some nuances to be aware of.
Navigation
Navigation has traditionally been a challenging aspect of SwiftUI. In fact, it was the primary reason I hesitated using SwiftUI in production on iOS 15 and earlier. Let's take a closer look at the specific challenges it involves and work together to find effective solutions.
Custom components
Custom components are the secret sauce behind unique and engaging user interfaces, where every button, view, or interaction is tailor-made to tell your app's story. However, their implementation and upkeep may present some challenges. Let's see a few strategies to improve that.
Lists
Lists are everywhere; it's quite a task to think of an app that doesn't make extensive use of them. In this chapter, we'll learn to effortlessly handle tasks such as infinite scrolling, pull-to-refresh, and craft custom lists that leave a lasting impression.
Handling external events
Whether it's responding to user input, sensor data, or data from the web, SwiftUI provides a robust and intuitive framework for managing external events. Here, we'll explore strategies for architecting our apps around these events, while avoiding becoming burdened by them.
Error boundaries
Error boundaries are an architectural pattern that allows us to gracefully manage errors occurring at any point within the view hierarchy while reducing the need for manual error handling.
Async boundaries
Async boundaries let us use Swift concurrency in various view-related event handlers without locally handling cancellation and error handling.