Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

Swift Introduction

1,180 views

Published on

Swift Programming Language Introduction @ Codemotion Milan by #pragma mark

Published in: Software
  • Be the first to comment

  • Be the first to like this

Swift Introduction

  1. 1. SWIFT INTRODUCTION by Giuseppe Arici & Matteo Battaglio @ Codemotion Milan, 29/11/2014, v 1.1-S
  2. 2. A SWIFT INTRODUCTION TO THE NEW APPLE PROGRAMMING LANGUAGE
  3. 3. HELLO WORLD ▸ Giuseppe Arici & Matteo Battaglio ▸ iOS devs @ Tiltap / Superpartes ▸ #pragma mark co-founders ▸ Codemotion friends ▸  addicted
  4. 4. [This] Short Presentation @ SlideShare http://slideshare.net/giuseppearici/swift-introduction Long Presentation @ SlideShare http://slideshare.net/giuseppearici/swift-programminglanguage Sample Code @ GitHub https://github.com/madbat/swift-fun-playgrounds
  5. 5. HISTORY
  6. 6. LANGUAGE FATHER Chris Lattner
  7. 7. LANGUAGE BIRTH I started work on the Swift Programming Language in July of 2010. I implemented much of the basic language structure, with only a few people knowing of its existence. A few other (amazing) people started contributing in earnest late in 2011, and it became a major focus for the Apple Developer Tools group in July 2013. — Chris Lattner
  8. 8. LANGUAGE INSPIRATION The Swift Programming Language greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list. — Chris Lattner
  9. 9. PRINCIPLES
  10. 10. SWIFT PROGRAMMING LANGUAGE imperative, functional, object oriented, multi-paradigm, static, strong typed, type safe, inferred, general purpose, compiled, fast, modern, elegant, clean, funny, happy, ❤️
  11. 11. SYNTAX
  12. 12. Immutable & Mutable Functions & Closures Tuples & Pattern Matching Data Types & Instances Protocols & Extensions Generics & Optionals
  13. 13. IMMUTABLE & MUTABLE
  14. 14. CONSTANTS & VARIABLES TYPE ANNOTATIONS & TYPE INFERENCE let constant: Int = 1 // Type Annotations let constant = 1 // Type Inference (as Int) let constant = 1 // readonly, cannot be re-assigned constant = 2 // ❌ ERROR !!! var variable = 1 // readwrite, can be re-assigned variable = 2 // OK By convention you should prefer to use 'let' over 'var'
  15. 15. CONSTANTS & VARIABLES UNICODE CHARACTERS IN CONSTANT & VARIABLE NAMES let !!!! = 4 var """"" = 5 ! KILLER APPLICATION "
  16. 16. VALUE & REFERENCE TYPES ENUMERATIONS & STRUCTURES VS CLASSES ▸ Enumerations & Structures are passed by Value ▸ Classes are passed by Reference ENUMERATIONS & STRUCTURES ARE ALWAYS COPIED WHEN THEY ARE PASSED AROUND IN THE CODE, AND DO NOT USE REFERENCE COUNTING.
  17. 17. STRUCTURES MANY SWIFT LIBRARY'S BASE TYPES ARE STRUCTURES // String let string = "Codemotion" // Character let character: Character = "c" // Array let array = ["A", "B"] // Dictionary let dictionary = ["First" : 1, "Second" : 2]
  18. 18. STRUCTURES CONSTANT & VARIABLE ARRAYS let constantArray = ["A"] var variableArray = ["A"] constantArray = ["X"] // ❌ ERROR !!! constantArray[0] = "Y" // ❌ ERROR !!! constantArray.append("B"); // ❌ ERROR !!! constantArray.removeAtIndex(0) // ❌ ERROR !!! variableArray = ["X"] // ["X"] variableArray[0] = "A" // ["A"] variableArray.append("B"); // ["A", "B"] variableArray.removeAtIndex(0) // ["B"]
  19. 19. FUNCTIONS & CLOSURES
  20. 20. FUNCTIONS FIRST-CLASS FUNCTION ▸ assign a function to variable ▸ pass function as argument to another function ▸ return a function from a function ▸ functional programming patterns: map, filter, ...
  21. 21. FUNCTIONS DECLARATION & CALL // declaration func foo(parameter1: Type1, parameter1: Type2) -> ReturnType { /* function body */ } // call foo(argument1, argument2) // external and local parameter names func bar(externalParameterName localParameterName: Type) { /* body use localParameterName */ } // call must use externalParameterName label bar(externalParameterName: argument)
  22. 22. CLOSURES MEANING & SYNTAX // Closures are blocks of functionality that can be passed around { (parameter1: Type1, parameter2: Type2) -> ReturnType in / * ... */ } // Closures can capture and store references to any constants and // variables from the context in which they are defined.
  23. 23. FUNCTIONS VS CLOSURES ▸ Global functions: NAMED CLOSURES / DO NOT CAPTURE ANY VALUES ▸ Nested functions: NAMED CLOSURES / CAPTURE VALUES FROM ENCLOSING FUNCTION ▸ Closure expressions: UNNAMED CLOSURES / CAPTURE VALUES FROM THEIR CONTEXT
  24. 24. FUNCTIONS VS CLOSURES SORTING WITHOUT CLOSURES // define a function which takes an array and a sorting algorithm func sorted(array: [Int], algorithm: (Int, Int) -> Bool) -> [Int] { /* apply the sorting algorithm to the array */ } // define an array let array = [1, 2, 3] // define a sorting algorithm funtion func backwards(i1: Int, i2: Int) { return i1 > i2 } // call sorted var reversed = sorted(array, backwards)
  25. 25. FUNCTIONS VS CLOSURES SORTING WITH CLOSURES 1/2 // Fully declared closure reversed = sorted(array, { (i1: Int, i2: Int) -> Bool in return i1 > i2 } ) // Infer closure type reversed = sorted(array, { (i1, i2) in return i1 > i2 } ) // Implicit returns reversed = sorted(array, { (i1, i2) in i1 > i2 } )
  26. 26. FUNCTIONS VS CLOSURES SORTING WITH CLOSURES 2/2 // Shorthand argument names reversed = sorted(array, { $0 > $1 } ) // Trailing closure: outside of () only if it's function’s final argument reversed = sorted(array) { $0 > $1 } // Operator functions reversed = sorted(array, >)
  27. 27. TUPLES & PATTERN MATCHING
  28. 28. TUPLES LIGHTWEIGHT CONTAINERS FOR MULTIPLE VALUES let complex = (1.0, -2.0) // Compound Type: (Double, Double) let (real, imag) = complex // Decompose let (real, _) = complex // Underscores ignore value // Access by index let real = complex.0 let imag = complex.1 // Name elements let complex = (real: 1.0, imag: -2.0) let real = complex.real
  29. 29. PATTERN MATCHING let point = (42, 42) switch point { // break by default case (0, 0): println("match a specific tuple") case (_, 0): println("ignore undescore value") case (let x, 1): println("bind a value to x") case let (x, y) where x == y: println("bind values which satify the where clause") default: println("must be exhaustive") }
  30. 30. DATA TYPES & INSTANCES
  31. 31. ENUMERATIONS, STRUCTURES & CLASSES COMMON CAPABILITIES ▸ Stored & Computed Properties ▸ Methods, Subscripts & Initializers ▸ Protocols & Extensions ▸ Access Control
  32. 32. ENUMERATIONS, STRUCTURES & CLASSES public class Vehicle { // stored instance property private let name: String // computed instance property public var formattedName: String { return "vehicle: (name)" } // type property class var maxSpeed : Int { return 299_792_458 } // initializer init (name: String) { self.name = name } // instance method internal func move() { /* ... */ } }
  33. 33. CLASSES Only ADDITIONAL CAPABILITIES: ▸ Inheritance ▸ Type casting ▸ Deinitializers ▸ Reference counting
  34. 34. CLASSES Only public class Car: Vehicle { // inheritance // override public override var formattedName: String { return "car: (name)" } // designated initializer override init(name: String) { super.init(name: name);} // convenience initializer convenience init() { self.init(name: "Car") } // deinitializer deinit { /* clean up */ } } let vehicle = Car(name: "Supercar") let car = vehicle as Car // Type Casting
  35. 35. PROTOCOLS & EXTENSIONS
  36. 36. PROTOCOLS // Available for Enumerations, Structures & Classes protocol SomeProtocol { // define a set of requirements var instanceProperty: Type { get set } // require instance properties class var typeProperty: Type { get set } // require type properties func someMethod() // require instance methods class func someTypeMethod() // require type methods init() // require initializers }
  37. 37. EXTENSIONS // Available for Enumerations, Structures & Classes extension SomeType: SomeProtocol { // add protocol conformance var stored = 1 // ❌ ERROR !!! // CANNOT add store properties ! var computed: String { /* ... */ } // add computed properties func method() { /* ... */ } // add methods subscript(i: Int) -> String { /* ... */ } // add subscripts init(parameter: Type) { /* ... */ } // add initializers enum SomeEnum { /* ... */ } // add nested types }
  38. 38. EXTENSIONS EXTENSIONS CAN EXTEND ALSO SWIFT LIBRARY TYPES extension Int { func times(task: () -> ()) { for i in 0 ..< self { task() } } } 3.times({ println("Developer! ") }) // Developer! Developer! Developer! !
  39. 39. GENERICS & OPTIONALS
  40. 40. GENERICS // Specific Functions func swapTwoStrings(inout a: String, inout b: String) { let temporaryA = a; a = b; b = temporaryA } func swapTwoDoubles(inout a: Double, inout b: Double) { let temporaryA = a; a = b; b = temporaryA } // Generic Function func swapTwoValues<T>(inout a: T, inout b: T) { let temporaryA = a; a = b; b = temporaryA } var someInt = 1, anotherInt = 2 swapTwoValues(&someInt, &anotherInt) // T == Int // someInt == 2, anotherInt == 1
  41. 41. GENERICS WHERE CLAUSES ON TYPE CONSTRAINTS protocol Container { typealias ItemType } func allItemsMatch< C1: Container, C2: Container where C1.ItemType == C2.ItemType, C1.ItemType: Equatable> (container1: C1, container2: C2) -> Bool { if container1.count != container2.count { return false } for i in 0..<container1.count { if container1[i] != container2[i] { return false } } return true // all items match } }
  42. 42. OPTIONALS AN OPTIONAL VALUE EITHER CONTAINS A VALUE OR NIL var optionalInt: Int? = 42 optionalInt = nil // to indicate that the value is missing var optionalDouble: Double? // automatically sets to nil // Check if nil optionalDouble == nil optionalDouble != nil
  43. 43. OPTIONALS // Force unwrap let optionalInt: Int? = 42 let definitelyInt = optionalInt! // throws runtime error if nil // Optional binding if let definitelyInt = optionalInt { // runs if optionalInt is not nil and sets definitelyInt: Int } // Implicitly Unwrapped Optionals var assumedInt: Int! // set to nil assumedInt = 42 var implicitInt: Int = assumedInt // do not need an exclamation mark assumedInt = nil implicitInt = assumedInt // ❌ RUNTIME ERROR !!!
  44. 44. OPTIONALS class Car { var model: String init(model: String) { self.model = model } func jump() -> String? { if model == "Supercar" { return "!⚡️" } else { return nil } } } // Return type of chaining is always optional var car1: Car? = nil; car1?.model // nil: String? var car2: Car? = Car(model: "Supercar"); car2?.model // "Supercar": String? // Chain on optional return value car1?.jump()?.hasPrefix("!") // type Bool?
  45. 45. OPTIONALS A GENERIC ENUMERATION WITH ASSOCIATED VALUE enum Optional<T> : Reflectable, NilLiteralConvertible { case None case Some(T) /* ... */ } var maybeInt1: Int? = nil var maybeInt2: Optional<Int> = .None maybeInt1 = 42 maybeInt2 = .Some(42)
  46. 46. TOOLS & PRACTICE
  47. 47. LET'S PLAY WITH SWIFT ▸ Swift in playground ▸ Swift distinctive features ! LET'S SEE IT IN ACTION!
  48. 48. FINAL THOUGHTS
  49. 49. SWIFT VS ... ? ▸ Swift vs Scala ▸ Swift vs Rust ▸ Swift vs C# Swift is Objective-C without the C
  50. 50. OPEN SOURCE SWIFT ? Guys, feel free to make up your own dragons if you want, but your speculation is just that: speculation. We literally have not even discussed this yet, because we have a ton of work to do [...] You can imagine that many of us want it to be open source and part of llvm, but the discussion hasn't happened yet, and won't for some time. — Chris Lattner @ llvmdev
  51. 51. WHAT SWIFT IS MISSING ? [ SWIFT 1.1 IN XCODE 6.1 ] ▸ Compiler attributes and Preprocessor ▸ Class Variables, Exceptions, KVO, KVC and Reflection6 HTTPS://GITHUB.COM/KSM/SWIFTINFLUX 6 Though it’s not documented in the Swift Standard Library — and is subject to change — Swift has a reflection API: let mirror = reflect(instance) // see Reflectable Protocol
  52. 52. SWIFT IN PRODUCTION ? ▸ Companies are doing it ▸ Freelances are doing it ▸ Many of us are doing it ▸ But be careful if you do it ! A few apps that were built using Swift @ apple.com
  53. 53. Q&A
  54. 54. THANKS see you @ https://fb.com/groups/pragmamark @giuseppearici / giuseppe.arici@pragmamark.org @m4dbat / matteo.battaglio@pragmamark.org

×