The complete course on building iOS apps with the UIKit framework
For years, The Confident iOS Professional has helped hundreds of students master the fundamentals of building iOS apps with the UIKit framework.
Even after the introduction of SwiftUI, that material remains relevant, so I include it along with the SwiftUI version. All the apps built in the past decade use UIKit, and most jobs require you to be familiar with the framework.
Here is what the UIKit version of The Confident iOS Professional contains:
Module 1
Architecture: The Fundamental Concept Nobody Talks About
What you’ll learn:
- Essential practices and the severe consequences of not following them. These concepts drive proper software development. Developers that copy and paste code from tutorials never understand these.
- Three fundamental architectural rules that guide the development of every app. Ignore them, and your code will become unmanageable.
Module 2
The Core of Every iOS App: The Model View Controller Pattern
What you’ll learn:
- Why design patterns are crucial to well-designed software and how they help you write robust apps.
- The MVC pattern, the central and most important design pattern of iOS. Ignore this, and you will constantly fight against the platform and introduce hard-to-find bugs.
- How the boundaries of MVC are blurred and which objects sit at these boundaries. Many developers think they follow the MVC pattern correctly, but they don’t.
Module 3
The Skeleton of iOS Apps: View Controllers and their Lifecycle
What you’ll learn:
- The central role of view controllers in well-written iOS apps. Getting this wrong will make your app misbehave, and you won’t understand why.
- The crucial sequence at the beginning of the lifecycle of a view controller, when it gets created, initialized, and shown on the screen.
- Common misconceptions that lead to architectural mistakes and make your code hard to change, reuse and test.
Module 4
Connecting the User Interface to Your Code: The View Hierarchy, Outlets, and the Target-Action Pattern
What you’ll learn:
- The role of views and how to create the interface of an app using Auto Layout. This forms the foundation of a dynamic user interface that works on all iOS devices.
- How views are organized in a hierarchy that makes them more manageable.
- Outlets and actions, the core mechanism to connect the interface to your code.
Module 5
How to Structure the Flow of any App: View Controller Presentation and Container View Controllers
What you’ll learn:
- How the navigation flow of iOS apps works. This allows you to use the standard transitions of iOS without having to re-invent them yourself.
- How view controllers can present other ones. This is the interaction pattern you need to interrupt the app flow when user action is required.
- How to create apps with many screens and complex flows using container view controllers. This makes the difference between a sample toy app and a real-world app.
- The available container view controllers in iOS which allow you to structure the flow of an app with many screens and different transitions.
Module 6
How View Controllers Communicate: Triggering Transitions and Preparing for Segues
What you’ll learn:
- How code gets executed when a segue is triggered and the exact moment in which you can pass data to the next view controller. Many developers miss this and use wrong patterns instead, like singletons or the app delegate.
- How to trigger transitions and pass data between view controllers even when you don’t use segues.
Module 7
The Delegate Pattern: Handing off Responsibility to Other Objects and Notifying Events
What you’ll learn:
- The next fundamental design pattern in iOS development, used by many core classes in the iOS SDK.
- The correct way to pass data backward between view controllers. Many beginners miss this and rely on other problematic approaches that create invisible architectural issues that manifest only later.
Module 8
Displaying Lists and Hierarchies: Table Views and Data Sources
What you’ll learn:
- How table views are the correct way to display long lists of elements and why other approaches lead to slow user interfaces and memory problems.
- How table views interact with delegates and data sources. Many developers are surprised when they first learn about this model of interaction.
- How to write reusable delegates and data sources. This is a common mistake that leads to bloated view controllers which contain code that should go into other classes.
Module 9
Moving backward: Unwind Segues and Passing Data to Previous View Controllers
What you’ll learn:
- Why unwind segues should not be missing from your toolbox, and why you should use them in a well-architected app even if you already know other techniques.
- The precise details behind unwind segues and how they are more complicated than other segues. Many developers fail to understand them and keep using other sub-optimal solutions.
- How you can validate data before a segue happens and even prevent it from happening. This works for any segue but is especially important when using unwind segues to validate user input.
A master tier with modules covering more advanced iOS development topics
While the core course curriculum covers all the foundations of iOS development needed for every app, the master modules include topics that are necessary for many modern iOS apps. Since these are more advanced concepts, some master modules contain more than one video lesson.
Master Module 1
Persisting Data – The Different Ways to Save Data in an iOS App
What you’ll learn:
- The technologies available in iOS to persist data and which ones you should choose. Many developers pick the wrong solution, doing a lot of unnecessary work.
- How to efficiently and safely save and read data in your app, without having to learn complicated solutions that are overkill for your app.
- The correct architectural patterns to use for storage code and avoiding the common pitfalls that cause problems in many apps. This is an important part that many developers get wrong.
Master Module 2
Connecting to the Network – Connecting to a Remote Web API and Making Requests in the Background
What you’ll learn:
- How code is executed concurrently in iOS. You need this vital concept to understand what tasks can make your app unresponsive.
- The internet protocols used in REST APIs. Knowing these fundamental internet technologies helps you when connecting your app to a remote API and troubleshooting any problems you might come across.
- How to code in your app the resources of a REST API and where to put your networking code. Many developers get this wrong and write garbled code that is hard to test and extend.
Master Module 3
Distributing and Deferring Calls – Notifications, Notification Centers, and Timers
What you’ll learn:
- How the broadcast model of iOS apps works precisely. This is an indispensable concept you need to understand to take advantage of app-wide notifications in the correct way.
- The hidden complexity notifications introduce in your app and the problems they might cause. Online tutorials never talk about this critical aspect of notifications.
- How to limit the scope of custom notifications to reduce unexpected problems. This is another cause of bugs that are hard to find and understand.
- The implications of scheduling delayed or repeated calls through timers. Miss these and you might get delayed timers or callbacks on unexpected threads.
Master Module 4
Advanced Architecture for Complex iOS Apps – Injecting Dependencies and Managing Flow with Custom Storyboards and Segues
What you’ll learn:
- The key points of the MVC pattern that create severe architectural problems in complex apps. If you don’t identify these points, you will end up with a highly coupled code that is hard to disentangle.
- How to take the critical duty of dependency injection out of view controllers, where it does not belong. Not taking care of this leads to many unused and confusing dependencies in all your view controllers.
- How conditional app flow in view controllers creates unnecessary and problematic coupling. This complicates code when you could the same more cleanly and efficiently elsewhere.
Bonus Master Module
Working Without Storyboards – Using Nib Files and Laying Out Interfaces in Code
What you’ll learn:
- The real reasons you should carefully consider when deciding whether to use nib files or code instead of storyboards. Many developers choose their options based only on personal preferences, but this is often a mistake that causes high development costs.
- The fundamental differences between UIs laid out inside storyboards, nib files or code. Each solution has hidden pitfalls you need to adequately consider, especially when you mix storyboards and nib files in the same app.
- How to manage the app flow and dependency injection when you lose access to storyboard segues. Most developers follow standard practices that are not thought-out properly and which lead to highly coupled code that is hard to maintain.
The Confident iOS Professional also includes…
Written hands-on lessons that guide you through building a complete app in Swift, with a complex flow. This example is fundamental to cement and put into practice the concepts learned in the video lessons and will teach you the mental process you have to follow when creating iOS apps
Understanding the theory is essential, but theory alone is not enough. Putting all concepts into practice is fundamental to learn how things really work in iOS.
Each module in the course contains hands-on lessons that put into practice the concepts explained in the video lessons. These lessons also explain in detail how to structure your code.
These hands-on lessons will guide you through the building of an entire app that will gradually get more and more complex. I will show you the same process I follow myself for any new app I make.
The app includes fully designed screens, and the lessons go deep into architectural concepts, showing you how to organize code is organized in a real project.
The whole app is written using Swift so that you can learn the most modern and up to date programming best practices.
These are some of the topics covered by the hands-on lessons:
Well-designed user interfaces
The foundations of Auto Layout for dynamic UIs, including stack views, guides and margins, and content hugging and compression resistance. Plus, using the asset catalog for icons, images, and global colors, and rendering custom views in Interface Builder with @IBInspectable and @IBDesignable.
Highly structured code
How to correctly structure the model of an app using structures, and the difference between value and reference types. Covering domain business logic, where to create data, how to keep the global state updated, and how to propagate it to all view controllers.
Composite navigation
Creating a complex navigation by combining containers with relationship, action and unwind segues. Including modal presentation and the interaction between the app delegate, the initial view controller, shared resources and flow coordinators.
In-depth networking
How to structure the networking layer of the app using protocol-oriented programming with Swift generics. Plus, the correct way to structure network controllers, and how to encode and decode JSON data using Swift’s Encodable and Decodable protocols.
Persistent data
Providing static data through property lists, saving data to the correct file system locations, and preserving app settings and preferences in the user defaults. Plus, architectural considerations about storage, and encoding and decoding custom types.
Static and dynamic table views
The correct way to configure dynamic table view cells with custom classes. Plus, using static table views to implement vertically scrolling interfaces, and how to adapt the UI when the system keyboard comes on screen.