✍️ Note

All the codes and contents are sourced from Apple’s official documentation. This post is for personal notes where I summarize the original contents to grasp the key concepts

Apple documents

DispatchQueue

QoS (Quality of Service)

• UserInteractive
  • Animations, event handling, or updates to your app’s user interface.
  • User-interactive tasks have the highest priority on the system. Use this class for tasks or queues that interact with the user or actively update your app’s user interface. For example, use this class for animations or for tracking events interactively.
• UserInitiated
  • Prevent the user from actively using your app
  • User-initiated tasks are second only to user-interactive tasks in their priority on the system. Assign this class to tasks that provide immediate results for something the user is doing, or that would prevent the user from using your app. For example, you might use this quality-of-service class to load the content of an email that you want to display to the user.
• Default
  • Default tasks have a lower priority than user-initiated and user-interactive tasks, but a higher priority than utility and background tasks. Assign this class to tasks or queues that your app initiates or uses to perform active work on the user’s behalf.
• Utility
  • Utility tasks have a lower priority than default, user-initiated, and user-interactive tasks, but a higher priority than background tasks. Assign this quality-of-service class to tasks that do not prevent the user from continuing to use your app. For example, you might assign this class to long-running tasks whose progress the user does not follow actively.
• Background
  • Background tasks have the lowest priority of all tasks. Assign this class to tasks or dispatch queues that you use to perform work while your app is running in the background.

let concurrentQueue = DispatchQueue(label: "concurrent", qos: .userInitiated, attributes: 
.concurrent)
let serialQueue = DispatchQueue(label: "serial", qos: . userInitiated)

Example 1. Perform async tasks on serialQueue

for i in 0...3 {
  serialQueue.async {
    print("serial task(\(i)) start")
    sleep(1)
    print("serial task(\(i)) end")
  }
}

//prints
serial task(0) start
serial task(0) end

serial task(1) start
serial task(1) end

serial task(2) start
serial task(2) end

serial task(3) start
serial task(3) end

It’s make sense because serialQueue can run a one task at a time.

Example 2. Perform sync tasks on serialQueue

for i in 0...3 {
  serialQueue.sync {
    print("serial task(\(i)) start")
    sleep(1)
    print("serial task(\(i)) end")
  }
}

//prints
serial task(0) start
serial task(0) end

serial task(1) start
serial task(1) end

serial task(2) start
serial task(2) end

serial task(3) start
serial task(3) end

Results are the same as example 1

Submits a work item for execution on the current queue and returns after that block finishes executing.

https://developer.apple.com/documentation/dispatch/dispatchqueue/2016083-sync

Example 3. Perform a sync task on the concurrentQueue

for i in 0...3 {
  concurrentQueue.sync {
    print("concurrent task(\(i)) start")
    sleep(1)
    print("concurrent task(\(i)) end")
  }
}

//Prints
concurrent task(0) start
concurrent task(0) end

concurrent task(1) start
concurrent task(1) end

concurrent task(2) start
concurrent task(2) end

concurrent task(3) start
concurrent task(3) end

Example 4. Perform a async task on the concurrentQueue

for i in 0...3 {
  concurrentQueue.async {
    print("concurrent task(\(i)) start")
    sleep(1)
    print("concurrent task(\(i)) end")
  }
}

//Prints
concurrent task(0) start
concurrent task(3) start
concurrent task(1) start
concurrent task(2) start

concurrent task(0) end
concurrent task(1) end
concurrent task(3) end
concurrent task(2) end

Schedules a work item for immediate execution, and returns immediately.

https://developer.apple.com/documentation/dispatch/dispatchqueue/2016103-async

It immediate execution and returns immediately.

Example 5. Perform async task on the concurrentQueue and sync task on the serialQueue

for i in 0...3 {
  concurrentQueue.async {
    print("concurrent task(\(i)) start")
    sleep(1)
    print("concurrent task(\(i)) end")
  }
            
  serialQueue.sync {
    print("serial task(\(i)) start")
    sleep(1)
    print("serial task(\(i)) end")
  }
}

//Prints
concurrent task(0) start
serial task(0) start
serial task(0) end
serial task(1) start
concurrent task(1) start
concurrent task(0) end
concurrent task(1) end
serial task(1) end
serial task(2) start
concurrent task(2) start
serial task(2) end
serial task(3) start
concurrent task(3) start
concurrent task(2) end
serial task(3) end
concurrent task(3) end

Example 6. Run async tasks on the concurrentQueue and serialQueue

for i in 0...3 {
   concurrentQueue.async {
     print("concurrent task(\(i)) start")
     sleep(1)
     print("concurrent task(\(i)) end")
   }

   serialQueue.async {
     print("serial task(\(i)) start")
     sleep(1)
     print("serial task(\(i)) end")
   }
}

//Prints
concurrent task(0) start
concurrent task(2) start
concurrent task(3) start
serial task(0) start
concurrent task(1) start
concurrent task(3) end
concurrent task(0) end
concurrent task(2) end
serial task(0) end
concurrent task(1) end
serial task(1) start
serial task(1) end
serial task(2) start
serial task(2) end
serial task(3) start
serial task(3) end

As you can see a SerialQueue run a task and returned when task has finished either perform it on sync or async.

What about dispatchQueue.main.async?

for i in 0...3 {
  DispatchQueue.main.async {
    print("main task(\(i)) start")
    sleep(1)
    print("main task(\(i)) end")
  }
}

//Prints
main task(0) start
main task(0) end

main task(1) start
main task(1) end

main task(2) start
main task(2) end

main task(3) start
main task(3) end

The dispatch queue associated with the main thread of the current process.

The system automatically creates the main queue and associates it with your application’s main thread. Your app uses one (and only one) of the following three approaches to execute blocks submitted to the main queue:

• Calling dispatchMain()
• Starting your app with a call to UIApplicationMain(_:_:_:_:) (iOS) or NSApplicationMain(_:_:)(macOS) 
• Using a CFRunLoop on the main thread

As with the global concurrent queues, calls to suspend(), resume(), dispatch_set_context(_:_:), and the like have no effect when used on the queue in this property.

https://developer.apple.com/documentation/dispatch/dispatchqueue/1781006-main

As the results, It is not returns immediately like a concurrent queue. Because It’s a serial queue. You can check it on Xcode.

What about dispatchQueue.global().async?

for i in 0...3 {
  DispatchQueue.global().async {
    print("global task(\(i)) start")
    sleep(1)
    print("global task(\(i)) end")
  }
}

//Prints
global task(3) start
global task(2) start
global task(0) start
global task(1) start

global task(1) end
global task(0) end
global task(3) end
global task(2) end

This method returns a queue suitable for executing tasks with the specified quality-of-service level. Calls to the suspend(), resume(), and dispatch_set_context(_:_:) functions have no effect on the returned queues.

Tasks submitted to the returned queue are scheduled concurrently with respect to one another

https://developer.apple.com/documentation/dispatch/dispatchqueue/2300077-global

🤯 When function is returned?

It’s a good example for understanding sync vs async.

Before look at the example, let’s remind

Dispatch queues are FIFO queues to which your application can submit tasks in the form of block objects. Dispatch queues execute tasks either serially or concurrently. Work submitted to dispatch queues executes on a pool of threads managed by the system. Except for the dispatch queue representing your app’s main thread, the system makes no guarantees about which thread it uses to execute a task.

You schedule work items synchronously or asynchronously. When you schedule a work item synchronously, your code waits until that item finishes execution. When you schedule a work item asynchronously, your code continues executing while the work item runs elsewhere.

https://developer.apple.com/documentation/dispatch/dispatchqueue

ConcurrentQueue with sync

runWorkItem function is returned when after finishing the sync task.

ConcurrentQueue with async

runWorkItem function returned and then async task starts

SerialQueue with async

DispatchQueue.main.async

Custom Serial DispatchQueue

SerialQueue with sync but what if a submitted task is delayed?

Keep in mind

Work submitted to dispatch queues executes on a pool of threads managed by the system. Except for the dispatch queue representing your app’s main thread, the system makes no guarantees about which thread it uses to execute a task.

https://developer.apple.com/documentation/dispatch/dispatchqueue

sync -> block will run and returned when task finished

async -> block will immediately returned when task started

	sync	async	when function returned?
SerialQeueue	wait until task finished	wait until task finished	either sync or async it returned when after task finished
ConcurrentQueue	wait until task finished	immediately return when task started	sync: it returned after task finished async: it returned before task finished

✍️ Note

All the codes and contents are sourced from Apple’s official documentation. This post is for personal notes where I summarize the original contents to grasp the key concepts

Apple document

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is being initialized")
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

Check Strong Reference Count

Example 1

var person = Person(name: "Shawn") //1
CFGetRetainCount(person) //2

Example 2

CFGetRetainCount(Person(name: "Shawn") //1

Example 3

var person = Person(name: "Shawn") //2
var person2 = person //3
var person3 = person //4

CFGetRetainCount(person) //4

As you can see when you initiate an object, the retain count is 1. And when you assign it, retain count will be counting up.

Strong Reference Cycle between classes

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}


class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

Example 1

var person = Person(name: "Shawn")
var apt = Apartment(unit: "3")

CFGetRetainCount(person) //2
CFGetRetainCount(apt) //2

Example 2 (🔥 Strong Reference Cycle)

var person = Person(name: "Shawn")
var apt = Apartment(unit: "3")

person.apartment = apt
apt.tenant = person

CFGetRetainCount(person) //3 (apt.tenant -> count up)
CFGetRetainCount(apt) //3 (person.apartment -> count up)

✅ Solution -> weak / unowned

What is weak reference and when to use it?

Use a weak reference when the other instance has a shorter lifetime — that is, when the other instance can be deallocated first.

Apple – https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting

ARC automatically sets a weak reference to nil when the instance that it refers to is deallocated. And, because weak references need to allow their value to be changed to nil at runtime, they’re always declared as variables, rather than constants, of an optional type.

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}


class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    weak var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

What is unowned reference and when to use it?

In contrast, use an unowned reference when the other instance has the same lifetime or a longer lifetime. Unlike a weak reference, an unowned reference is expected to always have a value. As a result, marking a value as unowned doesn’t make it optional, and ARC never sets an unowned reference’s value to nil.

Important

Use an unowned reference only when you are sure that the reference always refers to an instance that hasn’t been deallocated.

If you try to access the value of an unowned reference after that instance has been deallocated, you’ll get a runtime error.

Apple – https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("\(name) is being deinitialized") }
}


class CreditCard {
    let number: UInt64
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}

Example 1

var customer: Customer! = Customer(name: "Shawn")
customer.card = CreditCard(number: 7788_9999_1223_1225, customer: customer)

CFGetRetainCount(customer) //2 (because CreditCard's customer is defined as unowned let)

customer = nil

//Shawn is being deinitialized
//Card #7788999912231225 is being deinitialized 

unowned(unsafe)

Swift also provides unsafe unowned references for cases where you need to disable runtime safety checks — for example, for performance reasons. As with all unsafe operations, you take on the responsibility for checking that code for safety. You indicate an unsafe unowned reference by writing unowned(unsafe). If you try to access an unsafe unowned reference after the instance that it refers to is deallocated, your program will try to access the memory location where the instance used to be, which is an unsafe operation.

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting

When you access the unowned(unsafe), It try to access the memory location where the instance used to be

when use unowned, error type is different.

Unowned Optional References

You can mark an optional reference to a class as unowned. In terms of the ARC ownership model, an unowned optional reference and a weak reference can both be used in the same contexts. The difference is that when you use an unowned optional reference, you’re responsible for making sure it always refers to a valid object or is set to nil.

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting

class Department {
    var name: String
    var courses: [Course]
    init(name: String) {
        self.name = name
        self.courses = []
    }
}


class Course {
    var name: String
    unowned var department: Department
    unowned var nextCourse: Course?
    init(name: String, in department: Department) {
        self.name = name
        self.department = department
        self.nextCourse = nil
    }
}

Example

var department: Department! = Department(name: "Horticulture")

let intro = Course(name: "Survey of Plants", in: department)
var intermediate: Course! = Course(name: "Growing Common Herbs", in: department)
var advanced: Course = Course(name: "Caring for Tropical Plants", in: department)

intro.nextCourse = intermediate
intermediate.nextCourse = advanced
department.courses = [intro, intermediate, advanced]

//Deinit department and intermediate
department = nil
intermediate = nil

//Try to access nextCourse
intro.nextCourse //SIGABRT Error

Unlike weak, when you try to access the deallocated object, It causes a crash issue. Even you set it as unowned optionals.

Unowned References and Implicitly Unwrapped Optional Properties

class Country {
    let name: String
    var capitalCity: City! //Unwrapped Optional Properties
    init(name: String, capitalName: String) {
        self.name = name
        //At this point, Country already initiated. So can pass self to City initializer
        self.capitalCity = City(name: capitalName, country: self)
    }
}


class City {
    let name: String
    unowned let country: Country //Unowned References
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
}

var capitalCity: City!

• It’s initial value is nil

Above the example is Two-Phased initialization

🤔 Strong Reference Cycles for Closures

It’s such an important topic.

A strong reference cycle can also occur if you assign a closure to a property of a class instance, and the body of that closure captures the instance. This capture might occur because the closure’s body accesses a property of the instance, such as self.someProperty, or because the closure calls a method on the instance, such as self.someMethod(). In either case, these accesses cause the closure to “capture” self, creating a strong reference cycle.

This strong reference cycle occurs because closures, like classes, are reference types. When you assign a closure to a property, you are assigning a reference to that closure. In essence, it’s the same problem as above — two strong references are keeping each other alive. However, rather than two class instances, this time it’s a class instance and a closure that are keeping each other alive.

Swift provides an elegant solution to this problem, known as a closure capture list

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/automaticreferencecounting

class HTMLElement {
    let name: String
    let text: String?

    lazy var asHTML: () -> String = {
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())

//Deallocate HTMLElement
paragraph = nil // Can't deallocate it because the reference cycle between property (asHTML) and closure's capture list

Even though the closure refers to self multiple times (self.text and self.name), it only captures one strong reference to the HTMLElement instance.

Apple

Resolving Strong Reference Cycles for Closures

Use weak or unowned at capture lists

Defining a capture list

Each item in a capture list is a pairing of the weak or unowned keyword with a reference to a class instance (such as self) or a variable initialized with some value (such as delegate = self.delegate). These pairings are written within a pair of square braces, separated by commas.

Place the capture list before a closure’s parameter list and return type if they’re provided:

Apple

lazy var someClosure = {
        [unowned self, weak delegate = self.delegate]
        (index: Int, stringToProcess: String) -> String in
    // closure body goes here
}


lazy var someClosure2 = {
        [unowned self, weak delegate = self.delegate] in
    // closure body goes here
}

🔥 Think it again, weak vs unowned in Closures

Define a capture in a closure as an unowned reference when the closure and the instance it captures will always refer to each other, and will always be deallocated at the same time.

Conversely, define a capture as a weak reference when the captured reference may become nil at some point in the future. Weak references are always of an optional type, and automatically become nil when the instance they reference is deallocated. This enables you to check for their existence within the closure’s body.

Apple

class HTMLElement {
    let name: String
    let text: String?
    //Use unowned self to break reference cycle
    lazy var asHTML: () -> String = {
            [unowned self] in
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

Capture value from nested Closure

class Test {}
DispatchQueue.global().async {
  let test = Test()
   print("closure A: Start retain count is: \(CFGetRetainCount(test))")
   DispatchQueue.global().async {
     print("nested closure B retainCount: \(CFGetRetainCount(test))")
   }
   print("closure A: End")
}

//Prints
closure A: Start retain count is: 2
closure A: End
nested closure B retainCount: 3

As you can see nested closure also counting up ARC.

But… what about this example?

test object was already deallocated. And when you trying to access test, It should not be nil because It’s unowned.

Conclusion

Understanding How ARC works is very important to avoid memory leaks and crash issues. It’s also good to know what happens when objects are deallocated and How ARC handles those objects.

I asked my self Is python worth to learn for iOS development? My answer is Yes.

Because I can use it for

• Build scripts
• Core ML + coreml tools
• BE for Mobile (Django)

Getting Principles

• You can read the list of the python principles by importing this

import this

Cheatsheet

Standard Library	Swift	Python
variable	var name = "Shawn"	name = "Shawn"
constants	let name = "Shawn"	Not support But UPPERCASED Naming indicates constants It’s like a implicit rule in Python
string	"Hello World!" Multiline String """ Hello Swift """ Extended Delimiters #"Hello\n Swift"# It will print Hello\n Swift	"Hello World!" 'Hello World!' Swift can’t use single quote but Python can use
formatted string	let name = "Shawn" "My name is \(name)"	name = "Shawn" f"My name is {name}" f means formatted string
capitalized	var greeting = “shawn baek” print(greeting.capitalized) //’Shawn Baek’	name = “shawn baek” print(name.title()) //’Shawn Baek’
uppercased / lowercased	var greeting = “Shawn Baek” print(greeting.uppercased()) //’SHAWN BAEK’ print(greeting.lowercased()) //’shawn baek’	name = “Shawn Baek” print(name.upper()) //’SHAWN BAEK’ print(name.lower()) //’shawn baek’
trimmingCharacters(in: .whitespacesAndNewlines)	var greeting = ” Shawn Baek “ //MARK: Remove leading / trailing spaces greeting.trimmingCharacters(in: .whitespacesAndNewlines) //’Shawn Baek’	name = ” Shawn Baek “ name.rstrip() // ‘ Shawn Baek’ name.lstrip() //’Shawn Baek ‘ name.strip() //’Shawn Baek’
trimPrefix	var blogUrl = “https://shawnbaek.com” blogUrl.trimPrefix(“https://&#8221😉 //’shawnbaek.com’	blog_url = ‘https://shawnbaek.com’ blog_url.removeprefix(‘https://&#8217😉 //’shawnbaek.com’
pow	var number = pow(3.0, 2.0) print(number) //9.0	number = 3.0 ** 2 print(number) //9.0
comment	//Hello World	#Hello World

 

#!/bin/sh
brew install jq

 

#!/bin/zsh
#  ci_post_xcodebuild.sh

# PR Description
GITHUB_REST_API_PR_INFO=$(curl -L\
  -H "Accept: vnd.github+json" \
  -H "Authorization: Bearer $GITHUB_TOKEN" \
  -H "X-GitHub-Api-Version: 2022-11-28" \
  "https://api.github.com/repos/$CI_PULL_REQUEST_TARGET_REPO/pulls/$CI_PULL_REQUEST_NUMBER")

# Fixed: parse error: Invalid string: control characters from U+0000 through U+001F must be escaped, https://stackoverflow.com/questions/52399819/invalid-string-control-characters-from-u0000-through-u001f-must-be-escaped-us
PR_TITLE=$(printf '%s\n' "$GITHUB_REST_API_PR_INFO" | jq -r '.title')

PR_DESCRIPTION=$(printf '%s\n' "GITHUB_REST_API_PR_INFO" | jq -r '.body')
PR_DESCRIPTION_URLS=$(echo "$PR_DESCRIPTION" | grep -Eo 'https?://[^[:space:]]+')
PR_DESCRIPTION_JIRA_TICKETS=$(echo "$PR_DESCRIPTION_URLS" | grep 'atlassian')

# GIT COMMITS
COMMIT_MESSAGES=$(git log $CI_PULL_REQUEST_TARGET_COMMIT^..$CI_PULL_REQUEST_SOURCE_COMMIT --pretty=format:"%s\n%b")
FORMATTED_COMMIT_MESSAGES=$(echo -e "$COMMIT_MESSAGES" | awk 'NF {print}' ORS='\n')

# TEST FLIGHT - What To Test
WHAT_TO_TEST="$PR_TITLE\nCommits:\n$FORMATTED_COMMIT_MESSAGES\nJIRA Tickets:\n$PR_DESCRIPTION_JIRA_TICKETS"

if [[ -d "$CI_APP_STORE_SIGNED_APP_PATH" ]]; then
  TESTFLIGHT_DIR_PATH=../TestFlight
  mkdir $TESTFLIGHT_DIR_PATH
  echo "$WHAT_TO_TEST" >! $TESTFLIGHT_DIR_PATH/WhatToTest.en-US.txt
fi

 

CURRENT_PROJECT_VERSION=$(xcodebuild -project $CI_PROJECT_FILE_PATH -showBuildSettings | grep "MARKETING_VERSION" | sed 's/[ ]*MARKETING_VERSION = //')

echo "🐥 App Version is $CURRENT_PROJECT_VERSION"