Dig into Value types. It's really obvious when to use them. Or not?!

Dig into Value types. It's really obvious when to use them. Or not?!

Talk by Maksym Husar.

"Мы каждый день создаем и используем классы, структуры и перечисления, иногда даже не задумываясь, когда что лучше использовать и на что это может повлиять.
Все знают что классы это ссылочный тип, а структры - тип по значению.
Но все ли так просто? Всегда ли лучше использовать value types?
Мы копнем немного глубже “популярных” тезисов и рассмотрим особенности реализации и поведения типов по значению в зависимости от содержимого, вспомним о стеке, куче, управлении памятью и о производительности."

This talk was made for CocoaHeads Kyiv #15 which took place Jul 28, 2019. (https://cocoaheads.org.ua/cocoaheadskyiv/15)

Video: https://youtu.be/8L5cUiV1qDo

Db84cf61fdada06b63f43f310b68b462?s=128

CocoaHeads Ukraine

July 28, 2019
Tweet

Transcript

  1. Dig into Value types. It's really obvious when & how

    to use them. Or not?! Maksym Husar Mobile Team Lead, Indeema Software Inc.
  2. About me Creating inventive IoT solutions since 2014. We partner

    with companies worldwide, equipping them with tools to solve the most complex challenges. Maksym Husar • Mobile Team Lead at Indeema Software • In commercial iOS development since 2014 • Author of the “iOS Start: 0 to 1” course https://www.udemy.com/ios-start-zero-to-one-swift https://www.linkedin.com/in/maksymhusar/
  3. • First shareable air monitoring system. • Measures 5 air

    parameters • App receives readings from UBox • Alerts user when any of them is outside the limits UBreez For more information, scan QR Code: UBreez is the first shareable air monitoring system
  4. Agenda. A1. The Basics 2. Common Misconceptions 3. Recommendations

  5. The Basics. 1

  6. Value Type — each instance keeps a unique copy of

    its data. 1. The Basics “Pure” Value Types Reference Types Shared on assignment (Multiple owners) Copy on assignment (Single owner) From https://developer.apple.com/swift/blog/?id=10
  7. Swift Value Types != “Pure” Value Types Swift Value Types

    == Value Semantics 1. The Basics
  8. *Most of the time class Worker { let name: String

    var salary: Int init(name: String, salary: Int) { self.name = name; self.salary = salary } } let obj = Worker(name: "Jackie", salary: 1500) showDescription(of: obj) 1. The Basics The main advantage of (Swift)Value types: No unexpected data sharing*
  9. *Most of the time 1. The Basics The main advantage

    of (Swift)Value types: No unexpected data sharing* class Worker { let name: String var salary: Int init(name: String, salary: Int) { self.name = name; self.salary = salary } } let obj = Worker(name: "Jackie", salary: 1500) print("1) \(obj.salary)") // 1) 1500 showDescription(of: obj) print("2) \(obj.salary)") // 2) 200
  10. *Most of the time 1. The Basics The main advantage

    of (Swift)Value types: No unexpected data sharing* class Worker { let name: String var salary: Int init(name: String, salary: Int) { self.name = name; self.salary = salary } } let obj = Worker(name: "Jackie", salary: 1500) print("1) \(obj.salary)") // 1) 1500 showDescription(of: obj) print("2) \(obj.salary)") // 2) 200
  11. Consider the following recommendations to help you choose what option

    makes sense when adding a new data type to your app. • Use structures by default. • Use classes when you need Objective-C interoperability. • Use classes when you need to control the identity of the data you're modeling. • Use structures along with protocols to adopt behavior by sharing implementations. From https://developer.apple.com/documentation/swift/choosing_between_structu res_and_classes 1. The Basics
  12. Memory architecture basics (single thread for simplicity) |- - -

    - - - - - - - - - - - - - - - - - - - - - - - - - - - - | Stack |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | Nothing (Stack and heap grow towards here) |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | Heap |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | Global Data |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | Instructions |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | .......... 1. The Basics 0x0 (low address)
  13. Stack Memory: • Simple LIFO data structure • Decrement stack

    pointer to allocate • Increment stack pointer to deallocate • Thread-safe — 1 Stack per Thread • Not limitless — has an upper bound • Variables only exist while the function that created them exists • The cost of allocating/deallocating stack memory is literally the cost of assigning an integer Stack ... 1. The Basics
  14. Heap Memory: • Advanced data structure • Search for unused

    block of memory to allocate • Reinsert block of memory to deallocate • Shared memory requires synchronization • It’s large and usually limited by the available physical memory • Requires pointers to access it Heap 1. The Basics
  15. Common Misconceptions. 2

  16. • “Reference type instances are stored in the Heap and

    instances of a value type such as struct reside in the Stack” • “Structs are always faster/more efficient than classes” • “Unexpected data sharing for Value types doesn’t exist” • “Value types provide thread safety. No Race Conditions” 2. Common Misconceptions
  17. • “Reference type instances are stored in the Heap and

    instances of a value type such as struct reside in the Stack” • “Structs are always faster/more efficient than classes” • “Unexpected data sharing for Value types doesn’t exist” • “Value types provide thread safety. No Race Conditions” 2. Common Misconceptions
  18. • “Reference type instances are stored in the Heap and

    instances of a value type such as struct reside in the Stack” • “Structs are always faster/more efficient than classes” • “Unexpected data sharing for Value types doesn’t exist” • “Value types provide thread safety. No Race Conditions” 2. Common Misconceptions
  19. • “Reference type instances are stored in the Heap and

    instances of a value type such as struct reside in the Stack” • “Structs are always faster/more efficient than classes” • “Unexpected data sharing for Value types doesn’t exist” • “Value types provide thread safety. No Race Conditions” 2. Common Misconceptions
  20. • “Reference type instances are stored in the Heap and

    instances of a value type such as struct reside in the Stack” • “Structs are always faster/more efficient than classes” • “Unexpected data sharing for Value types doesn’t exist” • “Value types provide thread safety. No Race Conditions” 2. Common Misconceptions
  21. 2. Common Misconceptions Misconception: Reference type instances are stored in

    the Heap, and instances of a value type such as struct reside in the Stack
  22. 2. Common Misconceptions Misconception: Reference type instances are stored in

    the Heap, and instances of a value type such as struct reside in the Stack For Reference type it’s 100% true. For Value type it’s partly true but with a lot of IFs Precise definition: For reference types, the reference is stored on the Stack while the object it refers to is stored on the Heap.
  23. 2. Common Misconceptions Value type storage depending on the contents/circumstances*

    * Default behavior can be changed by compiler optimizations in specific cases ** Size may vary depending on Swift version a. Stack (fully stack allocated) b. Heap Swift standard library value types: Static size Dynamic size (Unknown actual size at compilation time) User-defined value types: All properties are static-sized Contained inside a reference type Optimization: Allocated as an abstract type with size ≤ 3** words Size cannot be determined during compilation time (because of a protocol/generic requirement) Contains recursions Potentially, gigantic static sized instances
  24. 2. Common Misconceptions Value type storage depending on the contents/circumstances*

    * Default behavior can be changed by compiler optimizations in specific cases c. Stack (mix: stack + heap)
  25. 2. Common Misconceptions Value type storage depending on the contents/circumstances*

    * Default behavior can be changed by compiler optimizations in specific cases c. Stack (mix: stack + heap) User-defined value types: • Contain reference type properties • Contain dynamic-sized value type properties Stack Heap b: Double ref: Class x1: Int x2: Int a: Int
  26. String, Array, Dictionary, and Set are value types that contain

    internal reference types. These types manage the storage of elements in the heap, allowing them to increase/decrease in size as needed. 2. Common Misconceptions
  27. Value semantics implementations Copy-on-Assignment (Stack) Copy-on-Write (Heap) 2. Common Misconceptions

  28. 2. Common Misconceptions The easiest way to find out the

    storage type of value instance is to create a copy and compare addresses
  29. 2. Common Misconceptions The easiest way to find out the

    storage type of value instance is to create a copy and compare addresses Let’s try to implement!
  30. 2. Common Misconceptions func printAddress(of object: UnsafeRawPointer) { let addr

    = Int(bitPattern: object) let address = String(format: "%p", addr) print(address) } struct User { var name: String } var user = User(name: "Bob") printAddress(of: &user) // 0x7ffee88208b0 var clone = user printAddress(of: &user) // 0x7ffee88208b0 printAddress(of: &clone)// 0x7ffee88208a0
  31. 2. Common Misconceptions var arr = [1, 2, 3] var

    arrCopy = arr printAddress(of: arr) // 0x6000000191a0 printAddress(of: arrCopy) // 0x6000000191a0 arrCopy[0] = 10 printAddress(of: arr) // 0x6000000191a0 printAddress(of: arrCopy) // 0x6000000196a0
  32. 2. Common Misconceptions class Container { var i = 10

    var user = User(name: "Bob") } let cont = Container() printAddress(of: &cont.user) // 0x7ffee48fd888 var userCopy = cont.user printAddress(of: &userCopy) // 0x7ffee48fd888 userCopy.name = "Ben" printAddress(of: &cont.user) // 0x7ffee48fd878 printAddress(of: &userCopy) // 0x7ffee48fd888
  33. 2. Common Misconceptions Misconception: Structs are always faster/more efficient than

    classes
  34. 2. Common Misconceptions Misconception: Structs are always faster/more efficient than

    classes The performance of Value type depends a lot on the content and compiler optimizations
  35. 2. Common Misconceptions Misconception: Structs are always faster/more efficient than

    classes The performance of Value type depends a lot on the content and compiler optimizations Since Swift 4.2, performance has increased dramatically and the language internals have changed a lot Currently used Swift version: 5.0
  36. 2. Common Misconceptions Critical to understand performance:

  37. 2. Common Misconceptions Critical to understand performance: • If value

    type contains heap-allocated property, then it will not be heap- allocated itself, but it will inherit reference counting overhead to be able to keep it's inner references alive. • String, Array, Dictionary, Set are value types that contain internal reference types that manage the storage of elements in the heap, allowing them to increase/decrease in size as needed.
  38. 2. Common Misconceptions final class TinyClass { } final class

    ClassOfClasses { let class1 = TinyClass() let class2 = TinyClass() let class3 = TinyClass() } struct StructOfClasses { let class1 = TinyClass() let class2 = TinyClass() let class3 = TinyClass() }
  39. 2. Common Misconceptions let classOfClasses = ClassOfClasses() let ref1 =

    classOfClasses let ref2 = classOfClasses let ref3 = classOfClasses print(CFGetRetainCount(classOfClasses)) // 4 print(CFGetRetainCount(classOfClasses.class1)) // 1 print(CFGetRetainCount(classOfClasses.class2)) // 1 print(CFGetRetainCount(classOfClasses.class3)) // 1 let structOfClasses = StructOfClasses() let copy = structOfClasses let copy2 = structOfClasses let copy3 = structOfClasses // Doesn't compile, structs themselves don't have a reference count. // print(CFGetRetainCount(structOfClasses)) print(CFGetRetainCount(structOfClasses.class1)) // 4 print(CFGetRetainCount(structOfClasses.class2)) // 4 print(CFGetRetainCount(structOfClasses.class3)) // 4
  40. 2. Common Misconceptions For some large values, creating copies could

    be time-consuming and hurt the performance of the program.
  41. 2. Common Misconceptions struct EnumsStringStruct { enum TestEnum: String {

    case a = "something", b, c, d } var p1 = TestEnum.a var p2 = TestEnum.b var p3 = TestEnum.c var p4 = TestEnum.d var p5 = TestEnum.a } struct StringsStruct { var p1 = "test1" var p2 = "testTestTest" var p3 = "random string" ... var p20 = "1234567890" } Let’s test the speed of copying items. Number of iterations: 10 000 000. Results in seconds.
  42. 2. Common Misconceptions Let’s test the speed of copying items.

    Number of iterations: 10 000 000. Results in seconds. Struct (Int) Struct (String) Class (Int) Class (String) Struct (Enum) Struct (Enum: String) 5 fields 0.0187 0.274 0.349 0.34 0.0189 0.0213 10 fields 0.0314 0.518 0.343 0.342 0.0176 0.0214 20 fields 0.0555 1.04 0.344 0.373 0.0172 0.0194 50 fields 0.125 2.45 0.343 0.338 0.0983 0.104 Source code: https://github.com/maksymhusar/ValueTypePerformance.git
  43. 2. Common Misconceptions Let’s test the speed of copying items.

    Number of iterations: 10 000 000. Results in seconds. Struct (Int) Struct (String) Class (Int) Class (String) Struct (Enum) Struct (Enum: String) 5 fields 0.0187 0.274 0.349 0.34 0.0189 0.0213 10 fields 0.0314 0.518 0.343 0.342 0.0176 0.0214 20 fields 0.0555 1.04 0.344 0.373 0.0172 0.0194 50 fields 0.125 2.45 0.343 0.338 0.0983 0.104 Source code: https://github.com/maksymhusar/ValueTypePerformance.git ~x15
  44. 2. Common Misconceptions Let’s test the speed of copying items.

    Number of iterations: 10 000 000. Results in seconds. Struct (Int) Struct (String) Class (Int) Class (String) Struct (Enum) Struct (Enum: String) 5 fields 0.0187 0.274 0.349 0.34 0.0189 0.0213 10 fields 0.0314 0.518 0.343 0.342 0.0176 0.0214 20 fields 0.0555 1.04 0.344 0.373 0.0172 0.0194 50 fields 0.125 2.45 0.343 0.338 0.0983 0.104 Source code: https://github.com/maksymhusar/ValueTypePerformance.git
  45. 2. Common Misconceptions Let’s test the speed of copying items.

    Number of iterations: 10 000 000. Results in seconds. Struct (Int) Struct (String) Class (Int) Class (String) Struct (Enum) Struct (Enum: String) 5 fields 0.0187 0.274 0.349 0.34 0.0189 0.0213 10 fields 0.0314 0.518 0.343 0.342 0.0176 0.0214 20 fields 0.0555 1.04 0.344 0.373 0.0172 0.0194 50 fields 0.125 2.45 0.343 0.338 0.0983 0.104 Source code: https://github.com/maksymhusar/ValueTypePerformance.git
  46. 2. Common Misconceptions Let’s test the speed of copying items.

    Number of iterations: 10 000 000. Results in seconds. Struct (Int) Struct (String) Class (Int) Class (String) Struct (Enum) Struct (Enum: String) 5 fields 0.0187 0.274 0.349 0.34 0.0189 0.0213 10 fields 0.0314 0.518 0.343 0.342 0.0176 0.0214 20 fields 0.0555 1.04 0.344 0.373 0.0172 0.0194 50 fields 0.125 2.45 0.343 0.338 0.0983 0.104 Source code: https://github.com/maksymhusar/ValueTypePerformance.git
  47. 2. Common Misconceptions Let’s test the speed of copying items.

    Number of iterations: 10 000 000. Results in seconds. Struct (Int) Struct (String) Class (Int) Class (String) Struct (Enum) Struct (Enum: String) 5 fields 0.0187 0.274 0.349 0.34 0.0189 0.0213 10 fields 0.0314 0.518 0.343 0.342 0.0176 0.0214 20 fields 0.0555 1.04 0.344 0.373 0.0172 0.0194 50 fields 0.125 2.45 0.343 0.338 0.0983 0.104 Source code: https://github.com/maksymhusar/ValueTypePerformance.git ~x3
  48. 2. Common Misconceptions Let’s test the speed of copying items.

    Number of iterations: 10 000 000. Results in seconds. Struct (Int) Struct (String) Class (Int) Class (String) Struct (Enum) Struct (Enum: String) 5 fields 0.0187 0.274 0.349 0.34 0.0189 0.0213 10 fields 0.0314 0.518 0.343 0.342 0.0176 0.0214 20 fields 0.0555 1.04 0.344 0.373 0.0172 0.0194 50 fields 0.125 2.45 0.343 0.338 0.0983 0.104 Source code: https://github.com/maksymhusar/ValueTypePerformance.git ~x54
  49. 2. Common Misconceptions Let’s test the speed of copying items.

    Number of iterations: 10 000 000. Results in seconds. Struct (Int) Struct (String) Class (Int) Class (String) Struct (Enum) Struct (Enum: String) 5 fields 0.0187 0.274 0.349 0.34 0.0189 0.0213 10 fields 0.0314 0.518 0.343 0.342 0.0176 0.0214 20 fields 0.0555 1.04 0.344 0.373 0.0172 0.0194 50 fields 0.125 2.45 0.343 0.338 0.0983 0.104 Source code: https://github.com/maksymhusar/ValueTypePerformance.git ~x5.5
  50. 2. Common Misconceptions Let’s test the speed of copying items.

    Number of iterations: 10 000 000. Results in seconds. Struct (Int) Struct (String) Class (Int) Class (String) Struct (Enum) Struct (Enum: String) 5 fields 0.0187 0.274 0.349 0.34 0.0189 0.0213 10 fields 0.0314 0.518 0.343 0.342 0.0176 0.0214 20 fields 0.0555 1.04 0.344 0.373 0.0172 0.0194 50 fields 0.125 2.45 0.343 0.338 0.0983 0.104 Source code: https://github.com/maksymhusar/ValueTypePerformance.git
  51. 2. Common Misconceptions Let’s test the speed of copying items.

    Number of iterations: 10 000 000. Results in seconds. Struct (Int) Struct (String) Class (Int) Class (String) Struct (Enum) Struct (Enum: String) 5 fields 0.0187 0.274 0.349 0.34 0.0189 0.0213 10 fields 0.0314 0.518 0.343 0.342 0.0176 0.0214 20 fields 0.0555 1.04 0.344 0.373 0.0172 0.0194 50 fields 0.125 2.45 0.343 0.338 0.0983 0.104 Source code: https://github.com/maksymhusar/ValueTypePerformance.git ~x20
  52. 2. Common Misconceptions Indirect Storage can be used for a

    big structs to improve performance
  53. final class Ref<T> { var value: T init(value: T) {

    self.value = value } } struct Box<T> { private var ref: Ref<T> init(value: T) { ref = Ref(value: value) } var value: T { get { return ref.value } set { guard isKnownUniquelyReferenced(&ref) else { ref = Ref(value: newValue) return } ref.value = newValue } } } struct User { var name: String } let user = User(name: "Alexa") let box = Box(value: user) // boxCopy shares instance of box.ref var boxCopy = box // Creates new object for boxCopy.ref boxCopy.value.name = "Siri" print(box.value.name) // Alexa print(boxCopy.value.name) // Siri 2. Common Misconceptions Indirect Storage with Copy-On-Write implementation:
  54. Performance optimization recommendations: • Never do/rely on premature optimization. •

    Research the performance-critical modules. • Profile with Instruments. 2. Common Misconceptions
  55. 2. Common Misconceptions Misconception: Unexpected data sharing for Value types

    doesn’t exist
  56. 2. Common Misconceptions Misconception: Unexpected data sharing for Value types

    doesn’t exist In general, it’s true but there are exceptions...
  57. 2. Common Misconceptions Misconception: Unexpected data sharing for Value types

    doesn’t exist var a = 10 let printClosure = { print("a = \(a)") } a = 20 printClosure()
  58. 2. Common Misconceptions Misconception: Unexpected data sharing for Value types

    doesn’t exist var a = 10 let printClosure = { print("a = \(a)") } a = 20 printClosure() // 20
  59. 2. Common Misconceptions Misconception: Unexpected data sharing for Value types

    doesn’t exist var a = 10 let printClosure = { print("a = \(a)") } a = 20 printClosure() // 20 By default, closures capture and store references to any used constants and variables from the context in which they are defined.
  60. 2. Common Misconceptions Misconception: Unexpected data sharing for Value types

    doesn’t exist var a = 10 let printClosure = { print("a = \(a)") } a = 20 printClosure() // 20 var a = 10 let printClosure = { [a] in print("a = \(a)") } a = 20 printClosure() // 10 By default, closures capture and store references to any used constants and variables from the context in which they are defined.
  61. 2. Common Misconceptions Misconception: Unexpected data sharing for Value types

    doesn’t exist By default, closures capture and store references to any used constants and variables from the context in which they are defined. struct User { var name: String } var user = User(name: "Ben") let printNameClosure = { print("name = \(user.name)") } user.name = "John" printNameClosure() // name = John var user = User(name: "Ben") let printNameClosure = { [user] in print("name = \(user.name)") } user.name = "John" printNameClosure() // name = Ben
  62. 2. Common Misconceptions Misconception: Value types provide thread safety. No

    Race Conditions
  63. 2. Common Misconceptions Misconception: Value types provide thread safety. No

    Race Conditions Thread safety: Only for constants
  64. 2. Common Misconceptions Example 1: struct PlainStruct { var a

    = 0; var b = 0 } var item = PlainStruct() DispatchQueue.global().async { for i in 0...9999 { item.a = i; item.b = -i if item.a != -item.b { print("*** a = \(item.a); b = \(item.b) ***") } } } DispatchQueue.global().async { for i in 0...9999 { item.a = -i; item.b = i if item.b != -item.a { print("### a = \(item.a); b = \(item.b) ###") } } } DispatchQueue.global().async { print("1) a = \(item.a); b = \(item.b)") } DispatchQueue.global().asyncAfter(deadline: .now() + 0.2) { print("2) a = \(item.a); b = \(item.b)") }
  65. 2. Common Misconceptions Console output: 1) a = 2019; b

    = -2143 ### a = 2002; b = -2142 ### .... ### a = 5098; b = -5102 ### *** a = -62; b = 336 *** ### a = 5156; b = -5160 ### *** a = -478; b = 482 *** ### a = 5218; b = -5221 ### .... ### a = 5270; b = -5273 ### *** a = -534; b = 538 *** ### a = 5322; b = -5326 ### ..... ### a = 9974; b = -9978 ### 2) a = -9999; b = 9999
  66. 2. Common Misconceptions Example 2: var balance = 1200 struct

    ATM { let tag: String func withdraw(value: Int) { print("\(self.tag): checking if balance contains sufficient money") if balance > value { print("\(self.tag): Balance is sufficient, please wait while processing withdrawal") // sleeping for some random time, simulating a long process Thread.sleep(forTimeInterval: Double.random(in: 0...2)) balance -= value print("\(self.tag): Done: \(value) has been withdrawn") print("\(self.tag): current balance is \(balance)") } else { print("\(self.tag): Can't withdraw: insufficient balance") } } } let queue = DispatchQueue(label: "WithdrawalQueue", attributes: .concurrent) queue.async { let first = ATM(tag: "firstATM"); first.withdraw(value: 1000) } queue.async { let second = ATM(tag: "secondATM"); second.withdraw(value: 800) }
  67. 2. Common Misconceptions Console output: firstATM: checking if balance contains

    sufficient amount of money secondATM: checking if balance contains sufficient amount of money firstATM: Balance is sufficient, please wait while processing withdrawal secondATM: Balance is sufficient, please wait while processing withdrawal firstATM: Done: 1000 have been withdrawn firstATM: current balance is 200 secondATM: Done: 800 have been withdrawn secondATM: current balance is -600
  68. 2. Common Misconceptions Misconception: Value types provide thread safety. No

    Race Conditions
  69. 2. Common Misconceptions Misconception: Value types provide thread safety. No

    Race Conditions Use appropriate thread-safe programming techniques!
  70. Recommendations. 3

  71. 3. Recommendations • Make properties immutable by default • Never

    do/rely on premature optimization. Profile with Instruments! • Use common semantics for logically related types (Do not force user to check every time is it a value or reference type) • For time-consuming modules, Indirect Storage can be used for big structs to improve performance • Don’t forget using appropriate thread-safe programming techniques when needed • Use Nested Types • Use Enums and type safety as much as possible
  72. 3. Recommendations • Make properties immutable by default • Never

    do/rely on premature optimization. Profile with Instruments! • Use common semantics for logically related types (Do not force user to check every time is it a value or reference type) • For time-consuming modules, Indirect Storage can be used for big structs to improve performance • Don’t forget using appropriate thread-safe programming techniques when needed • Use Nested Types • Use Enums and type safety as much as possible
  73. 3. Recommendations • Make properties immutable by default • Never

    do/rely on premature optimization. Profile with Instruments! • Use common semantics for logically related types (Do not force user to check every time is it a value or reference type) • For time-consuming modules, Indirect Storage can be used for big structs to improve performance • Don’t forget using appropriate thread-safe programming techniques when needed • Use Nested Types • Use Enums and type safety as much as possible
  74. 3. Recommendations struct Controller1ViewModel { ... } class Controller2ViewModel {

    ... } • Use common semantics for logically related types (Do not force user to check every time is it a value or reference type)
  75. 3. Recommendations • Make properties immutable by default • Never

    do/rely on premature optimization. Profile with Instruments! • Use common semantics for logically related types (Do not force user to check every time is it a value or reference type) • For time-consuming modules, Indirect Storage can be used for big structs to improve performance • Don’t forget using appropriate thread-safe programming techniques when needed • Use Nested Types • Use Enums and type safety as much as possible
  76. 3. Recommendations • Make properties immutable by default • Never

    do/rely on premature optimization. Profile with Instruments! • Use common semantics for logically related types (Do not force user to check every time is it a value or reference type) • For time-consuming modules, Indirect Storage can be used for big structs to improve performance • Don’t forget using appropriate thread-safe programming techniques when needed • Use Nested Types • Use Enums and type safety as much as possible
  77. 3. Recommendations • Make properties immutable by default • Never

    do/rely on premature optimization. Profile with Instruments! • Use common semantics for logically related types (Do not force user to check every time is it a value or reference type) • For time-consuming modules, Indirect Storage can be used for big structs to improve performance • Don’t forget using appropriate thread-safe programming techniques when needed • Use Nested Types • Use Enums and type safety as much as possible
  78. 3. Recommendations • Make properties immutable by default • Never

    do/rely on premature optimization. Profile with Instruments! • Use common semantics for logically related types (Do not force user to check every time is it a value or reference type) • For time-consuming modules, Indirect Storage can be used for big structs to improve performance • Don’t forget using appropriate thread-safe programming techniques when needed • Use Nested Types • Use Enums and type safety as much as possible
  79. 3. Recommendations • Make properties immutable by default • Never

    do/rely on premature optimization. Profile with Instruments! • Use common semantics for logically related types (Do not force user to check every time is it a value or reference type) • For time-consuming modules, Indirect Storage can be used for big structs to improve performance • Don’t forget using appropriate thread-safe programming techniques when needed • Use Nested Types • Use Enums and type safety as much as possible
  80. https://developer.apple.com/wwdc15/409 https://developer.apple.com/wwdc15/414 https://developer.apple.com/wwdc16/416 https://developer.apple.com/documentation/swift/choosing_between_structures_and_classes https://github.com/apple/swift/blob/master/docs/OptimizationTips.rst#the-cost-of-large-swift-values https://swiftrocks.com/memory-management-and-performance-of-value-types.html https://academy.realm.io/posts/goto-mike-ash-exploring-swift-memory-layout/ https://www.mikeash.com/pyblog/friday-qa-2015-07-17-when-to-use-swift-structs-and-classes.html https://forums.swift.org/t/class-vs-structures/6230/2 Useful

    Links