Developing iOS apps with Swift

40 minute introduction to iOS development and Swift for Computer Science students not yet familiar with iOS and functional programming. Touching upon what components an app contains, common problems, autolayout, Swift and a little bit of functional programming.

As presented at Q42 for students from Utrecht University.

Want to know more about Q42 and Swift?
Check out: http://q42.com/swift

Transcript

1. Developing iOS apps with Swift
2. Mathijs Kadijk Software Engineer
3. Developing iOS apps with Swift
5. New native apps
6. A little bit about mobile development
7. Component #1 User Experience
8. A good app is a fast app
9. A good app is an offline app
10. A good app is a simple app
11. UX == Everything fast, offline, simple
12. Component #2 Backend Server
13. Data synchronisatie
15. Component #3 User Interface
19. Component #4 Code
20. Reuse Libraries: 100%
21. Reuse Project code: 0%
22. Lets dive into Swift
23. Result screen Four states
24. How do we model this?
25. Booleans struct ShipmentResultState { var pending: Bool = true var notFound: Bool = false var details: Bool = false var error: Bool = false } ✗ Can create illigal states ✗ Amibiguous ✗ No state associated data
26. Swift enums are powerful
27. Enum enum ShipmentResultViewModel { case Pending(ShipmentAddToMailboxRequest, Promise<SearchResult<Shipment>>) case NotFound(ShipmentAddToMailboxRequest) case Details(Shipment) case Error(ShipmentAddToMailboxRequest) } ✔ Always one valid state ✔ Very clear what a state means ✔ Contains state data
28. Being functional in practice
29. Cocoa style error handling var optionalError: NSError? if let object = existingObjectWithID(managedObjectID, error: &optionalError) { println("Object found: \(object)") } else if let error = optionalError { println("An error occured: \(error)") } ✗ Both can be nil ✗ Both can be something ✗ Doesn't scale
30. Cocoa style error handling var optionalError: NSError? if let object = existingObjectWithID(managedObjectID, error: &optionalError) { if let object = deleteObject(object, error: &optionalError) { println("Object deleted!") } else if let error = optionalError { println("An error occured: \(error)") } } else if let error = optionalError { println("An error occured: \(error)") }
31. Result enum enum Result<T> { case Success(T) case Failure(NSError) }
32. Result enum error handling switch existingObjectWithID(managedObjectID) { case let .Success(object): println("Object found: \(object)") case let .Failure(error): println("An error occured: \(error)") } ✔ Always one valid state ✔ Very clear what happend ✗ Doesn't scale
33. Result enum error handling switch existingObjectWithID(managedObjectID) { case let .Success(object): switch deleteObject(object) { case .Success: println("Object deleted!") case let .Failure(error): println("An error occured: \(error)") } case let .Failure(error): println("An error occured: \(error)") }
34. Result enum with map extension Result { func map<U>(f: T -> U) -> Result<U> { switch self { case let .Success(x): return .Success(f(x)) case let .Failure(x): return .Failure(x) } } }
35. Result map example let carResult: Result<Car> = ... let colorResult: Result<UIColor> = carResult.map({ car in return car.color })
36. Result map example let carResult: Result<Car> = ... let colorResult: Result<UIColor> = carResult.map { car in return car.color }
37. Result map example let carResult: Result<Car> = ... let colorResult: Result<UIColor> = carResult.map { car in car.color }
38. Result map example let carResult: Result<Car> = ... let colorResult: Result<UIColor> = carResult.map { $0.color }
39. Result map awesomeness let carResult = ... let colorResult = carResult.map { $0.color }
40. Error handling with map let findResult = existingObjectWithID(managedObjectID) let deleteResult: Result<Result<Void>> = findResult.map { deleteObject($0) }
41. Error handling with map let findResult = existingObjectWithID(managedObjectID) let deleteResult: Result<Result<Void>> = findResult.map(deleteObject)
42. Result enum with flatten func flatten<T>(result: Result<Result<T>>) -> Result<T> { switch result { case let .Success(x): return x case let .Failure(x): return .Failure(x) } }
43. Error handling with map + flatten let findResult = existingObjectWithID(managedObjectID) let deleteResult: Result<Void> = flatten(findResult.map(deleteObject))
44. Result enum with flatmap extension Result { func flatMap<U>(f: T -> Result<U>) -> Result<U> { return flatten(map(f)) } }
45. Error handling with flatmap let findResult = existingObjectWithID(managedObjectID) let deleteResult: Result<Void> = findResult.flatMap(deleteObject)
46. Error handling with flatmap let result = existingObjectWithID(managedObjectID) .flatMap(deleteObject)
47. Cocoa style error handling var optionalError: NSError? if let object = existingObjectWithID(managedObjectID, error: &optionalError) { if let object = deleteObject(object, error: &optionalError) { println("Object deleted!") } else if let error = optionalError { println("An error occured: \(error)") } } else if let error = optionalError { println("An error occured: \(error)") }
48. Functional style error handling switch existingObjectWithID(managedObjectID) .flatMap(deleteObject) { case .Success: println("Object deleted!") case let .Failure(error): println("An error occured: \(error)") }
49. Bonus round #1 Custom operator
50. BONUS: Custom operators infix operator >>== {} func >>== <T,U>(x: Result<T>, f: T -> Result<U>) -> Result<U> { return x.flatMap(f) }
51. BONUS: Using our operator let result = existingObjectWithID(managedObjectID) >>== deleteObject
52. Bonus round #2 Syntactic sugar
53. BONUS: Optional chaining return car.map { $0.owner }.map { $0.partner }.map { $0.name } // == return car.owner?.partner?.name
54. BONUS: Optional flattening let optionalOptional: String?? let optional: String? = optionalOptional?
55. BONUS: Optional flattening let optionalOptional: Optional<Optional<String>> let optional: Optional<String> = flatten(optionalOptional)
56. Mathijs Kadijk @mac_cain13