Mastering macOS Programming

And finally

Summary

Export as a macOS App

Export a Development-signed Application

Export a Developer ID-signed Application

Testing the Installer package

Save for Mac App Store Deployment

Exporting the app for distribution

Uploading from Xcode to the App Store

Creating app records in iTunes Connect

Uploading to the App Store

Validating the archive

Archiving the app

Providing the required icons

Registering an app ID

Your developer account

Enabling sandboxing

Setting the Application Category

Setting up the project

Bundle ID

The Organization Identifier

Team

The product name

The right settings on project creation

App distribution

Wrapping It Up

Summary

The price of complexity

Carthage

Cocoapods

Other package managers

Package baggage

Over to Xcode

Adding the package to an Xcode project

SPM products

Swift Package Manager

Importing the source code

Cloning the repository

Installing Git

Installing Homebrew

Preparing to clone

Cloning the repo

Downloading the ZIP

Manual source code integration

Different installation methods

Leaving it till later

A case study

The take-away

The case against

The case for third - party code

Pros and cons

But the Internet says...

Third-party frameworks

Third - party libraries

Third - party source code

Distribution methods

Common use cases

Deploying Third - Party Code

Summary

Differences between standalone and Xcode LLDB

Running Xcode projects in a standalone LLDB session

Standalone LLDB

Altogether now

Getting help in Python

One liners from LLDB to Python

Switching between LLDB and Python REPL

Accessing program variables from Python

Using Python in LLDB

Leaving a REPL session

Switching between LLDB and Swift REPL

REPL in LLDB

Using shell commands in LLDB

Getting help in LLBD

Persistent customization

Enabling disabling and deleting watchpoints

Watchpoint lists

Adding conditions and commands

Watchpoints

Naming breakpoints

Creating a Swift Error breakpoint

Attaching commands to breakpoints

Breakpoint list

Adding a breakpoint

Breakpoints in LLDB

Type lookups

Executing code from LLDB

Printing formatted numbers

Stop hooks

Preparing classes for LLDB descriptions

Printing in LLDB

Enable

Trying it out

Step out

Step into

Step over

Continue

Debugging line-by-line

Using LLDB

LLDB

LLDB and the Command Line

Summary

Trying them out

Step out

Step into

Step over

Continue

Enable

Close

Debugger control

Breakpoint control flow

Multiple actions

Sounds

We can also get a little more ambitious with these actions

AppleScript

Shell Command

Debugger Command

Log message

Adding an action to a breakpoint

Ignore

Conditions

Editing breakpoints

Adding and removing breakpoints

Other breakpoint types

Symbolic breakpoints

Swift error breakpoints

Different types of breakpoint

Leveraging breakpoints

Report navigator

Breakpoint navigator

Changing the process view

Hiding and showing additional information

Debug navigator

Debugging in the navigator area

Console view

Using Quicklook

Variables view

Debug area

Checking out Xcode's debugging tools

Understanding Xcodes Debugging Tools

Summary

Defining concurrent custom operations

Defining non-concurrent custom operations

Concurrent and non-concurrent operations

Defining a custom Operation object

BlockOperation completion blocks

More BlockOperation features

Adding dependencies to BlockOperations

Basic use of an OperationQueue

Understanding operations and queues

Operation framework

Dependencies and why you don't need to worry

The challenges of asynchronous programming

Asynchronicity

Threads and why you don't need to worry

Multiprocessing

Multithreading

Concurrency and parallelism

Concurrency

Concurrency and asynchronicity

Concurrency and Asynchronous Programming

Summary

Using different request cache policies

Cache rewards

Ephemeral sessions

URLSessionTasks

The URLSession framework

No third-party frameworks?

Adding suspend and resume

URLSessionTaskDelegate methods

Canceling a download

Getting progress information

Catching errors

Handling the data

URLSessionDownloadDelegate methods

Creating a session delegate class

Creating the manager

Creating a simple UI

Adding HTTP compatibility to the app

Downloading using a URLSession delegate

Customizing URLSessionTask properties

Customizing URLRequest properties

Customizing URLSessionConfiguration properties

Improving the simplest request possible

The completion handler

The simplest request possible

The web as an asynchronous entity

Implementing an HTTP request manager

Testing the server

Creating a JSON file

Starting the server

Starting a local test server on your machine

Downloading using closures

Control

Simplicity

Patterns for downloading data

Connect to the World - Networking

Summary

Making that decision

The cons

The pros

Does app X really need Core Data?

NSPersistentStoreCoordinator

NSManagedObjectContext

NSManagedObjectModel

The Core Data stack

More about Core Data

Deleting the red guy

Relationship predicates

Combining predicates

Searching for a case - insensitive string

Searching for a string

Using other predicates

Predicate fetching

Sorting in the table view

Sorted fetches

Same thing the other way around

Adding relationships to the crew

One-to-many relationships

One-to-one relationships

Adding relationships between entities

Fetching data

What is a managed object context?

Creating entity instances

Non-string entity attributes

Creating a data manager class

Replacing references to the context

Delete the unneeded properties

Adding an NSPersistentContainer instance

Using NSPersistenceContainer

Using our data model

Connecting the text fields

Connecting the Table Cell Views

Setting up the table columns

Connecting the Array Controller

Connecting the buttons

Connecting up to the storyboard

Preparing the View Controller

Setting up the data model

Add an Array Controller

Adding the necessary UI objects to the Scene

Create a simple UI in Interface Builder

Create the project

Core Data Cocoa Bindings and no code

Relationships

Attributes

Entities

Elements of a Core Data model

What Core Data is and isn't

The Benefits of Core Data

Summary

Presenting open and save dialog boxes

More complex objects

Testing the code

Loading NSCoding--compliant objects

Saving NSCoding--compliant objects

Handling NSCoding--compliant objects

Creating an NSCoding--compliant class

NSCoding/NSKeyedArchiver

Testing the load function

Loading text files

Testing the save function

Storing textual data

Create an extension and helper function

Saving text to the Documents folder

Security considerations

Testing the code

Loading the data

Saving with convenience methods

UserDefaults convenience methods

Testing the code

Loading by type

Testing the code

Loading structured data

Saving structured data

Storing structured data

Testing the code

Loading simple objects

Using the synchronize method

Storing simple objects

Storage of simple objects

Using UserDefaults

Creating the project's file manager

Creating a project

Persistent Storage

Summary

Creating NSError instances in Swift

Pattern-matched Cocoa catches

Catching NSErrors

Anatomy of an NSError

NSError handling

Anything can be an error

Verbose errors

Propagation - case study: propagation

Propagation - case study: handling in scope

Propagating an error

Matching associated values

Pattern matching

Handling an error with do-catch

Handling the error as an optional value

Asserting that the error will not occur

The error life cycle

Handling an error

Throwing an error

Creating a better Error enum

Creating the simplest Error enum

Error types

The four ways of handling errors

Swift error handling

Explicit error handling

Optionals

Expecting the unexpected

Errors aren't mistakes

Handling Errors Gracefully

Summary

Animating NSViews

Adding 3D animation

Rotating the CATransformLayer

Composing CALayers onto CATransformLayer

Introducing CATransformLayer

Getting even closer to 3D

Adding perspective

Two-and-a-half dimensional animations

Nesting CATransaction blocks

Adding CATransaction completion blocks

Affine transformation

Wrapping changes in CATransaction objects

Controlling animations with CAAnimationGroup

Using CAKeyframeAnimation

Delaying an animation

CABasicAnimation and the view model

CABasicAnimation

CA explicit animations

CA implicit animations

Animating CALayer objects

Using CATextLayer

Rotating a layer in 3D

Adding CA transformations

CGPaths

CAShapeLayer properties

Adding a CAShapeLayer

Exploring glows and shadows

Adding CA sublayers

Building CALayer objects

Adding a button in code

Preparing the ViewController class

Extending CGColor

Adding a custom view

Creating a project

Introducing CALayer

Drawing then animating

Layer backed and layer hosting

Where does Core Animation fit in?

What is Core Animation?

Core Animation

Summary

Context scaling

Adding shadows

Adding the hour displacement

Rotating the text

Translating the context

Context rotation

Context translation

The drawHours method

Adding more color locations

Adding a gradient with Core Graphics

The drawMinutes method

Adding a gradient with AppKit

The drawFace method

The draw method

Overriding the class's draw method

Creating the custom class

Understanding the CG coordinates system

Why do we need a graphics context?

Understanding CGContext

Creating a custom view with Core Graphics

Pie clock

Correcting the order of drawing

Adding the hours curve

Adding the minutes curve

Adding the fill color

Drawing the outline

Drawing arcs

Overriding the custom view's draw method

Creating a custom view with AppKit

Dial clock

Testing the button

Adding an alternative icon

Drawing the icon with code

Stroking a path

Filling a path

Overriding the button's draw method

Defining the custom button's properties

Custom buttons

Creating custom views

Which to use

Using Core Graphics

Using AppKit

Core Graphics and AppKit drawing

Why not use native views?

Why not use an image?

Drawing on the Strength of Core Graphics

Summary

Under the hood of a storyboard

Refactoring large storyboards

Taming the storyboard

Encapsulating views with NSStackView

Showing constraints

Zooming

Wireframe view

Other view settings

Controlling the amount of information

Debug View Hierarchy

Showing all views under the cursor

The little-known HUD

Advanced IB navigation

Getting More from Interface Builder

Summary

Creating the custom text view

Creating the custom storage class

Custom text view

NSLayoutManager

NSTextContainer

NSTextStorage

The MVC pattern of text views

NSTextView

Styles and effects

Links in text

Multiple attributes

Adding an attribute

Formatting using NSMutableAttributedString

Formatting using fonts

Formatting strings

String comparison

Value and reference

Mutability

Indexing

Some NSString gotchas

NSString

C strings

Other representations

Escape characters

Writing long strings

String interpolation

Inserting characters

Removing characters

Modifying strings

Obtaining a subrange

Obtaining a String.Index

String indices and subranges

Combining strings and characters

Unicode compliance

What is a Character?

What is a String in Swift?

Strings and characters

Strings and Text

Summary

Running the app

Implementing a button's action

Adding the sort button

Adding further control elements in code

The final line of code

Advantages of KVO in code

Triggering changes to the data

Removing an observer

Handling changes in the data

Adding an observer

Adding KVO to the View Controller

Observing without bindings

Reacting to selection events

Returning table view columns

Delegate extension

Datasource extension

Adopting datasource and delegate protocols

Getting data from the property list

Creating a property list with XML

The data model

Importing the Person class

Providing the app with data

Adding the info label

Configuring the table's columns

Adding the table

The table and label

Preparing the View Controller

Coding a table view

Beyond the visuals

The steps involved

Setting our goals

Why code instead of IB?

Creating Views Programmatically

Summary

Pretty Boolean

Changing array values

Adding and binding a text field

Adding the binding

Binding the table selection

Binding the table view

Adding an NSArrayController

Adding the data model

Cocoa bindings

Modifying ViewController

Trying it out

Removing the observer

Reacting to value changes

Adding the observer

KVO - compliant classes

Coding for KVO

Leveraging key-value observing

Import statements

Understanding NSObject

Understanding Foundation Kit

Cocoa Frameworks - The Backbone of Your Apps

Summary

Implicitly unwrapped optionals

Unwrapping optionals with guard

Conditional downcasting

Optionals

Removing dictionary elements

Mutating dictionaries

Accessing all keys or values

Dictionaries

Sorting arrays

Mutating non-returning methods

Methods that mutate and return a value

Removing elements from an array

Testing array elements

Using arrays to create new arrays

Mutating an array

Comparing arrays

Arrays

Collection types

Implementing a custom operator

Infix operators

Postfix operators

Prefix operators

Defining a custom operator

Custom operators

Equivalence

Adding operator implementations to types

Customizing operators

Protocol composition

Class considerations

Class-only protocols

Implementing required properties

Declaring required properties

Protocols can conform to protocols

Creating collections of mixed types

Extending existing types with a protocol

Protocol advantages over classes

Conforming to a protocol

Declaring method requirements

Protocols

Replacing classes

Making constants with an enum

Recursive definitions

Mixed type arrays anybody?

Creating multiple distinct types from a single type

Grouping together different data types

Associated values

Adding methods to enums

Enumerations as data structures

Chaining

Nesting

Nesting and chaining map reduce and filter

filter

reduce

Map with dictionaries

Map with arrays

Using map reduce and filter

Closures are functions; functions are closures

Alternative closure syntax

Closures with multiple arguments

Closures that take arguments

Closures

Functions are typed

First class functions

Function naming in Swift 3.0

Function overloading

Variadic arguments

Anonymous arguments

Default arguments

Arguments

Functions

The guard statement

The fallthrough statement

The break statement

Control transfer statements

Using the where keyword

Value binding

Tuple matching

Compound cases

Using switch

Control flow

Advanced Swift

Summary

Design patterns

Objects

Data flow

Functions

A path through the forest

Simplification

Separation of concerns

Encapsulation

Learning functional programming the fast way

Using functional concepts within OOP

Understanding functional programming

Declarative programming

The drawbacks of OOP

Protocol-oriented programming

Class-based programming

Object-oriented programming

Imperative

So what is meant by paradigm?

Programming paradigms

MVC and Other Design Patterns

Summary

Finding the build settings on disk

Using custom flags in code

Creating the custom flag

Using Swift compiler custom flags

Adapting the Info.plist file

Creating user-defined build settings

Creating a new build configuration

Why build configs are so cool

Using scheme environment variables

Creating a new scheme

What schemes actually do

Understanding schemes

Behaviors

Don't stop me now

Triggering an AppleScript or shell script

Adding a debugger command

Other actions

Editing breakpoint options

Getting the most out of breakpoints

Logging with special literals

Rolling your own snippets

Usage

Checking out the supplied snippets

Speeding it up with code snippets

A quick and simple sketch app

Checking Out the Power of Xcode

Summary

Functions

while

Iterating with for loops

Saying goodbye to i++

Loops

switch

if else

Control flow

Unwrapping an optional

Why use optionals?

Optionals

Enumerations

Tuples

Optional instances

Classes

Structs

Structs classes and other data structures

Nil-coalescing operator

Ternary operator

Other standard operators

Logical operators

Comparison operators

Augmented assignment

Mathematical operators

Operators

Value and reference types

Type aliases

Naming of types and variables

Sets

Dictionaries

Arrays

Arrays dictionaries and sets

Comments

Printing to the console

Strings

Booleans

Integers

Number types

Variables and types

Basic Swift

Summary

What you'll get from this book

The serious developer's toolkit

Harnessing that power

Cocoa

macOS

Darwin

How Unix macOS Cocoa and AppKit fit together

The book's overall structure

Prerequisites

It's going to be Xcode and more

And more than Swift

It's going to be Swift

Hello macOS

Questions

Piracy

Errata

Downloading the color images of this book

Downloading the example code

Customer support

Reader feedback

Conventions

Who this book is for

What you need for this book

What this book covers

Preface

Dedication

Customer Feedback

www.PacktPub.com

About the Reviewer

About the Author

Credits

Title Page

coverpage

coverpage

Title Page

Credits

About the Author

About the Reviewer

www.PacktPub.com

Customer Feedback

Dedication

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

Hello macOS

It's going to be Swift

And more than Swift

It's going to be Xcode and more

Prerequisites

The book's overall structure

How Unix macOS Cocoa and AppKit fit together

Darwin

macOS

Cocoa

Harnessing that power

The serious developer's toolkit

What you'll get from this book

Summary

Basic Swift

Variables and types

Number types

Integers

Booleans

Strings

Printing to the console

Comments

Arrays dictionaries and sets

Arrays

Dictionaries

Sets

Naming of types and variables

Type aliases

Value and reference types

Operators

Mathematical operators

Augmented assignment

Comparison operators

Logical operators

Other standard operators

Ternary operator

Nil-coalescing operator

Structs classes and other data structures

Structs

Classes

Optional instances

Tuples

Enumerations

Optionals

Why use optionals?

Unwrapping an optional

Control flow

if else

switch

Loops

Saying goodbye to i++

Iterating with for loops

while

Functions

Summary

Checking Out the Power of Xcode

A quick and simple sketch app

Speeding it up with code snippets

Checking out the supplied snippets

Usage

Rolling your own snippets

Logging with special literals

Getting the most out of breakpoints

Editing breakpoint options

Other actions

Adding a debugger command

Triggering an AppleScript or shell script

Don't stop me now

Behaviors

Understanding schemes

What schemes actually do

Creating a new scheme

Using scheme environment variables

Why build configs are so cool

Creating a new build configuration

Creating user-defined build settings

Adapting the Info.plist file

Using Swift compiler custom flags

Creating the custom flag

Using custom flags in code

Finding the build settings on disk

Summary

MVC and Other Design Patterns

Programming paradigms

So what is meant by paradigm?

Imperative

Object-oriented programming

Class-based programming

Protocol-oriented programming

The drawbacks of OOP

Declarative programming

Understanding functional programming

Using functional concepts within OOP

Learning functional programming the fast way

Encapsulation

Separation of concerns

Simplification

A path through the forest

Functions

Data flow

Objects

Design patterns

Summary

Advanced Swift

Control flow

Using switch

Compound cases

Tuple matching

Value binding

Using the where keyword

Control transfer statements

The break statement

The fallthrough statement

The guard statement

Functions

Arguments

Default arguments

Anonymous arguments

Variadic arguments

Function overloading

Function naming in Swift 3.0

First class functions

Functions are typed

Closures

Closures that take arguments

Closures with multiple arguments

Alternative closure syntax

Closures are functions; functions are closures

Using map reduce and filter

Map with arrays

Map with dictionaries

reduce

filter

Nesting and chaining map reduce and filter

Nesting

Chaining

Enumerations as data structures

Adding methods to enums

Associated values

Grouping together different data types

Creating multiple distinct types from a single type

Mixed type arrays anybody?

Recursive definitions

Making constants with an enum

Replacing classes

Protocols

Declaring method requirements

Conforming to a protocol

Protocol advantages over classes

Extending existing types with a protocol

Creating collections of mixed types

Protocols can conform to protocols

Declaring required properties

Implementing required properties

Class-only protocols

Class considerations

Protocol composition

Customizing operators

Adding operator implementations to types

Equivalence

Custom operators

Defining a custom operator

Prefix operators

Postfix operators

Infix operators

Implementing a custom operator

Collection types

Arrays

Comparing arrays

Mutating an array

Using arrays to create new arrays

Testing array elements

Removing elements from an array

Methods that mutate and return a value

Mutating non-returning methods

Sorting arrays

Dictionaries

Accessing all keys or values

Mutating dictionaries

Removing dictionary elements

Optionals

Conditional downcasting

Unwrapping optionals with guard

Implicitly unwrapped optionals

Summary

Cocoa Frameworks - The Backbone of Your Apps

Understanding Foundation Kit

Understanding NSObject

Import statements

Leveraging key-value observing

Coding for KVO

KVO - compliant classes

Adding the observer

Reacting to value changes

Removing the observer

Trying it out

Modifying ViewController

Cocoa bindings

Adding the data model

Adding an NSArrayController

Binding the table view

Binding the table selection

Adding the binding

Adding and binding a text field

Changing array values

Pretty Boolean

Summary

Creating Views Programmatically

Why code instead of IB?

Setting our goals

The steps involved

Beyond the visuals

Coding a table view

Preparing the View Controller

The table and label

Adding the table

Configuring the table's columns

Adding the info label

Providing the app with data

Importing the Person class

The data model

Creating a property list with XML

Getting data from the property list

Adopting datasource and delegate protocols

Datasource extension

Delegate extension

Returning table view columns

Reacting to selection events

Observing without bindings

Adding KVO to the View Controller

Adding an observer

Handling changes in the data

Removing an observer

Triggering changes to the data

Advantages of KVO in code

The final line of code

Adding further control elements in code

Adding the sort button

Implementing a button's action

Running the app

Summary

Strings and Text

Strings and characters

What is a String in Swift?

What is a Character?

Unicode compliance

Combining strings and characters

String indices and subranges

Obtaining a String.Index

Obtaining a subrange

Modifying strings

Removing characters

Inserting characters

String interpolation

Writing long strings

Escape characters

Other representations

C strings

NSString

Some NSString gotchas

Indexing

Mutability

Value and reference

String comparison

Formatting strings

Formatting using fonts

Formatting using NSMutableAttributedString

Adding an attribute

Multiple attributes

Links in text

Styles and effects

NSTextView

The MVC pattern of text views

NSTextStorage

NSTextContainer

NSLayoutManager

Custom text view

Creating the custom storage class

Creating the custom text view

Summary

Getting More from Interface Builder

Advanced IB navigation

The little-known HUD

Showing all views under the cursor

Debug View Hierarchy

Controlling the amount of information

Other view settings

Wireframe view

Zooming

Showing constraints

Encapsulating views with NSStackView

Taming the storyboard

Refactoring large storyboards

Under the hood of a storyboard

Summary

Drawing on the Strength of Core Graphics

Why not use an image?

Why not use native views?

Core Graphics and AppKit drawing

Using AppKit

Using Core Graphics

Which to use

Creating custom views

Custom buttons

Defining the custom button's properties

Overriding the button's draw method

Filling a path

Stroking a path

Drawing the icon with code

Adding an alternative icon

Testing the button

Dial clock

Creating a custom view with AppKit

Overriding the custom view's draw method

Drawing arcs

Drawing the outline

Adding the fill color

Adding the minutes curve

Adding the hours curve

Correcting the order of drawing

Pie clock

Creating a custom view with Core Graphics

Understanding CGContext

Why do we need a graphics context?

Understanding the CG coordinates system

Creating the custom class

Overriding the class's draw method

The draw method

The drawFace method

Adding a gradient with AppKit

The drawMinutes method

Adding a gradient with Core Graphics

Adding more color locations

The drawHours method

Context translation

Context rotation

Translating the context

Rotating the text

Adding the hour displacement

Adding shadows

Context scaling

Summary

Core Animation

What is Core Animation?

Where does Core Animation fit in?

Layer backed and layer hosting

Drawing then animating

Introducing CALayer

Creating a project

Adding a custom view

Extending CGColor

Preparing the ViewController class

Adding a button in code

Building CALayer objects

Adding CA sublayers

Exploring glows and shadows

Adding a CAShapeLayer

CAShapeLayer properties

CGPaths

Adding CA transformations

Rotating a layer in 3D

Using CATextLayer

Animating CALayer objects

CA implicit animations

CA explicit animations

CABasicAnimation

CABasicAnimation and the view model

Delaying an animation

Using CAKeyframeAnimation

Controlling animations with CAAnimationGroup

Wrapping changes in CATransaction objects

Affine transformation

Adding CATransaction completion blocks

Nesting CATransaction blocks

Two-and-a-half dimensional animations

Adding perspective

Getting even closer to 3D

Introducing CATransformLayer

Composing CALayers onto CATransformLayer

Rotating the CATransformLayer

Adding 3D animation

Animating NSViews

Summary

Handling Errors Gracefully

Errors aren't mistakes

Expecting the unexpected

Optionals

Explicit error handling

Swift error handling

The four ways of handling errors

Error types

Creating the simplest Error enum

Creating a better Error enum

Throwing an error

Handling an error

The error life cycle

Asserting that the error will not occur

Handling the error as an optional value

Handling an error with do-catch

Pattern matching

Matching associated values

Propagating an error

Propagation - case study: handling in scope

Propagation - case study: propagation

Verbose errors

Anything can be an error

NSError handling

Anatomy of an NSError

Catching NSErrors

Pattern-matched Cocoa catches

Creating NSError instances in Swift

Summary

Persistent Storage

Creating a project

Creating the project's file manager

Using UserDefaults

Storage of simple objects

Storing simple objects

Using the synchronize method

Loading simple objects

Testing the code

Storing structured data

Saving structured data

Loading structured data

Testing the code

Loading by type

Testing the code

UserDefaults convenience methods

Saving with convenience methods

Loading the data

Testing the code

Security considerations

Saving text to the Documents folder

Create an extension and helper function

Storing textual data

Testing the save function

Loading text files

Testing the load function

NSCoding/NSKeyedArchiver

Creating an NSCoding--compliant class

Handling NSCoding--compliant objects

Saving NSCoding--compliant objects

Loading NSCoding--compliant objects

Testing the code

More complex objects

Presenting open and save dialog boxes

Summary

The Benefits of Core Data

What Core Data is and isn't

Elements of a Core Data model

Entities

Attributes

Relationships

Core Data Cocoa Bindings and no code

Create the project

Create a simple UI in Interface Builder

Adding the necessary UI objects to the Scene

Add an Array Controller

Setting up the data model

Preparing the View Controller

Connecting up to the storyboard

Connecting the buttons

Connecting the Array Controller

Setting up the table columns

Connecting the Table Cell Views

Connecting the text fields

Using our data model

Using NSPersistenceContainer

Adding an NSPersistentContainer instance

Delete the unneeded properties

Replacing references to the context

Creating a data manager class

Non-string entity attributes

Creating entity instances

What is a managed object context?

Fetching data

Adding relationships between entities

One-to-one relationships

One-to-many relationships

Adding relationships to the crew

Same thing the other way around

Sorted fetches

Sorting in the table view

Predicate fetching

Using other predicates

Searching for a string

Searching for a case - insensitive string

Combining predicates

Relationship predicates

Deleting the red guy

More about Core Data

The Core Data stack

NSManagedObjectModel

NSManagedObjectContext

NSPersistentStoreCoordinator

Does app X really need Core Data?

The pros

The cons

Making that decision

Summary

Connect to the World - Networking

Patterns for downloading data

Simplicity

Control

Downloading using closures

Starting a local test server on your machine

Starting the server

Creating a JSON file

Testing the server

Implementing an HTTP request manager

The web as an asynchronous entity

The simplest request possible

The completion handler

Improving the simplest request possible

Customizing URLSessionConfiguration properties

Customizing URLRequest properties

Customizing URLSessionTask properties

Downloading using a URLSession delegate

Adding HTTP compatibility to the app

Creating a simple UI

Creating the manager

Creating a session delegate class

URLSessionDownloadDelegate methods

Handling the data

Catching errors

Getting progress information

Canceling a download

URLSessionTaskDelegate methods

Adding suspend and resume

No third-party frameworks?

The URLSession framework

URLSessionTasks

Ephemeral sessions

Cache rewards

Using different request cache policies

Summary

Concurrency and Asynchronous Programming

Concurrency and asynchronicity

Concurrency

Concurrency and parallelism

Multithreading

Multiprocessing

Threads and why you don't need to worry

Asynchronicity

The challenges of asynchronous programming

Dependencies and why you don't need to worry

Operation framework

Understanding operations and queues

Basic use of an OperationQueue

Adding dependencies to BlockOperations

More BlockOperation features

BlockOperation completion blocks

Defining a custom Operation object

Concurrent and non-concurrent operations

Defining non-concurrent custom operations

Defining concurrent custom operations

Summary

Understanding Xcodes Debugging Tools

Checking out Xcode's debugging tools

Debug area

Variables view

Using Quicklook

Console view

Debugging in the navigator area

Debug navigator

Hiding and showing additional information

Changing the process view

Breakpoint navigator

Report navigator

Leveraging breakpoints

Different types of breakpoint

Swift error breakpoints

Symbolic breakpoints

Other breakpoint types

Adding and removing breakpoints

Editing breakpoints

Conditions

Ignore

Adding an action to a breakpoint

Log message

Debugger Command

Shell Command

AppleScript

We can also get a little more ambitious with these actions

Sounds

Multiple actions

Breakpoint control flow

Debugger control

Close

Enable

Continue

Step over

Step into

Step out

Trying them out

Summary

LLDB and the Command Line

LLDB

Using LLDB

Debugging line-by-line

Continue

Step over

Step into

Step out

Trying it out

Enable

Printing in LLDB

Preparing classes for LLDB descriptions

Stop hooks

Printing formatted numbers

Executing code from LLDB

Type lookups

Breakpoints in LLDB

Adding a breakpoint

Breakpoint list

Attaching commands to breakpoints

Creating a Swift Error breakpoint

Naming breakpoints

Watchpoints

Adding conditions and commands

Watchpoint lists

Enabling disabling and deleting watchpoints

Persistent customization

Getting help in LLBD

Using shell commands in LLDB

REPL in LLDB

Switching between LLDB and Swift REPL

Leaving a REPL session

Using Python in LLDB

Accessing program variables from Python

Switching between LLDB and Python REPL

One liners from LLDB to Python

Getting help in Python

Altogether now

Standalone LLDB

Running Xcode projects in a standalone LLDB session

Differences between standalone and Xcode LLDB

Summary

Deploying Third - Party Code

Common use cases

Distribution methods

Third - party source code

Third - party libraries

Third-party frameworks

But the Internet says...

Pros and cons

The case for third - party code

The case against

The take-away

A case study

Leaving it till later

Different installation methods

Manual source code integration

Downloading the ZIP

Cloning the repo

Preparing to clone

Installing Homebrew

Installing Git

Cloning the repository

Importing the source code

Swift Package Manager

SPM products

Adding the package to an Xcode project

Over to Xcode

Package baggage

Other package managers

Cocoapods

Carthage

The price of complexity

Summary

Wrapping It Up

App distribution

The right settings on project creation

The product name

Team

The Organization Identifier

Bundle ID

Setting up the project

Setting the Application Category

Enabling sandboxing

Your developer account

Registering an app ID

Providing the required icons

Archiving the app

Validating the archive

Uploading to the App Store

Creating app records in iTunes Connect

Uploading from Xcode to the App Store

Exporting the app for distribution

Save for Mac App Store Deployment

Testing the Installer package

Export a Developer ID-signed Application

Export a Development-signed Application

Export as a macOS App

Summary

And finally