iOS Development: Architecture

Course details

Behind every polished iOS app is a thoughtful plan. By understanding and applying the fundamental concepts behind iOS application architecture, you can ensure that the software you develop is well-understood, flexible, and easy to extend or refactor. In this course, instructor Károly Nyisztor dives into these concepts, helping to familiarize you with the basics of iOS application architecture and design best practices.

To begin, Károly explores the Unified Modeling Language (UML), goes over some core UML diagrams, and discusses the iOS app life cycle. Next, he covers fundamental architectural design patterns such as the model-view-controller (MVC)—the classical iOS app design paradigm—as well as the Model-View-ViewModel (MVMM) pattern and other alternatives to MVC. He also shares how to manage app state transitions and build responsive apps. In addition, he discusses URL scheme-based communication and AirDrop; efficient memory and power consumption; how to detect issues and bottlenecks in your apps; and more.

Learning objectives
Unified Modeling Language (UML)
Use case, class, and sequence diagrams
App state preservation and restoration
Fundamental architectural design patterns
Model-view-controller (MVC) and model-view-presenter (MVP)
Implementing one-way binding
App stage changes
Building responsive apps
SOLID principles
Exchanging information between apps
Optimizing your apps to avoid excessive CPU usage

Concepts

0. Introduction

01 - The value in architecting your apps
02 - What you should know

1. UML Basics

03 - A brief introduction to UML
04 - The use case diagram
05 - The class diagram
06 - The sequence diagram

2. The iOS App Life Cycle

07 - The app launch sequence
08 - Walking through the launch sequence
09 - App state preservation
10 - App state restoration
11 - The main run loop
12 - Subclassing UI application

3. Fundamental Architectural Design Patterns

13 - Introduction to fundamental architectural design patterns
14 - The model-view-controller
15 - The model-view-presenter
16 - MVP example
17 - Refactoring to MVP - Model
18 - Refactoring to MVP - Presenter
19 - Refactoring to MVP - View controller
20 - The Model-View-ViewModel pattern
21 - Implementing one-way binding, part 1
22 - Implementing one-way binding, part 2

4. App State Transitions

23 - The app delegate
24 - App state changes
25 - Demo - Define the states
26 - Demo - Instrument delegate calls

5. Building Responsive Apps

27 - The main UI thread
28 - Concurrency
29 - Moving work off the main thread
30 - Custom concurrent queues
31 - Deadlocks

6. The SOLID Principles

32 - Introduction to the SOLID principles
33 - Single responsibility
34 - The open closed principle
35 - Liskov substitution
36 - Interface segregation
37 - Dependency inversion

7. Communication between Apps

38 - URL scheme-based communication
39 - Calling an app from another app
40 - URL scheme whitelist
41 - Passing parameters between apps
42 - Display the message, part 1
43 - Display the message, part 2
44 - AirDrop

8. Efficiency and Performance

45 - Respond to memory warnings via delegates
46 - Dispatch source memory pressure
47 - Optimizing for performance
48 - Analyze your app using Instruments

Conclusion

49 - Next steps