We have this new language, Swift, which takes some familiar Apple patterns, and introduces some new ones. With tools like closures and method chaining, there are definitely some new ways to solve the age-old Obj-c architecture challenges. This talk will walk through some of the most common Obj-c design patterns rewritten in Swift, and showcase the strengths and weaknesses of this new language.

1. Cocoa Design Patterns
in Swift
@MicheleTitolo

4. • New language features
• Functional patterns
• Patterns in Swift
• Anti-patterns
What we’ll cover

5. New language features

6. Tuples

7. Tuples group multiple values
into a single compound value.

8. let http404Error = (404, "Not Found")
println(http404Error.0)

9. var http200Response: (statusCode: Int, statusText: String,
hasBody: Bool)
http200Response.statusCode = 200
http200Response.statusText = "OK"
http200Response.hasBody = true

10. You can put any kind
of object in a tuple

11. Generics

12. <T>

13. More than just an id

14. Abstraction

15. Create functions without
declaring type

16. struct Stack<T> {
var items = [T]()
mutating func push(item: T) {
items.append(item)
}
mutating func pop() -> T {
return items.removeLast()
}
}

17. <T: Equitable>

18. AnyObject

19. ...used a lot more like id

20. Closures

21. “Closures are behaviors
with attached state”
- Peter Norvig

22. Like blocks, but better!

23. var closure = { (params) -> returnType in
statements
}

24. let

25. Immutable variable

26. var myString: String? = someFucntion()
if let greeting = myString {
println(greeting)
}
else {
println("Not a string")
}

27. Structs + Enums

28. Structs:
Pass-by-value

29. struct Rect {
var origin: Point
var size: Size
}

30. Structs can have methods, and
conform to protocols

31. Enums:
also pass-by-value

32. Also can conform
to protocols and have methods

33. enum Rank: Int {
case Ace = 1
case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
case Jack, Queen, King
func description() -> String {
switch self {
case .Ace:
return "ace"
case .Jack:
return "jack"
case .Queen:
return "queen"
case .King:
return "king"
default:
return String(self.toRaw())
}
}
}

34. Functional Patterns

35. Function Passing

36. func printExcitedly(string: String){
println(string + "!!!!!!!")
}
var excitedFunc = printExcitedly

37. Pass functions into functions

38. func printVeryExcitedly(excitedFunction: (String) -> Void,
message: String){
excitedFunction(message.uppercaseString)
}
printVeryExcitedly(printExcitedly, "Hello");

39. Return functions
from functions

40. func beExcited(excitementLevel: Int) -> (String) -> Void {
...
}

41. Patterns

42. Composition

43. ...because we can pass
functions!

44. The OO way

45. class Car {
let numWheels: Int
let numCylinders: Int
init (numWheels: Int, numCylinders: Int) {
self.numWheels = numWheels
self.numCylinders = numCylinders
}
}
var newCar = Car(numWheels: 4,numCylinders: 4)
var otherCar = Car(numWheels: 4, numCylinders: 6)

46. var motorcycle = ??

47. class Motorcycle {
...
}

48. This is not ideal

49. protocol Vehicle {
var numWheels: Int {get set}
var numCylinders: Int {get set}
func drive()
}

50. Better

51. How do we handle this at
scale?

54. struct WheelSet {
var wheelSize: Int
var wheelFrictionCoefficient: Float
}
struct BodyType {
var numWheels: Int
var wheels: WheelSet
var wheelBase: Float
}
enum EngineType: Int {
case Automatic, Manual
}
protocol Vehicle {
var body: BodyType {get set}
var transmission: EngineType {get set}
func drive(force: Float)
func turn(speed: Float)
}

55. Better

56. ...but we can still improve

57. Factories

58. Abstract away object
creation and composition

59. protocol VehicleCreator {
func createVehicle(bodyType: BodyType, engineType: EngineType) -> Vehicle
}
class VehicleFactory: VehicleCreator {
func createVehicle(bodyType: BodyType, engineType: EngineType) -> Vehicle {}
}

60. protocol VehicleCreator {
func createVehicle(bodyType: BodyType, engineType: EngineType) -> Vehicle
}
class VehicleFactory: VehicleCreator {
func createVehicle(bodyType: BodyType, engineType: EngineType) -> Vehicle {}
}
class MotorcycleFactory: VehicleCreator {
func createVehicle(bodyType: BodyType, engineType: EngineType) -> Vehicle {}
}

61. This still looks very OO

62. class VehicleFactory {
func wheelSetGenerator(wheelSize: Int,
friction: Float) -> WheelSet {
return WheelSet(wheelSize: wheelSize,
wheelFrictionCoefficient: friction)
}
func generateBodyType(wheelCount: Int,
wheelType: WheelSet,
wheelBase: Float) -> (Void) -> BodyType {
func bodyGen() -> BodyType {
return BodyType(numWheels:wheelCount,
wheels:wheelType,
wheelBase:wheelBase)
}
return bodyGen
}
func createVehicle(
bodyGenerator:(wheelCount: Int,
wheelType: WheelSet,
wheelBase: Float) -> BodyType,
transmission: EngineType) -> Vehicle {}
}

63. let factory: VehicleFactory = VehicleFactory()
let motorcycleWheelSet: WheelSet = factory.wheelSetGenerator(28, friction: 0.5)
let motorcycleBodyGen = factory.generateBodyType(2,
wheelType:motorcycleWheelSet,
wheelBase: 45)
let motorcycle = factory.createVehicle(motorcycleBodyGen, transmission: .Manual)
let electricMotorcycle = factory.createVehicle(motorcycleBodyGen,
transmission: .Auomatic)

64. Factories in Swift can be
incredibly flexible

65. Command

66. A delegate chain
that returns a function

67. protocol Commander {
func commandSomething(String) -> (Int) -> Dictionary<String, String>
}
class ViewController: {
let delegate: Commander
}

68. Why is this better
than closures?

69. It’s more explicit

70. It’s more flexible

71. Enumeration

72. Not the type enum!

73. We have new ways of
transforming collections

74. [1,2,3,4].map {
(var number) -> Int in
return number * number
}

75. var array = [3, 2, 5, 1, 4]
array.sort { $0 < $1 }

76. let array = [1, 2, 3, 4, 5]
let reversedArray = array.reverse()
// reversedArray = [5, 4, 3, 2, 1]

77. And of course, this is useful for
more than just math

78. var vehicles = [suv, motorcycle, electricMotorcycle, car, truck]
var manualVehicles = vehicles.filter {
(var vehicle: Vehicle) -> Vehicle in
return (vehicle.transmission == .Manual)
}
// manualVehicles = [motorcycle, truck]

79. Encapsulate better

80. func meanMedianMode(a: Array<Int>) -> (mean:Int, median:Int, mode:Int) {
var mean = findMean(a)
var median = findMedian(a)
var mode = findMode(a)
return (mean, median, mode)
}

81. Tuples with names are
incredibly useful

82. Anti-Patterns

83. No changes to
handling protocols

84. This is the slide I was hoping
to put something magical on

85. class ViewController: UIViewController, UITableViewDataSource {
var tableView: UITableView
func tableView(tableView: UITableView!, cellForRowAtIndexPath indexPath: NSIndexPath!) ->
UITableViewCell! {
var cell : UITableViewCell = tableView.dequeueReusableCellWithIdentifier("Cell") as
UITableViewCell
if (cell == nil) {
cell = UITableViewCell(style: UITableViewCellStyle.Default, reuseIdentifier: "Cell")
}
cell.textLabel.text = "Hello World"
return cell
}
func tableView(tableView: UITableView!, numberOfRowsInSection section: Int) -> Int {
return 1
}
}

86. Protocols are first class citizens
in Swift, just like in Obj-c

87. Tuples all the way down

89. Yes, you can put a tuple in a
tuple

90. These are temporary data
structures

91. We have better OO
tools available

92. Operator overloading

93. Don’t overload default
operators

94. func decode(json: JSON) -> User? {
return _JSONObject(json) >>> { d in
User.create <^>
d["id"] >>> _JSONInt <*>
d["name"] >>> _JSONString <*>
d["email"] >>> _JSONString
}
}

95. Operators make code
harder to read

96. Type is still important

97. Getting classes from
AnyObject are kind of a pain

99. Still be explicit when you can

100. var music: [String: String] = ["AC/DC": "Hells Bells",
"Red Hot Chili Peppers": "Californication"]

101. In Summary

102. Swift gives us new tools

103. But Objective-C, and its
patterns, aren’t going away
anytime soon

104. More Swift!
• Today 11:30am
Interoperating Swift with Lower Level Code
by Stephan Tramer in Terrace
• Tomorrow 1:45pm
Functional Programming in Swift
by Chris Eidhof in Vail

105. Resources
• Swift Programming Guide from Apple
• Design Patterns in Dynamic Programming by Peter
Norvig
• Erica Sadun’s many blog posts on Swift
• Functional Programming in Swift, ebook by Objc.io
founders (See Chris’ talk tomorrow!)
• Instance Methods and Curried Functions in Swift by Ole
Begemann

106. Thanks!
@MicheleTitolo