Skip to main content
Mapagam

69 SECTIONS · 1831 TOPICS

Ios Swift Roadmap

  1. Working with Variables and Constants

    1. 1. Declaring Variables
    2. Example: Variable Declaration
    3. 2. Declaring Constants
    4. Example: Declaring and Using Constants
    5. 3. Understanding Type Inference
    6. Example: Type Inference in Action
    7. Example: Ambiguous Type Inference
    8. 4. Using Explicit Type Annotations
    9. Example: Declaring Variables with Explicit Types
    10. 5. Working with Optionals (?, !)
    11. Example: Optional Binding
    12. Example: Nil Coalescing Operator
    13. 6. Understanding Implicitly Unwrapped Optionals (!)
    14. Example: Declaring and Using Implicitly Unwrapped Optionals
    15. 7. Using Optional Binding (if let, guard let)
    16. Example: Using if let
    17. Example: Using guard let
    18. 8. Using Optional Chaining (?.)
    19. Example: Safe Property Access
    20. Example: Method Chaining
    21. 9. Using Nil Coalescing Operator (??)
    22. Example: Safe Unwrapping with Nil Coalescing
    23. 10. Working with Tuples
    24. Example: Declaring and Using Tuples
    25. Example: Tuple with Mixed Types

  2. Working with Data Types

    1. 1. Using Integer Types
    2. Example: Integer Literal Conversion
    3. Example: Integer Type Casting
    4. 2. Using Unsigned Integer Types
    5. Example: Using UInt8 for RGB Color Components
    6. Example: Converting Int to UInt
    7. 3. Using Floating-Point Types
    8. Example: Declaring and Using Float Values
    9. Example: Declaring and Using Double Values
    10. 4. Working with Boolean
    11. Example: Boolean Operations
    12. Example: Conditional with Boolean
    13. 5. Working with Strings
    14. Example: String Interpolation
    15. Example: String Concatenation
    16. Example: Substring Access
    17. Example: String Formatting
    18. Example: Unicode and Emoji Support
    19. 6. Using Type Aliases
    20. Example: Defining and Using Type Aliases
    21. Key Points
    22. 7. Converting Between Types
    23. Example: Type Conversion in Functions
    24. 8. Checking Type Information
    25. Example: Using
    26. Example: Using
    27. Example: Safe casting with
    28. 9. Using Any and AnyObject
    29. Example: Using Any in a Collection
    30. Example: Using AnyObject with Class Instances
    31. 10. Understanding Value vs Reference Types
    32. Example: Value Type Behavior
    33. Example: Reference Type Behavior
    34. 11. Working with Numeric Literals
    35. Example: Numeric Literal Usage

  3. Working with Operators

    1. 1. Using Arithmetic Operators (+, -, *, /, %)
    2. Example: Basic Arithmetic Operations
    3. 2. Using Comparison Operators (==, !=, <, >, <=, >=)
    4. Example: Comparing Values
    5. 3. Using Logical Operators (&&, ||, !)
    6. Example: Combining Conditions
    7. Example: Negation Usage
    8. 4. Using Compound Assignment Operators (+=, -=)
    9. Example: Using Compound Assignment Operators
    10. 5. Using Ternary Conditional Operator (?:)
    11. Example: Basic Ternary Operator Usage
    12. Example: Nested Ternary Operator
    13. 6. Using Range Operators (..., ..
    14. Example: Using Range Operators in a Loop
    15. Example: Using Half-Open Range
    16. 7. Using Bitwise Operators (&, |, ^, ~)
    17. Example: Bitwise Operations
    18. 8. Using Nil-Coalescing Operator (??)
    19. 9. Using Identity Operators (===, !==)
    20. Example: Identity Operator Usage
    21. 10. Implementing Custom Operators
    22. Example: Defining a Custom Infix Operator
    23. Example: Defining a Prefix Operator

  4. Working with Strings

    1. 1. Creating Strings
    2. 2. Using String Interpolation (\())
    3. Example: Combining Multiple Values
    4. 3. Concatenating Strings
    5. 4. Accessing Characters
    6. Example: Iterating Characters
    7. Example: Character Count
    8. 5. Using String Methods
    9. 6. Modifying Strings
    10. 7. Splitting and Joining
    11. 8. Working with Substrings
    12. Example: Extracting Substrings
    13. Example: Using Substring in a Loop
    14. 9. Using String Formatting
    15. Example: String Formatting with Variables
    16. Example: Formatting Floating Point Numbers
    17. 10. Understanding Unicode and Character Sets
    18. Example: Unicode Scalar Values
    19. Example: Grapheme Clusters
    20. 11. Using Multi-line Strings
    21. Example: Multi-line String with Interpolation

  5. Working with Collections

    1. 1. Creating Arrays
    2. Example: Initializing with Values
    3. Example: Creating with Initial Values
    4. 2. Accessing Array Elements
    5. 3. Modifying Arrays
    6. 4. Iterating Arrays
    7. 5. Transforming Arrays
    8. 6. Filtering Arrays
    9. 7. Reducing Arrays (reduce)
    10. 8. Sorting Arrays
    11. 9. Creating Dictionaries
    12. Example: Creating a Dictionary with Initial Values
    13. 10. Working with Dictionary Methods
    14. 11. Creating Sets
    15. Example: Creating a Set
    16. Example: Creating an Empty Set
    17. 12. Using Set Operations

  6. Working with Control Flow

    1. 1. Using If Statements
    2. Example: Basic If Statement
    3. Example: If-Else Statement
    4. Example: If-Else If Statement
    5. 2. Using Switch Statements
    6. Example: Basic Switch
    7. Example: Range Matching
    8. Example: Tuple Matching
    9. 3. Using Pattern Matching in Switch
    10. Example: Pattern Matching with Tuples
    11. Example: Pattern Matching with Arrays
    12. 4. Using For-In Loops
    13. Example: Iterating Over an Array
    14. Example: Iterating Over a Range
    15. Example: Iterating Over a Dictionary
    16. 5. Using While Loops
    17. Example: Basic While Loop
    18. Example: Repeat-While Loop
    19. 6. Using Break and Continue
    20. Example: Using break in a loop
    21. Example: Using continue in a loop
    22. 7. Using Fallthrough in Switch
    23. Example: Fallthrough in Switch
    24. 8. Using Guard Statements
    25. Example: Basic Guard Usage
    26. Example: Guard with Multiple Conditions
    27. 9. Understanding Control Transfer
    28. Example: Using break in a loop
    29. Example: Using continue in a loop
    30. Example: Using fallthrough in switch
    31. 10. Using Labeled Statements
    32. Example: Breaking from Nested Loops
    33. Example: Continuing Nested Loops

  7. Working with Functions

    1. 1. Defining Functions
    2. Example: Function with Multiple Return Values
    3. 2. Using Function Parameters
    4. Example: Function with Multiple Parameter Types
    5. Example: Variadic Parameter Usage
    6. 3. Specifying Return Types (->)
    7. Example: Function with Return Type
    8. Example: Function Returning Optional
    9. 4. Using Default Parameter Values
    10. Example: Function with Default Parameter
    11. 5. Using Variadic Parameters (...)
    12. Example: Using Variadic Parameters
    13. Example: Variadic with Other Parameters
    14. 6. Using Inout Parameters
    15. Example: Modifying a Variable with Inout
    16. 7. Defining Function Types
    17. Example: Function Type Alias
    18. Example: Function Type as Parameter
    19. 8. Using Functions as Parameters
    20. Example: Passing a Function as a Parameter
    21. Example: Using Function Parameters in a Higher-Order Function
    22. 9. Using Functions as Return Types
    23. Example: Using Functions as Return Types
    24. 10. Creating Nested Functions
    25. Example: Using Nested Functions for Encapsulation

  8. Working with Closures

    1. 1. Understanding Closure Syntax ({ })
    2. 2. Using Trailing Closures
    3. Example: Trailing Closure with Higher-Order Functions
    4. 3. Using Shorthand Argument Names ($0, $1)
    5. 4. Understanding Capturing Values
    6. 5. Using Escaping Closures
    7. Example: Storing an Escaping Closure
    8. 6. Using Autoclosures
    9. Example: Basic Autoclosure Usage
    10. Example: Autoclosure with Default Values
    11. 7. Understanding Closure Reference Cycles
    12. Example: Retain Cycle
    13. Example: Fixing Retain Cycles with Weak References
    14. 8. Using Weak and Unowned References
    15. Example: Weak Reference in Closures
    16. Example: Unowned Reference in Closures
    17. 9. Using Map, Filter, Reduce with Closures
    18. Example: Transforming an Array with Map
    19. Example: Filtering and Reducing
    20. Example: Nested Operations with Closures
    21. 10. Creating Custom Higher-Order Functions
    22. Example: Custom Higher-Order Function

  9. Working with Enumerations

    1. 1. Defining Enumerations
    2. Example: Using Raw Values
    3. Example: Using Associated Values
    4. 2. Using Raw Values
    5. Example: Accessing Raw Values
    6. Example: Initializing from Raw Values
    7. 3. Using Associated Values
    8. Example: Defining an Enum with Associated Values
    9. Example: Using Associated Values in a Switch Statement
    10. 4. Matching Enumeration Values
    11. Example: Switch with Associated Values
    12. Example: Using if case for Optional Enum
    13. 5. Using Recursive Enumerations
    14. Example: Defining a Recursive Enum
    15. Example: Using Recursive Enum
    16. 6. Iterating Enumeration Cases
    17. 7. Adding Computed Properties
    18. Example: Using Computed Properties in an Enum
    19. 8. Adding Methods to Enumerations
    20. Example: Using Associated Values with Methods
    21. 9. Using Enum Initializers
    22. 10. Implementing Custom String Convertible
    23. Example: Implementing CustomStringConvertible

  10. Working with Structures

    1. 1. Defining Structures
    2. Example: Basic Structure Definition
    3. 2. Creating Structure Instances
    4. 3. Using Memberwise Initializers
    5. Example: Initializing a Structure with Memberwise Initializer
    6. Example: Using Default Values in Memberwise Initializer
    7. 4. Adding Computed Properties
    8. Example: Calculating Area
    9. Example: Read-Only Property
    10. 5. Adding Methods to Structures
    11. Example: Using Instance Methods
    12. Example: Using Mutating Methods
    13. 6. Using Mutating Methods
    14. Example: Mutating Method in a Structure
    15. 7. Understanding Value Semantics
    16. 8. Implementing Custom Initializers
    17. Example: Custom Initializer
    18. Example: Convenience Initializer
    19. 9. Using Static Properties and Methods
    20. Example: Using Static Properties
    21. Example: Using Static Methods
    22. 10. Conforming to Protocols
    23. Example: Conforming to Equatable
    24. Example: Conforming to Hashable
    25. Example: Conforming to Comparable

  11. Working with Classes

    1. 1. Defining Classes
    2. 2. Creating Class Instances
    3. Example: Creating Instances with Different Initializers
    4. 3. Understanding Reference Semantics
    5. Example: Reference Type Behavior
    6. Example: Value Type Behavior
    7. 4. Using Inheritance
    8. Example: Inheritance Hierarchy
    9. 5. Overriding Methods
    10. Example: Overriding a Method
    11. 6. Using Super to Access Parent
    12. Example: Calling Parent Method
    13. Example: Accessing Parent Property
    14. 7. Preventing Overrides
    15. Example: Using final to prevent subclassing
    16. Example: Using final to prevent method override
    17. 8. Using Type Properties and Methods
    18. Example: Type Properties and Methods in a Class
    19. 9. Implementing Deinitializers
    20. Example: Basic Deinitializer
    21. 10. Understanding Identity Operators (===, !==)
    22. Example: Using Identity Operators

  12. Working with Properties

    1. 1. Using Stored Properties
    2. Example: Declaring and Using Stored Properties
    3. 2. Using Lazy Stored Properties
    4. Example: Lazy Property Initialization
    5. 3. Using Computed Properties
    6. Example: Calculating Area of a Rectangle
    7. Example: Temperature Conversion
    8. 4. Using Property Observers
    9. Example: Using Property Observers
    10. 5. Understanding Property Wrappers
    11. Example: Using a Custom Property Wrapper
    12. 6. Using Built-in Wrappers
    13. Example: Using @State and @Binding
    14. Example: Using @ObservedObject and @StateObject
    15. 7. Creating Custom Property Wrappers
    16. Example: Basic Property Wrapper
    17. Example: Property Wrapper with Initialization
    18. 8. Using Type Properties
    19. Example: Accessing Type Properties
    20. 9. Understanding Property Requirements in Protocols
    21. Example: Protocol with Property Requirements
    22. 10. Using Key Paths
    23. Example: Basic Key Path Usage
    24. Example: Nested Key Path
    25. Example: Key Path with Function

  13. Working with Initializers

    1. 1. Defining Designated Initializers
    2. Example: Designated Initializer with Default Values
    3. 2. Defining Convenience Initializers
    4. Example: Defining a Convenience Initializer
    5. 3. Understanding Initialization Phases
    6. Example: Initialization Phases in a Class
    7. 4. Using Required Initializers
    8. Example: Required Initializer in a Class
    9. 5. Creating Failable Initializers
    10. Example: Failable initializer for a User model
    11. Key Points
    12. 6. Using Default Initializers
    13. Example: Default Initializer
    14. Example: NSCoder Initializer
    15. 7. Implementing Memberwise Initializers
    16. Example: Memberwise Initializer
    17. Example: Custom Memberwise Logic
    18. 8. Using Closure-Based Initialization
    19. Example: Closure-Based Initialization
    20. 9. Understanding Initializer Inheritance
    21. Example: Inheriting Initializers
    22. 10. Implementing Deinitialization
    23. Example: Basic Deinitializer

  14. Working with Protocols

    1. 1. Defining Protocols
    2. Example: Basic Protocol Definition
    3. Example: Protocol with Method Requirements
    4. 2. Using Property Requirements
    5. Example: Defining a Protocol with Property Requirements
    6. Example: Conforming to a Protocol with Property Requirements
    7. 3. Using Method Requirements
    8. Example: Protocol with Method Requirements
    9. 4. Using Initializer Requirements
    10. Example: Protocol with Required Initializer
    11. 5. Conforming to Protocols
    12. Example: Conforming to Equatable
    13. Example: Conforming to Hashable
    14. 6. Using Protocol Inheritance
    15. Example: Protocol Inheritance
    16. 7. Using Class-Only Protocols
    17. Example: Class-Only Protocol Usage
    18. 8. Using Protocol Composition (&)
    19. Example: Protocol Composition in Function Parameter
    20. 9. Using Optional Requirements
    21. Example: Defining an Optional Protocol Requirement
    22. 10. Understanding Protocol Extensions
    23. Example: Protocol Extension with Default Implementation
    24. Example: Conditional Conformance
    25. 11. Using Protocol-Oriented Programming
    26. Example: Protocol-Oriented Design
    27. Key Benefits of POP

  15. Working with Extensions

    1. 1. Adding Computed Properties
    2. Example: Adding a Computed Property to a Struct
    3. 2. Adding Methods to Existing Types
    4. Example: Adding a reverse method to String
    5. Example: Adding a sum method to Array<Int>
    6. 3. Adding Initializers via Extensions
    7. Example: Adding an initializer to a custom struct
    8. 4. Adding Nested Types
    9. Example: Using Nested Types in Extensions
    10. 5. Using Protocol Conformance Extensions
    11. Example: Protocol Extension with Default Implementation
    12. 6. Extending Generic Types
    13. Example: Extending a Generic Type with Constraints
    14. 7. Using Conditional Extensions
    15. Example: Platform-specific extension
    16. Example: Version-specific extension
    17. 8. Organizing Code with Extensions
    18. Example: Adding a Method to a Built-in Type
    19. Example: Adding a Computed Property
    20. 9. Adding Subscripts via Extensions
    21. Example: Accessing Array Elements via Extension Subscript
    22. 10. Understanding Extension Limitations

  16. Working with Generics

    1. 1. Creating Generic Functions
    2. 2. Creating Generic Types
    3. Example: Generic Stack Implementation
    4. Example: Generic Function with Constraints
    5. 3. Using Type Constraints
    6. Example: Using
    7. 4. Using Associated Types in Protocols
    8. Example: Generic Protocol with Associated Types
    9. 5. Using Generic Where Clauses
    10. Example: Protocol Conformance with Where Clause
    11. Example: Collection with Element Constraints
    12. 6. Creating Generic Subscripts
    13. Example: Generic Subscript in a Dictionary
    14. 7. Understanding Type Erasure
    15. Example: Using Any and Type Erasure
    16. Key Points
    17. 8. Using Opaque Types
    18. Example: Returning Opaque Types
    19. 9. Understanding Generic Specialization
    20. Example: Generic Function Specialization
    21. Key Points of Generic Specialization
    22. 10. Working with Collection Generics
    23. Example: Using Generic Collections

  17. Handling Errors

    1. 1. Defining Error Types
    2. Example: Custom Error Type
    3. Example: Error with Associated Values
    4. 2. Throwing Errors
    5. Example: Throwing Errors in a Function
    6. 3. Using Throwing Functions
    7. Example: Using Throwing Functions
    8. 4. Catching Errors
    9. Example: Throwing and Catching Errors
    10. 5. Converting Errors to Optionals
    11. 6. Disabling Error Propagation
    12. 7. Using Defer for Cleanup
    13. Example: Resource Management with defer
    14. Key Points
    15. 8. Creating Custom Error Types
    16. Example: Custom Error with Associated Values
    17. Example: Throwing and Catching Custom Errors
    18. 9. Rethrowing Functions
    19. Example: Rethrowing a Thrown Error
    20. Example: Using Rethrowing in Higher-Order Functions
    21. 10. Understanding Error Propagation Patterns
    22. Example: Throw and Catch
    23. Example: Result Type

  18. Working with Result Type

    1. 1. Understanding Result Type
    2. Example: Basic Result Usage
    3. 2. Creating Result Values
    4. 3. Unwrapping Result with Switch
    5. Example: Unwrapping Result with Switch
    6. 4. Using get() Method
    7. Example: Using get() on a Result
    8. 5. Using map and flatMap on Result
    9. 6. Converting Throwing Functions to Result
    10. Example: Converting Throwing Function to Result
    11. 7. Using mapError for Error Transformation
    12. Example: Transforming Error Types
    13. Example: Adding Context to Errors
    14. 8. Combining Result with async/await
    15. Example: Using Result with async/await
    16. 9. Implementing Custom Result Extensions
    17. Example: Using flatMap to Chain Operations
    18. Example: Safe Error Handling with get()
    19. 10. Handling Network Responses with Result
    20. Example: Using Result in Network Call
    21. Best Practices for Result Usage

  19. Working with Memory Management

    1. 1. Understanding Automatic Reference Counting
    2. Example: Strong Reference Cycle
    3. Example: Using Weak to Break Cycle
    4. 2. Using Strong References
    5. Example: Strong Reference in Action
    6. 3. Using Weak References
    7. Example: Preventing retain cycles with weak references
    8. 4. Using Unowned References
    9. Example: Using Unowned References
    10. 5. Resolving Strong Reference Cycles
    11. Example: Resolving Strong Reference Cycle with
    12. 6. Using Capture Lists in Closures
    13. Example: Using Weak Capture List
    14. Example: Using Unowned Capture List
    15. 7. Understanding Reference Cycles in Delegates
    16. Example: Reference Cycle in Delegate
    17. How to Prevent Reference Cycles
    18. 8. Using Value Types to Avoid Cycles
    19. Example: Using a struct to avoid retain cycles
    20. 9. Monitoring Memory Usage
    21. Example: Measuring Memory Size of a Struct
    22. Example: Monitoring Memory in a Loop
    23. Memory Monitoring Tips
    24. 10. Understanding Copy-on-Write
    25. Example: COW in Action
    26. Key Points

  20. Working with Delegation Pattern

    1. 1. Defining Delegate Protocols
    2. Example: Defining a Custom Delegate Protocol
    3. 2. Creating Weak Delegate Properties
    4. Example: Setting up a weak delegate property
    5. 3. Implementing Delegate Methods
    6. Example: Implementing a Table View Delegate Method
    7. Example: Implementing a Text Field Delegate Method
    8. 4. Using Optional Delegate Methods
    9. Example: Implementing Optional Delegate Method
    10. 5. Understanding Delegate Pattern Benefits
    11. 6. Using Multiple Delegates
    12. Example: Implementing Multiple Delegates
    13. 7. Implementing Common Delegates
    14. Example: Implementing UITableView Delegate
    15. Example: Implementing UITextField Delegate
    16. 8. Avoiding Retain Cycles with Delegates
    17. Example: Using
    18. 9. Using Closures vs Delegates
    19. Example: Closure Usage
    20. Example: Delegate Usage
    21. When to Use Which?
    22. 10. Implementing Protocol Witnesses
    23. Example: Implementing UITableViewDataSource

  21. Working with Notifications

    1. 1. Using NotificationCenter
    2. Example: Posting a Notification
    3. Example: Observing a Notification
    4. 2. Registering Observers
    5. Example: Registering a Notification Observer
    6. 3. Posting Notifications
    7. Example: Posting a Local Notification
    8. 4. Removing Observers
    9. Example: Removing All Observers
    10. Example: Removing Specific Observer
    11. 5. Passing Data with Notifications
    12. Example: Posting a Notification with Data
    13. Example: Receiving Notification Data
    14. 6. Using Local Notifications
    15. Example: Schedule a Local Notification
    16. Example: Handle Notification Response
    17. 7. Scheduling Local Notifications
    18. Example: Schedule a Local Notification
    19. 8. Handling Notification Actions
    20. Example: Registering Notification Categories
    21. Example: Handling Notification Action Responses
    22. 9. Requesting Notification Permissions
    23. Permission Summary
    24. 10. Using Push Notifications
    25. Example: Requesting Push Notification Permissions
    26. Example: Scheduling a Push Notification
    27. 11. Handling Remote Notifications
    28. Example: Receiving Remote Notification
    29. Example: Handling Notification Response

  22. Working with Modern Concurrency

    1. 1. Using async/await Keywords
    2. Example: Basic async/await usage
    3. Example: Concurrent execution with Task
    4. 2. Defining Async Functions
    5. Example: Defining an Async Function
    6. 3. Using Task and Task Groups
    7. Task Lifecycle
    8. 4. Understanding Structured Concurrency
    9. Example: Basic Task Creation
    10. Example: Using TaskGroup
    11. 5. Using Async Sequences
    12. Example: Creating and Using AsyncStream
    13. Example: Using AsyncSequence with for-await-in Loop
    14. 6. Using Async Streams
    15. Example: Creating and Consuming an Async Stream
    16. Key Points
    17. 7. Implementing Actors
    18. Example: Basic Actor Implementation
    19. Example: Actor with Async Methods
    20. 8. Using MainActor for UI Updates
    21. Example: Updating UI on MainActor
    22. 9. Understanding Sendable Protocol
    23. Example: Sendable Protocol Usage
    24. 10. Handling Cancellation
    25. Example: Canceling a Task
    26. Example: Using withTaskCancellationHandler
    27. 11. Using Continuation
    28. Example: Using Continuation to Wrap Async Operation
    29. 12. Using Task Priorities
    30. Example: Setting Task Priority

  23. Working with Grand Central Dispatch

    1. 1. Understanding Dispatch Queues
    2. Example: Creating and Using Dispatch Queues
    3. Key Points
    4. 2. Using Main Queue
    5. Example: Updating UI on Main Queue
    6. 3. Using Global Queues
    7. Example: Dispatching to Main Queue
    8. Example: Dispatching to Background Queue
    9. 4. Creating Custom Queues
    10. Example: Creating a Custom Serial Queue
    11. Example: Creating a Custom Concurrent Queue
    12. 5. Using Sync vs Async Dispatch
    13. Example: Sync vs Async Dispatch
    14. Key Differences
    15. 6. Using Serial vs Concurrent Queues
    16. Example: Serial Queue Usage
    17. Example: Concurrent Queue Usage
    18. Serial vs Concurrent Queue Comparison
    19. 7. Understanding Quality of Service
    20. Example: Setting QoS for a Background Task
    21. 8. Using Dispatch Groups
    22. Example: Using Dispatch Group to Wait for Multiple Network Requests
    23. Key Points
    24. 9. Using Dispatch Barriers
    25. Example: Using dispatch_barrier_async
    26. Example: Using dispatch_barrier_sync
    27. 10. Using Dispatch Semaphores
    28. Example: Using Dispatch Semaphores to Limit Concurrent Operations
    29. 11. Using Dispatch Work Items
    30. Example: Creating and Executing a DispatchWorkItem
    31. Example: Using Work Item with QoS

  24. Working with Combine Framework

    1. 1. Understanding Publishers and Subscribers
    2. Example: Basic Publisher and Subscriber Setup
    3. 2. Creating Publishers
    4. Example: Creating a simple publisher from a value
    5. 3. Using CurrentValueSubject
    6. Example: Creating and Using CurrentValueSubject
    7. 4. Subscribing with sink and assign
    8. Example: Using
    9. Example: Using
    10. 5. Using Operators
    11. Example: Transforming Values with
    12. Example: Combining Publishers with
    13. Example: Combining Publishers with
    14. 6. Combining Publishers
    15. Example: Merging Publishers
    16. Example: Combining Latest Values
    17. 7. Handling Errors in Combine
    18. Example: Catching Errors in Combine
    19. 8. Managing Subscriptions
    20. Example: Basic Subscription Management
    21. 9. Using Schedulers
    22. Example: Configuring a Scheduler
    23. Key Points
    24. 10. Integrating Combine with SwiftUI
    25. Example: Binding to a Published Property
    26. Example: Handling Asynchronous Events

  25. Working with App Lifecycle

    1. 1. Understanding App States
    2. Example: App State Transition Handling
    3. 2. Implementing App Delegate Methods
    4. Example: Implementing App Delegate Methods
    5. 3. Using Scene Delegates
    6. Example: Scene Delegate Implementation
    7. 4. Handling App Launch
    8. Example: App Launch Configuration
    9. 5. Handling App Termination
    10. Example: App Termination Handler
    11. 6. Managing Background Tasks
    12. Example: Requesting Background Task
    13. Example: Handling Background Task
    14. 7. Using Background Fetch
    15. Example: Configure Background Fetch
    16. 8. Using Background URLSessions
    17. Example: Creating a Background URLSession
    18. Example: Handling Background Session Events
    19. 9. Implementing State Restoration
    20. Example: Enabling State Restoration
    21. Example: Implementing UIStateRestoring
    22. 10. Monitoring Memory Warnings
    23. Example: Handling Memory Warnings in a View Controller

  26. Building User Interfaces with UIKit

    1. 1. Creating Views
    2. Example: Creating a Custom View
    3. Example: Adding a Subview
    4. 2. Working with Frames and Bounds
    5. Example: Setting Frame and Bounds
    6. 3. Using UILabel for Text Display
    7. Example: Basic UILabel Usage
    8. Example: Dynamic Text Update
    9. 4. Using UIButton for Actions
    10. Example: Basic Button with Action
    11. Example: Button with Custom Background
    12. 5. Working with UIImageView
    13. Example: Setting an Image
    14. Example: Handling Image Highlighting
    15. Content Mode Options
    16. 6. Using UITextField for Input
    17. Example: Basic UITextField Usage
    18. Example: Handling Text Changes
    19. 7. Using UITextView for Multiline Text
    20. Example: Basic UITextView Setup
    21. Example: UITextView with Text Selection
    22. 8. Working with UIScrollView
    23. Example: Basic UIScrollView Setup
    24. Example: Adding Content to UIScrollView
    25. 9. Using UITableView for Lists
    26. Example: Basic UITableView Setup
    27. Example: Custom Cell with Image
    28. Key Points
    29. 10. Using UICollectionView for Grids
    30. Example: Basic UICollectionView Setup
    31. Example: Custom UICollectionViewFlowLayout
    32. Key Features of UICollectionView Grids
    33. 11. Working with UIStackView
    34. Example: Creating a Horizontal Stack View
    35. Example: Adding Subviews to a Stack View
    36. Key Features of UIStackView
    37. 12. Understanding Responder Chain
    38. Example: Traversing the Responder Chain

  27. Working with View Controllers

    1. 1. Creating View Controllers
    2. 2. Understanding View Lifecycle Methods
    3. Example: Using viewDidLoad to set up a view controller
    4. 3. Using viewDidLoad for Setup
    5. Example: Setting up UI in viewDidLoad
    6. 4. Using viewWillAppear and viewDidAppear
    7. Example: Using viewWillAppear and viewDidAppear
    8. 5. Using viewWillDisappear and viewDidDisappear
    9. Example: Managing view lifecycle
    10. 6. Managing View Hierarchy
    11. Example: Adding a Child View Controller
    12. Example: Removing a Child View Controller
    13. 7. Working with Navigation Controllers
    14. Example: Pushing a View Controller onto Navigation Stack
    15. Example: Setting Navigation Bar Title
    16. Example: Customizing Navigation Bar Appearance
    17. Navigation Controller Workflow
    18. 8. Using Tab Bar Controllers
    19. Example: Setting up a Tab Bar Controller
    20. Key Features of Tab Bar Controllers
    21. 9. Implementing Modal Presentations
    22. Example: Presenting a Modal View Controller
    23. Example: Dismissing a Modal View Controller
    24. 10. Using Container View Controllers
    25. Example: Adding a Child View Controller
    26. Example: Removing a Child View Controller
    27. Container View Controller Types
    28. 11. Understanding View Controller Transitions
    29. Example: Presenting a Modal View Controller
    30. Example: Pushing a View Controller

  28. Working with Auto Layout

    1. 1. Creating Constraints Programmatically
    2. Example: Creating a Simple Constraint
    3. Example: Setting Width and Height Constraints
    4. 2. Using NSLayoutConstraint
    5. Example: Creating a Basic Constraint
    6. Example: Using Constraint with Priority
    7. 3. Using Layout Anchors
    8. Example: Basic Layout Anchor Usage
    9. Example: Centering a View with Layout Anchors
    10. Example: Setting Width and Height Constraints
    11. Example: Using Layout Anchors with Safe Area
    12. 4. Setting Constraint Priorities
    13. Example: Setting Constraint Priority
    14. 5. Using Visual Format Language
    15. Example: Basic Horizontal Layout
    16. Example: Vertical Layout with Spacing
    17. Example: Complex Layout with Metrics
    18. 6. Understanding Intrinsic Content Size
    19. Example: Custom View with Intrinsic Content Size
    20. 7. Using Constraint Compression and Hugging
    21. Example: Setting Hugging and Compression Resistance
    22. Key Concepts
    23. 8. Activating and Deactivating Constraints
    24. Example: Activating and Deactivating Constraints
    25. 9. Animating Constraint Changes
    26. Example: Animating a View's Width Constraint
    27. Example: Using Layout Animator
    28. 10. Debugging Layout Issues
    29. Example: Using the View Debugger
    30. Workflow: Debugging Layout in Xcode
    31. 11. Using Safe Area Layout Guide
    32. Example: Using Safe Area Layout Guide in Constraints

  29. Working with Tables and Lists

    1. 1. Creating UITableView
    2. Example: Basic UITableView Setup
    3. 2. Implementing UITableViewDataSource
    4. Example: Implementing UITableViewDataSource
    5. 3. Implementing UITableViewDelegate
    6. Example: Implementing tableView(_:didSelectRowAt:)
    7. Example: Implementing tableView(_:cellForRowAt:)
    8. 4. Registering Custom Cells
    9. Example: Registering Custom Cell Class
    10. Example: Registering Custom Cell from Nib
    11. 5. Dequeuing Reusable Cells
    12. Example: Dequeuing a Reusable Cell
    13. 6. Implementing Cell Selection
    14. Example: Selecting a Cell
    15. Example: Deselecting a Cell
    16. 7. Using Section Headers and Footers
    17. Example: Adding Section Headers and Footers
    18. 8. Implementing Editing Mode
    19. Example: Enabling Editing Mode
    20. Example: Customizing Editing Behavior
    21. Editing Mode Workflow
    22. 9. Reordering Table Rows
    23. Example: Reordering Table Rows
    24. 10. Using Self-Sizing Cells
    25. Example: Configuring Self-Sizing Cells
    26. Example: Cell Configuration with Auto Layout
    27. 11. Implementing Pull-to-Refresh
    28. Example: Basic Pull-to-Refresh Implementation

  30. Working with Collection Views

    1. 1. Creating UICollectionView
    2. Example: Basic UICollectionView Setup
    3. 2. Implementing UICollectionViewDataSource
    4. Example: Basic UICollectionViewDataSource Implementation
    5. 3. Implementing UICollectionViewDelegate
    6. Example: Handling Cell Selection
    7. Example: Customizing Highlight Behavior
    8. 4. Creating Custom Collection View Layouts
    9. Example: Basic Custom Layout Class
    10. Key Points
    11. 5. Using UICollectionViewFlowLayout
    12. Example: Setting up UICollectionViewFlowLayout
    13. 6. Configuring Item Size and Spacing
    14. Example: Setting Item Size and Spacing
    15. 7. Implementing Section Insets
    16. Example: Setting Section Insets
    17. 8. Using Supplementary Views
    18. Example: Registering and Using a Header View
    19. 9. Implementing Cell Selection
    20. Example: Selecting a Cell
    21. Example: Deselecting a Cell
    22. 10. Using Compositional Layout
    23. Example: Creating a Compositional Layout
    24. 11. Implementing Diffable Data Source
    25. Example: Setting up Diffable Data Source
    26. Key Features

  31. Handling User Input and Gestures

    1. 1. Using UITapGestureRecognizer
    2. Example: Basic Tap Gesture Setup
    3. Example: Multi-Tap Gesture
    4. 2. Using UISwipeGestureRecognizer
    5. Example: Basic Swipe Gesture
    6. Example: Multi-Finger Swipe
    7. 3. Using UIPanGestureRecognizer
    8. Example: Basic Pan Gesture Setup
    9. Example: Pan Gesture with Velocity
    10. 4. Using UIPinchGestureRecognizer
    11. Example: Setting up a UIPinchGestureRecognizer
    12. 5. Using UIRotationGestureRecognizer
    13. Example: Detecting Rotation Gesture
    14. 6. Using UILongPressGestureRecognizer
    15. Example: Setting up a long press gesture recognizer
    16. 7. Implementing Custom Gesture Recognizers
    17. Example: Custom Tap Gesture Recognizer
    18. 8. Handling Touch Events
    19. Example: Detecting Touch Location
    20. 9. Understanding Gesture Recognizer States
    21. Example: Handling State Changes
    22. 10. Combining Multiple Gestures
    23. Example: Combining Tap and Long Press Gestures
    24. Best Practices for Gesture Combination

  32. Working with Navigation

    1. 1. Using UINavigationController
    2. Example: Pushing a View Controller
    3. Example: Setting Navigation Title
    4. Example: Customizing Navigation Bar
    5. 2. Pushing and Popping View Controllers
    6. Example: Pushing a View Controller
    7. Example: Popping a View Controller
    8. 3. Customizing Navigation Bar
    9. Example: Setting Navigation Bar Background Color
    10. Example: Customizing Title Text Attributes
    11. 4. Using Navigation Bar Items
    12. Example: Adding Navigation Bar Items
    13. 5. Implementing Custom Back Button
    14. Example: Custom Back Button Title
    15. Example: Custom Back Button Image
    16. 6. Using Large Titles
    17. Example: Enabling Large Titles
    18. Key Points
    19. 7. Hiding Navigation Bar
    20. Example: Hide Navigation Bar
    21. Example: Show Navigation Bar
    22. 8. Implementing Navigation Delegates
    23. Example: Implementing Navigation Delegate
    24. 9. Using Segues in Storyboards
    25. Example: Creating a Show Segue
    26. 10. Passing Data Between View Controllers
    27. Example: Using Segue to Pass Data
    28. Example: Using Closure for Data Return

  33. Working with UIKit Animations

    1. 1. Using UIView.animate Methods
    2. Example: Basic UIView Animation
    3. Example: UIView Animation with Options
    4. 2. Animating View Properties
    5. Example: Animating Alpha Property
    6. Example: Animating Frame Property
    7. Example: Animating Transform Property
    8. 3. Using Animation Curves
    9. Example: Custom Animation Curve
    10. 4. Chaining Animations
    11. Example: Sequential Animation Chain
    12. 5. Using Spring Animations
    13. Example: Spring Animation
    14. 6. Using Keyframe Animations
    15. Example: Basic Keyframe Animation
    16. Example: Keyframe Animation with Rotation
    17. 7. Animating Constraints
    18. Example: Animating Constraint Changes
    19. Key Points
    20. 8. Using UIViewPropertyAnimator
    21. Example: Basic UIViewPropertyAnimator Usage
    22. Example: Controlling Animation Progress
    23. Example: Reversing Animation
    24. 9. Creating Custom Transitions
    25. Example: Custom Transition with UIViewControllerAnimatedTransitioning
    26. Key Steps to Implement Custom Transitions
    27. 10. Using Core Animation
    28. Example: Basic Core Animation
    29. Example: Keyframe Animation
    30. Core Animation Overview

  34. Building Declarative UIs with SwiftUI

    1. 1. Creating SwiftUI Views
    2. Example: Basic Text View
    3. Example: Button with Action
    4. 2. Using Text and Label Views
    5. Example: Basic Text Usage
    6. Example: Dynamic Text with Binding
    7. Example: Label with System Image
    8. 3. Using Button and Toggle
    9. Example: Basic Button
    10. Example: Toggle with Binding
    11. Example: Button with Image
    12. 4. Working with Image Views
    13. Example: Displaying an Image from Asset Catalog
    14. Example: Using SF Symbols
    15. Example: Resizing and Cropping Images
    16. 5. Using VStack, HStack, ZStack
    17. Example: VStack Usage
    18. Example: HStack Usage
    19. Example: ZStack Usage
    20. 6. Using List and ForEach
    21. Example: Basic List
    22. Example: ForEach with Custom Data
    23. Example: ForEach with Nested Views
    24. 7. Working with ScrollView
    25. Example: Basic ScrollView with Text
    26. Example: Horizontal ScrollView
    27. 8. Using NavigationStack and NavigationLink
    28. Example: Basic NavigationStack with NavigationLink
    29. Example: Navigation with Data
    30. 9. Using TabView for Navigation
    31. Example: Basic TabView Implementation
    32. Example: TabView with Nested Navigation
    33. 10. Applying View Modifiers
    34. Example: Combining Modifiers
    35. 11. Understanding View Composition
    36. Example: Composing a Simple UI
    37. Key Concepts of View Composition

  35. Managing SwiftUI State

    1. 1. Using @State for Local State
    2. Example: Declaring and Using @State
    3. 2. Using @Binding for Two-Way Binding
    4. Example: Two-Way Binding with @Binding
    5. 3. Using @ObservedObject for External Objects
    6. Example: Using @ObservedObject in a View
    7. 4. Using @StateObject for Owned Objects
    8. Example: Using @StateObject
    9. 5. Using @EnvironmentObject for Shared State
    10. Example: Setting up and Using @EnvironmentObject
    11. Key Points
    12. 6. Using @Environment for System Values
    13. Example: Accessing System Values
    14. Example: Using Environment in a Child View
    15. 7. Understanding @Published Properties
    16. Example: Using @Published in a Model
    17. 8. Implementing ObservableObject Protocol
    18. Example: Basic ObservableObject Implementation
    19. Example: Using ObservableObject in SwiftUI View
    20. 9. Using @AppStorage for UserDefaults
    21. Example: Storing and Retrieving User Preferences
    22. 10. Understanding State Management Patterns
    23. Example: Using ObservableObject

  36. Using SwiftUI Observation Framework

    1. 1. Using @Observable Macro
    2. Example: Basic Usage of @Observable
    3. 2. Understanding Observation vs Combine
    4. Key Differences Summary
    5. Example: Using @State in SwiftUI (Observation)
    6. Example: Using Combine Publisher (Combine)
    7. 3. Using @Bindable for Two-Way Binding
    8. Example: Using @Bindable
    9. 4. Migrating from ObservableObject
    10. ObservableObject vs @Observable
    11. Example: Migration from ObservableObject to @Observable
    12. Example: Updated with @Observable
    13. 5. Using withObservationTracking
    14. Example: Using withObservationTracking
    15. 6. Understanding Observation Dependencies
    16. 7. Combining Observation with SwiftUI
    17. Example: Using @ObservedObject in SwiftUI
    18. Example: Using @StateObject
    19. Comparison: @ObservedObject vs @StateObject
    20. 8. Working with Optional Observations
    21. Example: Using Optional Observations
    22. 9. Using @ObservationIgnored Property
    23. Example: Using @ObservationIgnored
    24. 10. Optimizing Observation Performance
    25. Example: Using @StateObject for Performance
    26. Example: Using @ObservedObject for Performance

  37. Working with SwiftUI Forms and Input

    1. 1. Creating Forms
    2. Example: Basic Form Structure
    3. 2. Using TextField for Text Input
    4. Example: Basic TextField Usage
    5. Example: TextField with Submission Handling
    6. Example: TextField with Validation
    7. 3. Using SecureField for Passwords
    8. Example: SecureField in a Form
    9. 4. Using Picker for Selection
    10. Example: Basic Picker Usage
    11. Example: Picker with Custom Labels
    12. 5. Using DatePicker for Dates
    13. Example: Basic DatePicker Usage
    14. Example: DatePicker with Time
    15. Example: DatePicker with Date Range
    16. 6. Using Stepper for Increments
    17. Example: Basic Stepper Usage
    18. Example: Stepper with Custom Increment
    19. 7. Using Slider for Ranges
    20. Example: Basic Slider Usage
    21. Example: Slider with Step
    22. 8. Using Toggle for Boolean Values
    23. Example: Basic Toggle Usage
    24. Example: Toggle with Custom Label
    25. 9. Using ColorPicker for Colors
    26. Example: Basic ColorPicker Usage
    27. 10. Implementing Form Validation
    28. Example: Basic Form Validation
    29. Example: Custom Validation Rule

  38. Working with SwiftUI Grids and Layouts

    1. 1. Using LazyVGrid for Vertical Grids
    2. Example: Basic LazyVGrid
    3. Example: Grid with Fixed Columns
    4. 2. Using LazyHGrid for Horizontal Grids
    5. Example: Basic LazyHGrid
    6. 3. Configuring Grid Items
    7. Example: GridItem with Fixed Size
    8. Example: Adaptive Grid Item
    9. 4. Using fixed, flexible, and adaptive Sizing
    10. Example: Combining Sizing Types
    11. 5. Working with GeometryReader
    12. Example: Using GeometryReader to get view size
    13. 6. Using ViewThatFits for Adaptive Layouts
    14. Example: Basic Usage of ViewThatFits
    15. Key Features
    16. 7. Using Layout Protocol
    17. Example: Implementing Custom Layout
    18. 8. Using ContainerRelativeFrame
    19. Example: Basic ContainerRelativeFrame Usage
    20. 9. Understanding Layout Priorities
    21. Example: Using Layout Priorities
    22. 10. Building Responsive Layouts
    23. Example: Responsive Grid with HStack and VStack
    24. Example: Lazy Grid with ScrollView
    25. Responsive Layout Tips

  39. Working with SwiftUI Shapes and Paths

    1. 1. Using Built-in Shapes
    2. Example: Using Circle and Rectangle
    3. Example: Using RoundedRectangle and Capsule
    4. 2. Using RoundedRectangle and Capsule
    5. Example: Creating a RoundedRectangle
    6. Example: Creating a Capsule
    7. 3. Creating Custom Shapes
    8. Example: Creating a Custom Triangle Shape
    9. Example: Using the Custom Shape in a View
    10. 4. Drawing Paths
    11. Example: Creating a Custom Path
    12. Example: Using Path with Modifier
    13. 5. Using Stroke and Fill Modifiers
    14. Example: Stroke and Fill
    15. Example: StrokeBorder
    16. 6. Animating Shape Changes
    17. Example: Basic Shape Animation
    18. Example: Shape Transition
    19. 7. Using ShapeStyle
    20. Example: Applying a ShapeStyle to a Rectangle
    21. Example: Using Gradient ShapeStyle
    22. 8. Clipping Views with Shapes
    23. Example: Clipping to a Circle
    24. 9. Using Canvas for Drawing
    25. Example: Basic Canvas Drawing
    26. Example: Drawing with Gradient
    27. 10. Creating Complex Path Operations
    28. Example: Combining Multiple Paths
    29. Example: Using Path with Custom Shape

  40. Working with SwiftUI Charts

    1. 1. Creating Bar Charts
    2. Example: Basic Bar Chart
    3. Example: Bar Chart with Labels
    4. 2. Creating Line Charts
    5. Example: Basic Line Chart
    6. Example: Line Chart with Multiple Series
    7. 3. Creating Point Charts
    8. Example: Basic Point Chart
    9. 4. Creating Area Charts
    10. Example: Basic Area Chart
    11. Example: Customized Area Chart
    12. 5. Creating Rule Charts
    13. Example: Basic Rule Chart
    14. 6. Customizing Chart Axes
    15. Example: Customizing Chart Axes
    16. 7. Adding Chart Legends
    17. Example: Adding a Chart Legend
    18. 8. Using Chart Annotations
    19. Example: Line Annotation in Chart
    20. Example: Text Annotation in Chart
    21. 9. Implementing Interactive Charts
    22. Example: Basic Interactive Chart
    23. Example: Chart with Interactive Selection
    24. Key Features of Interactive Charts
    25. 10. Styling Charts with Modifiers
    26. Example: Applying Chart Modifiers

  41. Working with SwiftUI Animations

    1. 1. Using withAnimation Function
    2. Example: Basic withAnimation Usage
    3. Example: Custom Animation
    4. 2. Applying .animation Modifier
    5. Example: Basic Animation
    6. Example: Animation with Custom Timing
    7. 3. Using Animation Types
    8. Example: Applying Different Animations
    9. Example: Spring Animation
    10. 4. Creating Custom Timing Curves
    11. Example: Using Custom Timing Curve
    12. 5. Using Matched Geometry Effect
    13. Example: Basic Matched Geometry Effect
    14. Key Points
    15. 6. Implementing Transitions
    16. Example: Using .transition with .opacity
    17. Example: Combining .transition and .animation
    18. 7. Combining Multiple Animations
    19. Example: Sequential and Parallel Animations
    20. Example: Using
    21. 8. Using Phase Animator
    22. Example: Basic Phase Animator Usage
    23. 9. Using Keyframe Animator
    24. Example: Basic Keyframe Animation
    25. Example: Keyframe with Custom Timing
    26. 10. Creating Animation Sequences
    27. Example: Basic Animation Sequence
    28. Example: Sequential Animation

  42. Working with Images and Graphics

    1. 1. Loading Images
    2. Example: Loading an Image from Bundle
    3. 2. Using SF Symbols
    4. Example: Using SF Symbols in UI
    5. 3. Resizing Images
    6. Example: Resize Image to Fit Within Bounds
    7. 4. Cropping Images
    8. Example: Cropping a UIImage
    9. 5. Applying Image Filters
    10. Example: Applying a Blur Filter
    11. 6. Drawing with Core Graphics
    12. Example: Basic Drawing Context
    13. 7. Using UIGraphicsImageRenderer
    14. Example: Creating a Simple Image with UIGraphicsImageRenderer
    15. Key Features of UIGraphicsImageRenderer
    16. 8. Creating Custom Drawing in UIView
    17. Example: Custom Drawing in UIView
    18. 9. Working with Image Assets
    19. Example: Adding an Image Asset to Xcode
    20. Image Asset Best Practices
    21. 10. Supporting Dark Mode Images
    22. Example: Using Image Assets for Dark Mode
    23. 11. Handling Image Caching
    24. Example: Basic Image Caching with NSCache

  43. Working with Camera and Photos

    1. 1. Using UIImagePickerController
    2. Example: Presenting UIImagePickerController
    3. 2. Accessing Camera
    4. Example: Request Camera Permission
    5. Example: List Available Cameras
    6. 3. Accessing Photo Library
    7. Example: Requesting Photo Library Permission
    8. Example: Fetching Photos
    9. 4. Using AVCaptureSession for Custom Camera
    10. Example: Setting up AVCaptureSession
    11. Key Steps
    12. 5. Capturing Photos with AVCapturePhotoOutput
    13. Example: Setting up photo capture
    14. 6. Recording Videos with AVCaptureMovieFileOutput
    15. Example: Recording Video
    16. Key Points
    17. 7. Implementing Camera Permissions
    18. Example: Requesting Camera Permission
    19. 8. Using PHPhotoLibrary for Photo Access
    20. Example: Requesting Photo Library Permissions
    21. Example: Fetching Photos from Library
    22. Example: Saving Photo to Library
    23. 9. Saving Images to Photo Library
    24. Example: Saving an Image to Photo Library
    25. 10. Fetching Photos with PHAsset
    26. Example: Fetching a Photo Asset
    27. Example: Fetching Multiple Assets
    28. 11. Using Live Photos (PHLivePhoto)
    29. Example: Requesting a Live Photo

  44. Working with Media Playback

    1. 1. Using AVPlayer for Video Playback
    2. Example: Initialize AVPlayer with a video URL
    3. Example: Play video using AVPlayerLayer
    4. Example: Handle playback state changes
    5. 2. Using AVPlayerViewController
    6. Example: Basic AVPlayerViewController Setup
    7. 3. Controlling Playback
    8. Example: Controlling Playback
    9. 4. Observing Playback State
    10. Example: Observing Playback State Changes
    11. 5. Playing Audio with AVAudioPlayer
    12. Example: Initialize and Play Audio
    13. Example: Set Volume and Rate
    14. 6. Using AVAudioSession for Audio Configuration
    15. Example: Setting up AVAudioSession
    16. 7. Implementing Background Audio Playback
    17. Example: Setting up background audio session
    18. Example: Handling audio session interruption
    19. 8. Handling Audio Interruptions
    20. Example: Handling Audio Interruptions
    21. 9. Using Media Player Framework
    22. Example: Play Media Using AVPlayer
    23. Example: Display Media in ViewController
    24. 10. Accessing Music Library with MPMediaQuery
    25. Example: Fetching Songs from Library
    26. 11. Implementing Now Playing Info
    27. Example: Setting Up Now Playing Info

  45. Working with Haptic Feedback

    1. 1. Using UIImpactFeedbackGenerator
    2. Example: Triggering Impact Feedback
    3. 2. Using UISelectionFeedbackGenerator
    4. 3. Using UINotificationFeedbackGenerator
    5. Example: Triggering Notification Feedback
    6. 4. Preparing Haptic Generators
    7. Example: Initializing a Haptic Generator
    8. 5. Choosing Feedback Intensity
    9. 6. Using Core Haptics
    10. Example: Initializing Core Haptics Engine
    11. Example: Playing a Simple Haptic
    12. Example: Creating a Custom Haptic Pattern
    13. 7. Creating Custom Haptic Patterns
    14. Example: Creating a Custom Haptic Pattern
    15. 8. Synchronizing Haptics with Audio
    16. Example: Synchronizing Haptic and Audio Playback
    17. Best Practices for Synchronizing Haptics with Audio
    18. 9. Testing Haptic Feedback
    19. Example: Triggering Haptic Feedback
    20. Testing Guidelines
    21. 10. Understanding Haptic Guidelines
    22. Comparison: Haptic vs Visual Feedback
    23. Best Practices Summary

  46. Working with Location Services

    1. 1. Using CLLocationManager
    2. Example: Requesting Location Permissions
    3. 2. Requesting Location Permissions
    4. Example: Requesting Location Permission
    5. 3. Getting Current Location
    6. Example: Requesting Location Permission
    7. 4. Monitoring Significant Location Changes
    8. Example: Start Monitoring Significant Location Changes
    9. Key Points
    10. 5. Using Region Monitoring
    11. Example: Setting up a Region Monitor
    12. 6. Implementing Location Delegates
    13. Example: Implementing Location Delegate
    14. 7. Converting Coordinates to Addresses
    15. Example: Reverse Geocoding a Location
    16. 8. Calculating Distance Between Locations
    17. Example: Calculating Distance
    18. 9. Using Background Location Updates
    19. Example: Requesting Background Location Permissions
    20. Key Considerations
    21. 10. Implementing Location-Based Features
    22. Example: Monitoring Region Enter/Exit

  47. Working with MapKit

    1. 1. Creating Map Views
    2. Example: Basic Map View Setup
    3. 2. Setting Map Region and Center
    4. Example: Setting Map Region
    5. Example: Setting Map Center
    6. 3. Adding Annotations
    7. Example: Adding a Basic Annotation
    8. 4. Customizing Annotation Views
    9. Example: Custom Annotation View
    10. 5. Using Map Overlays
    11. Example: Adding a Polygon Overlay
    12. Example: Adding a Circle Overlay
    13. 6. Drawing Routes on Map
    14. Example: Drawing a Route
    15. 7. Calculating Directions
    16. Example: Calculating Directions
    17. Example: Alternate Routes
    18. 8. Using User Location on Map
    19. Example: Enable User Location
    20. 9. Implementing Map Delegate Methods
    21. Example: Implementing map view delegate methods
    22. 10. Customizing Map Appearance
    23. Example: Setting Map Type
    24. Example: Showing User Location

  48. Working with Networking

    1. 1. Using URLSession for Requests
    2. Example: Making a GET Request
    3. Example: Making a POST Request
    4. 2. Creating URLRequest
    5. Example: Creating a URLRequest
    6. 3. Making GET Requests
    7. Example: Basic GET Request
    8. Example: GET Request with Codable
    9. 4. Making POST Requests
    10. Example: Basic POST Request
    11. 5. Handling Response Data
    12. Example: Parsing JSON Response
    13. Example: Handling HTTP Status Code
    14. Example: Reading Response Headers
    15. 6. Parsing JSON with Codable
    16. Example: Basic Codable Implementation
    17. Example: JSON Parsing with Codable
    18. Example: Handling Optional Fields
    19. 7. Using URLSessionDataTask
    20. Example: Fetching Data with URLSessionDataTask
    21. 8. Using URLSessionDownloadTask
    22. Example: Downloading a file using URLSessionDownloadTask
    23. Key Points
    24. 9. Using URLSessionUploadTask
    25. Example: Uploading Data with URLSessionUploadTask
    26. 10. Implementing Request Authentication
    27. Example: Using Bearer Token Authentication
    28. 11. Handling Network Errors
    29. Example: Basic Error Handling in URLSession
    30. Common Network Error Codes
    31. 12. Monitoring Network Reachability
    32. Example: Check Network Reachability

  49. Working with Codable

    1. 1. Conforming to Codable Protocol
    2. Example: Basic Codable Conformance
    3. Example: Custom Property Names
    4. 2. Using JSONEncoder to Encode
    5. Example: Encoding a Person Object
    6. Key Points
    7. 3. Using JSONDecoder to Decode
    8. Example: Decoding a JSON Object
    9. Example: Decoding a JSON Array
    10. 4. Customizing Coding Keys
    11. Example: Custom Coding Keys
    12. 5. Using Custom Encoding Logic
    13. Example: Custom Encoding with Nested Objects
    14. 6. Using Custom Decoding Logic
    15. Example: Custom Decoding with Conditional Logic
    16. 7. Handling Nested JSON
    17. Example: Decoding Nested JSON
    18. 8. Working with Dates
    19. Example: Encoding and decoding a Date
    20. 9. Handling Missing or Optional Fields
    21. Example: Optional Field
    22. Example: Default Value for Missing Field
    23. 10. Using PropertyListEncoder and PropertyListDecoder
    24. Example: Encoding to Property List
    25. Example: Decoding from Property List

  50. Working with Data Persistence

    1. 1. Using UserDefaults for Simple Storage
    2. Example: Saving and Retrieving Data
    3. Example: Working with Arrays and Dictionaries
    4. 2. Storing and Retrieving Objects
    5. 3. Working with File Manager
    6. Example: Save Data to Documents Directory
    7. Example: Read Data from Documents Directory
    8. 4. Reading Files from Bundle
    9. 5. Writing Files to Documents Directory
    10. Example: Writing a Text File to Documents Directory
    11. 6. Using Codable for File Persistence
    12. Example: Saving Codable Data to File
    13. Example: Loading Codable Data from File
    14. 7. Understanding App Sandbox Directories
    15. Example: Accessing Sandbox Directories
    16. 8. Using Keychain for Secure Storage
    17. Example: Storing a Password in Keychain
    18. Example: Retrieving a Password from Keychain
    19. 9. Implementing Data Migration
    20. Example: Custom Migration with Mapping Model
    21. 10. Understanding iCloud Storage Options
    22. Example: Using UserDefaults for Key-Value Storage

  51. Working with Core Data

    1. 1. Setting Up Core Data Stack
    2. Example: Basic Core Data Stack Setup
    3. Setup Steps
    4. 2. Creating Managed Object Model
    5. Example: Programmatic MOM Creation
    6. 3. Using NSManagedObjectContext
    7. Example: Creating a Managed Object Context
    8. Example: Fetching Objects
    9. Example: Saving Changes
    10. 4. Creating Entities Programmatically
    11. Example: Creating an Entity Programmatically
    12. 5. Fetching Data
    13. Example: Basic Fetch Request
    14. Example: Fetch with Predicate
    15. Example: Fetch with Sort
    16. 6. Filtering with Predicates
    17. Example: Fetching Employees by Department
    18. Example: Case-Insensitive Search
    19. 7. Sorting Fetch Results
    20. Example: Sorting by Name Ascending
    21. Example: Sorting by Multiple Fields
    22. 8. Updating Managed Objects
    23. Example: Updating a Managed Object
    24. Example: Using NSFetchedResultsController for Updates
    25. 9. Deleting Managed Objects
    26. Example: Deleting a Single Object
    27. Example: Deleting Multiple Objects
    28. 10. Saving Context Changes
    29. Example: Saving Context Changes
    30. 11. Using Batch Operations
    31. Example: Batch Insert
    32. Example: Batch Update
    33. Example: Batch Delete
    34. 12. Implementing Background Contexts
    35. Example: Creating a Background Context
    36. Example: Saving Changes on Background Context

  52. Working with SwiftData

    1. 1. Defining Models with @Model Macro
    2. Example: Basic Model Definition
    3. Example: Model with Relationships
    4. 2. Creating Model Container
    5. Example: Creating a Model Container
    6. 3. Using ModelContext for Operations
    7. 4. Querying Data with @Query
    8. Example: Basic @Query usage
    9. Example: @Query with sorting and limit
    10. Example: @Query with count
    11. 5. Inserting and Deleting Models
    12. 6. Working with Relationships
    13. Example: Defining a To-Many Relationship
    14. Example: Fetching Related Objects
    15. 7. Using Sort Descriptors
    16. Example: Sorting with SortDescriptor
    17. 8. Filtering with Predicates
    18. Example: Filtering with Predicate
    19. Example: Complex Predicate
    20. 9. Migrating from Core Data
    21. Core Data vs SwiftData Migration Considerations
    22. Example: Migrating a Simple Core Data Model to SwiftData
    23. 10. Understanding SwiftData vs Core Data
    24. SwiftData vs Core Data

  53. Working with CloudKit

    1. 1. Setting Up CloudKit Container
    2. Example: Configure CloudKit Container
    3. 2. Using Public and Private Databases
    4. Example: Saving to Public Database
    5. Example: Fetching from Private Database
    6. 3. Creating CKRecord Objects
    7. Example: Creating a CKRecord
    8. 4. Saving Records to CloudKit
    9. Example: Saving a Record to Public Database
    10. 5. Fetching Records with CKQuery
    11. Example: Fetching Records with CKQuery
    12. 6. Using Predicates for Filtering
    13. Example: Filtering Records by Name
    14. Example: Filtering Records by Date Range
    15. Example: Combining Predicates
    16. 7. Handling CloudKit Errors
    17. Example: Error Handling in CloudKit Operation
    18. 8. Subscribing to Record Changes
    19. Example: Creating a Record Change Subscription
    20. 9. Using CKShare for Sharing
    21. Example: Creating a CKShare
    22. Example: Saving a CKShare
    23. 10. Syncing with Core Data (NSPersistentCloudKitContainer)
    24. Example: Setting up CloudKit Container
    25. Example: Fetching Data from CloudKit

  54. Working with Deep Linking

    1. 1. Implementing URL Schemes
    2. Example: Handling URL Scheme in AppDelegate
    3. 2. Handling Universal Links
    4. Example: Implementing Universal Link Handling
    5. 3. Configuring Associated Domains
    6. Example: Configuring Associated Domains in Xcode
    7. 4. Processing Incoming URLs
    8. Example: Parsing URL Components
    9. 5. Using NSUserActivity for Handoff
    10. Example: Creating an NSUserActivity
    11. Handoff Workflow
    12. 6. Implementing Spotlight Search Integration
    13. Example: Configuring Spotlight Search Item
    14. Example: Indexing Content with Spotlight
    15. 7. Working with Siri Shortcuts
    16. Example: Defining a Custom Intent
    17. Example: Handling an Intent in App
    18. Key Steps for Siri Shortcuts
    19. 8. Handling Quick Actions
    20. Example: Defining Quick Action in Info.plist
    21. 9. Using Deferred Deep Linking
    22. Example: Handling Deferred Deep Links
    23. 10. Validating Deep Link Parameters
    24. Example: Validating Deep Link URL

  55. Working with App Groups and Extensions

    1. 1. Configuring App Groups
    2. Example: App Group Entitlements
    3. 2. Sharing Data with UserDefaults
    4. Example: Accessing Shared UserDefaults
    5. 3. Creating Share Extensions
    6. Example: Basic Share Extension Configuration
    7. Steps to Create a Share Extension
    8. 4. Building Today Extensions
    9. Example: Today Extension Info.plist Configuration
    10. Example: Widget Data Provider
    11. Example: Widget View
    12. 5. Implementing Custom Keyboard Extensions
    13. Example: Basic Custom Keyboard Setup
    14. 6. Creating Action Extensions
    15. Example: Basic Action Extension Configuration
    16. Example: Info.plist Configuration
    17. 7. Using File Provider Extensions
    18. Example: Implementing a File Provider Extension
    19. Key Features of File Provider Extensions
    20. 8. Communicating Between App and Extensions
    21. Example: Reading Shared UserDefaults
    22. Example: Writing to Shared Container
    23. 9. Sharing Keychain Access
    24. Example: Sharing Keychain Data
    25. 10. Managing Extension Lifecycle
    26. Example: App Extension Lifecycle

  56. Working with Widgets and App Clips

    1. 1. Creating WidgetKit Widgets
    2. Example: Basic Widget Configuration
    3. 2. Defining Widget Timeline
    4. Example: Creating a Timeline Entry
    5. 3. Using Timeline Providers
    6. Example: Implementing a Timeline Provider
    7. 4. Configuring Widget Families
    8. Example: Widget Family Configuration
    9. 5. Implementing Widget Intents
    10. Example: Defining a Widget Intent
    11. 6. Creating Interactive Widgets
    12. Example: Basic Interactive Widget
    13. 7. Building App Clips
    14. Example: Basic App Clip Configuration
    15. Key Requirements
    16. 8. Configuring App Clip Experiences
    17. Example: App Clip Configuration
    18. 9. Using App Clip Invocations
    19. Example: App Clip Invocation Setup
    20. 10. Converting App Clip Users to Full App
    21. Example: Conversion Logic

  57. Working with App Intents Framework

    1. 1. Defining App Intents
    2. Example: Defining a Simple Intent
    3. 2. Creating Intent Parameters
    4. Example: Defining Intent Parameters
    5. 3. Implementing perform() Method
    6. Example: Implementing perform() in a Custom Intent
    7. 4. Using Intent Shortcuts
    8. Example: Define an Intent Shortcut
    9. 5. Integrating with Siri
    10. Example: Defining an Intent
    11. Example: Handling the Intent
    12. 6. Providing Intent Suggestions
    13. Example: Defining Intent Suggestions
    14. 7. Using App Shortcuts
    15. Example: Defining an App Shortcut
    16. 8. Creating Focus Filters
    17. Example: Creating a Focus Filter
    18. 9. Implementing Entity Queries
    19. Example: Fetching Entities
    20. Example: Defining an Entity
    21. 10. Combining Intents with Widgets
    22. Example: Creating a Widget with App Intent

  58. Working with Permissions

    1. 1. Requesting Camera Permission
    2. Example: Requesting Camera Permission
    3. 2. Requesting Photo Library Access
    4. Example: Requesting Photo Library Access
    5. 3. Requesting Location Services
    6. Example: Requesting Location Permission
    7. 4. Requesting Microphone Permission
    8. Example: Requesting Microphone Access
    9. 5. Requesting Contacts Access
    10. Example: Requesting Contacts Permission
    11. 6. Requesting Calendar and Reminders
    12. Example: Requesting Calendar Permission
    13. Example: Requesting Reminders Permission
    14. 7. Requesting Notifications Permission
    15. Example: Requesting Notification Permission
    16. 8. Checking Permission Status
    17. Example: Check Camera Permission Status
    18. Example: Check Location Permission Status
    19. 9. Handling Permission Denials
    20. Example: Requesting Location Permission with Error Handling
    21. Workflow: Handling Permission Denial
    22. Comparison: Permission Types
    23. 10. Using Info.plist Usage Descriptions
    24. Example: Adding Usage Description to Info.plist

  59. Working with Accessibility

    1. 1. Using Accessibility Labels
    2. Example: Setting Accessibility Label
    3. 2. Using Accessibility Hints
    4. Example: Setting an Accessibility Hint
    5. 3. Using Accessibility Traits
    6. Example: Setting Accessibility Traits
    7. 4. Setting Accessibility Values
    8. Example: Setting Accessibility Values on a Button
    9. Example: Setting Accessibility Value on a Slider
    10. 5. Grouping Accessibility Elements
    11. Example: Grouping Buttons
    12. 6. Using VoiceOver Testing
    13. Example: Enabling VoiceOver in Simulator
    14. Workflow: Testing VoiceOver Navigation
    15. Comparison: VoiceOver vs. Accessibility Inspector
    16. 7. Supporting Dynamic Type
    17. Example: Using Dynamic Type in UI
    18. Example: Custom Font Scaling
    19. 8. Implementing Custom Actions
    20. Example: Custom Action Implementation
    21. 9. Using Accessibility Notifications
    22. Example: Posting an Accessibility Notification
    23. 10. Testing with Accessibility Inspector
    24. Example: Using Accessibility Inspector
    25. Accessibility Inspector Workflow
    26. 11. Supporting Reduce Motion
    27. Example: Check if Reduce Motion is Enabled
    28. Best Practices for Reduce Motion

  60. Implementing Localization

    1. 1. Using NSLocalizedString
    2. Example: Basic Usage of NSLocalizedString
    3. Example: Using NSLocalizedString with Table
    4. 2. Creating Localizable.strings Files
    5. Example: Basic Localizable.strings
    6. Example: Localizable.stringsdict for Plurals
    7. 3. Localizing Storyboards and XIBs
    8. Example: Localizing a Label in Storyboard
    9. 4. Supporting Multiple Languages
    10. Example: Setting Up Localization in Swift
    11. Localization Setup Steps
    12. 5. Using String Formatting for Localization
    13. Example: Formatting with Localization
    14. 6. Localizing Images and Assets
    15. Example: Using Asset Catalogs for Localization
    16. 7. Using Locale for Region-Specific Formatting
    17. Example: Formatting Numbers with Locale
    18. Example: Formatting Dates with Locale
    19. 8. Testing Different Locales
    20. Example: Simulating Locale in Simulator
    21. Workflow: Testing Locales in Xcode Simulator
    22. 9. Using Base Internationalization
    23. Example: Setting up Base Internationalization
    24. Key Benefits of Base Internationalization
    25. 10. Implementing Right-to-Left Support
    26. Example: Setting Up Right-to-Left Layout
    27. Example: Using Directional Layout Margins

  61. Implementing Security Best Practices

    1. 1. Using Keychain for Sensitive Data
    2. Example: Storing and Retrieving Data in Keychain
    3. 2. Implementing Certificate Pinning
    4. Example: Using Certificate Pinning with URLSession
    5. 3. Using App Transport Security
    6. Example: Basic ATS Configuration
    7. Example: Exception for Specific Domain
    8. ATS Best Practices
    9. 4. Encrypting Data at Rest
    10. Example: Using Data Protection API
    11. Example: Storing Secure Data in Keychain
    12. 5. Using Secure Coding Practices
    13. Example: Secure API Call
    14. 6. Preventing Screen Capture
    15. Example: Disable Screen Capture
    16. 7. Implementing Biometric Authentication
    17. Example: Evaluating Face ID Authentication
    18. 8. Using Secure Random Generators
    19. Example: Generating a Secure Random Number
    20. Example: Using CryptoKit for Secure Randomness
    21. 9. Validating User Input
    22. Example: Validating Email Input
    23. 10. Implementing Jailbreak Detection
    24. Example: Basic Jailbreak Detection Check
    25. Key Points

  62. Working with In-App Purchases

    1. 1. Configuring Products in App Store Connect
    2. Example: Product ID Configuration
    3. 2. Using StoreKit for Purchases
    4. Example: Requesting Product Information
    5. Example: Initiating a Purchase
    6. Example: Handling Purchase Verification
    7. 3. Fetching Product Information
    8. Example: Fetching Product Information
    9. 4. Processing Transactions
    10. Example: Handling Transaction States
    11. 5. Restoring Purchases
    12. Example: Restoring Purchases
    13. Key Points for Restore Purchases
    14. 6. Implementing Subscription Management
    15. Example: Requesting Subscription Products
    16. Example: Purchasing a Subscription
    17. Example: Managing Auto-Renewal
    18. Subscription Management Workflow
    19. 7. Handling Receipt Validation
    20. Example: Basic Receipt Validation
    21. Receipt Validation Steps
    22. 8. Using Server-Side Receipt Verification
    23. Example: Verifying Receipt with Server
    24. Server-Side Receipt Verification Steps
    25. 9. Implementing Promotional Offers
    26. Example: Fetching Promotional Offers
    27. Example: Applying Promotional Offer
    28. 10. Testing In-App Purchases
    29. Example: Setting up SKTestSession
    30. Example: Simulating Purchase Flow
    31. Testing Steps

  63. Implementing iOS Design Patterns

    1. 1. Understanding MVC Pattern
    2. Example: Basic MVC Implementation in Swift
    3. 2. Implementing MVVM Pattern
    4. Example: Binding in MVVM
    5. Key Benefits of MVVM
    6. 3. Using Coordinator Pattern for Navigation
    7. Example: Coordinator Protocol
    8. Example: Login Coordinator
    9. 4. Implementing Repository Pattern for Data
    10. Example: Using Repository in a View Model
    11. 5. Using Dependency Injection
    12. Example: Dependency Injection in Action
    13. Benefits of Dependency Injection
    14. 6. Applying Factory Pattern
    15. Example: Factory Method in iOS
    16. 7. Implementing Observer Pattern
    17. Example: Basic Observer Pattern Implementation
    18. Key Points
    19. 8. Using Singleton Pattern
    20. Example: Singleton Implementation
    21. 9. Applying Strategy Pattern
    22. Example: Payment Processing Strategy
    23. 10. Understanding Clean Architecture
    24. Example: Layered Architecture
    25. Key Benefits

  64. Testing iOS Applications

    1. 1. Writing Unit Tests
    2. Example: Basic Unit Test
    3. Workflow: Setting Up a Unit Test
    4. 2. Using XCTAssert Methods
    5. 3. Testing Asynchronous Code
    6. Example: Using XCTestExpectation
    7. Example: Using async/await
    8. Best Practices for Testing Async Code
    9. 4. Using Test Doubles
    10. Example: Using Mocks in Swift
    11. Example: Using Stubs in Swift
    12. Summary of Test Doubles
    13. 5. Writing UI Tests
    14. Example: Basic UI Test Setup
    15. Example: Interacting with UI Elements
    16. Example: Using Gestures
    17. Key Concepts in UI Testing
    18. 6. Recording UI Tests
    19. Example: Recording a UI Test
    20. Key Steps to Record UI Tests
    21. 7. Testing Accessibility
    22. Example: Setting Accessibility Properties
    23. Accessibility Testing Best Practices
    24. 8. Using Performance Tests
    25. Example: Measuring Method Execution Time
    26. Example: UI Performance Test
    27. Key Points
    28. 9. Testing Network Code
    29. Example: Mocking a Network Request
    30. Testing Network Code Best Practices
    31. 10. Implementing Code Coverage
    32. Example: Setting up code coverage in Xcode
    33. Code Coverage Configuration
    34. 11. Using Test Plans
    35. Example: Creating a Test Plan
    36. Key Features of Test Plans

  65. Debugging iOS Applications

    1. 1. Using Print Statements for Logging
    2. Example: Basic Print Usage
    3. Example: Print with Variable Values
    4. 2. Using Breakpoints in Xcode
    5. Example: Setting a Conditional Breakpoint
    6. 3. Using LLDB Commands
    7. Example: Setting a breakpoint and stepping through code
    8. 4. Using View Debugger
    9. Example: Inspecting UI Hierarchy
    10. Workflow: Using View Debugger
    11. Comparison: View Debugger vs Debug Console
    12. 5. Analyzing Memory Issues
    13. Example: Using Xcode Memory Graph Debugger
    14. 6. Using Instruments for Profiling
    15. Example: Launching Instruments
    16. Workflow: Profiling with Time Profiler
    17. Comparison: Instruments vs Xcode Debugging
    18. 7. Detecting Memory Leaks
    19. Example: Using Memory Graph Debugger
    20. Key Points
    21. 8. Using Network Link Conditioner
    22. Example: Enabling Network Link Conditioner in Xcode
    23. Example: Disabling Network Link Conditioner
    24. Summary of Network Link Conditioner Usage
    25. 9. Debugging Layout Constraints
    26. Example: Enabling Debugging for Layout Constraints
    27. Common Constraint Debugging Techniques
    28. 10. Using OSLog for Logging
    29. Example: Basic OSLog Usage
    30. Example: Using Custom Log Levels
    31. Key Features of OSLog
    32. 11. Implementing Custom Debug Descriptions
    33. Example: Custom debugDescription implementation

  66. Optimizing Performance

    1. 1. Profiling with Instruments
    2. Example: Using Time Profiler
    3. 2. Optimizing Table and Collection Views
    4. Example: Reusing Cells
    5. Example: Using Estimated Row Height
    6. Performance Tips
    7. 3. Implementing Cell Reuse
    8. Example: Reusing Cells in UITableView
    9. 4. Using Lazy Loading Techniques
    10. Example: Lazy Loading Images in a TableView
    11. 5. Optimizing Image Loading
    12. Example: Loading Image with SDWebImage
    13. Example: Using Kingfisher for Image Loading
    14. Best Practices for Image Loading
    15. 6. Using Background Threads for Heavy Tasks
    16. Example: Performing Heavy Task on Background Thread
    17. 7. Minimizing View Hierarchy Depth
    18. Example: Flattening View Hierarchy
    19. 8. Using Opaque Views
    20. Example: Setting Opaque View
    21. 9. Avoiding Excessive Redraws
    22. Example: Using @ViewBuilder to Avoid Unnecessary Redraws
    23. 10. Optimizing Network Requests
    24. Example: Making a GET Request
    25. Example: Using a Custom Session
    26. Best Practices
    27. 11. Using Caching Strategies
    28. Example: Image Caching with NSCache
    29. Best Practices
    30. 12. Reducing App Launch Time
    31. Example: Lazy Loading in Swift
    32. Example: Preloading Assets
    33. Key Strategies

  67. Working with Swift Macros

    1. 1. Understanding Macro Types
    2. Example: Expression Macro Usage
    3. Example: Declaration Macro Usage
    4. 2. Using Built-in Macros (#warning, #error)
    5. Example: Using #warning and #error
    6. 3. Using @Observable Macro
    7. Example: Basic Usage of @Observable
    8. Example: Using @Observable with Property Observers
    9. 4. Using @Model Macro for SwiftData
    10. Example: Define a SwiftData Model
    11. Example: Using Relationships
    12. 5. Creating Freestanding Expression Macros
    13. Example: Basic Freestanding Expression Macro
    14. 6. Creating Attached Member Macros
    15. Example: Basic Attached Member Macro
    16. Key Points
    17. 7. Understanding Macro Expansion
    18. Example: Basic Macro Expansion
    19. Expansion Process Overview
    20. 8. Testing Macros
    21. Example: Basic Macro Test
    22. Testing Strategy
    23. 9. Debugging Macro Output
    24. Example: Using
    25. 10. Following Macro Best Practices
    26. Summary of Macro Best Practices

  68. Working with Xcode and Build Tools

    1. 1. Understanding Xcode Project Structure
    2. Example: Basic Project Structure
    3. 2. Using Workspaces vs Projects
    4. Workspaces vs Projects
    5. Example: Creating a Workspace
    6. 3. Managing Build Configurations
    7. Example: Setting Up Custom Build Configuration
    8. Build Configuration Summary
    9. 4. Using Build Settings
    10. Example: Setting Deployment Target
    11. 5. Configuring Code Signing
    12. Example: Setting Code Signing in Xcode
    13. 6. Using Provisioning Profiles
    14. Example: Creating a Provisioning Profile in Xcode
    15. 7. Managing Dependencies with Swift Package Manager
    16. Example: Adding a dependency to Package.swift
    17. Example: Using SPM in Xcode
    18. 8. Using CocoaPods for Dependencies
    19. Example: Podfile Configuration
    20. Example: Installing Dependencies
    21. 9. Implementing Custom Build Scripts
    22. Example: Adding a Custom Build Script to an Xcode Project
    23. Key Points for Custom Build Scripts
    24. 10. Using Schemes and Targets
    25. Example: Creating a New Scheme
    26. Example: Configuring Target Build Settings
    27. Key Points About Schemes and Targets
    28. 11. Understanding Build Phases
    29. Example: Run Script Build Phase

  69. Preparing for App Store

    1. 1. Creating App Store Connect Account
    2. Example: Registering for App Store Connect
    3. 2. Preparing App Icons and Screenshots
    4. Example: App Icon Sizes
    5. Example: Screenshot Requirements
    6. 3. Writing App Description and Metadata
    7. Example: App Description Formatting
    8. 4. Configuring App Privacy Information
    9. Example: App Privacy Manifest Configuration
    10. Privacy Manifest Requirements
    11. 5. Creating App Store Provisioning Profile
    12. Example: Xcode App Store Provisioning Profile Setup
    13. Steps to Create App Store Provisioning Profile
    14. 6. Archiving App for Distribution
    15. Example: Archive Command via Terminal
    16. 7. Uploading Build to App Store Connect
    17. Example: Archive and Upload via Xcode
    18. 8. Managing App Versions and Builds
    19. Example: Setting Version in Info.plist
    20. Example: Using Xcode Build Settings
    21. 9. Submitting App for Review
    22. Example: App Store Connect Submission
    23. 10. Handling App Review Feedback
    24. Example: Resubmitting After Rejection
    25. 11. Managing App Updates and Releases
    26. Example: Archive and Upload via Terminal