KEMBAR78
Introduction to Swift | PDF
IOS BOOTCAMP
7° EDITION
#pragma mark
@ WCAP Catania
06/06/2015, v 1.2-S
THANKS TO
Youthub Catania
Motorsquare
#PRAGMA MARK
Started by a group of friends in 2012
Aim: create a community of iOS developers
Non-profit org since Sept. 2013
#PRAGMA MARK
In 3 years:
Organized a dozen events in northern Italy
all over Italy! !
Created an active on-line community:
fb.com/groups/pragmamark
2 editions of the #Pragma Conference
#PRAGMA MARK
Next edition: Florence, 9-10 Oct 2015
www.pragmaconference.com
JUST FOR TODAY'S ATTENDEES
15% DISCOUNT CODE:
! PragmaLovesCatania "
(limited to 30 tickets, so be quick!)
LET'S GET THE
BOOTCAMP STARTED!
HELLO WORLD
▸ Matteo Battaglio
▸ iOS dev @ Codermine
▸ #pragma mark co-founder
SLIDES
http://bit.ly/swift-introduction
HISTORY
LANGUAGE FATHER
Chris Lattner
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
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
PRINCIPLES
SWIFT PROGRAMMING LANGUAGE
imperative, functional, object oriented, multi-paradigm,
static, strong typed, type safe, inferred,
general purpose, compiled, fast,
modern, elegant, clean,
funny, happy,
❤
SYNTAX
Immutable & Mutable
Functions & Closures
Tuples & Pattern Matching
Data Types & Instances
Protocols & Extensions
Generics & Optionals
IMMUTABLE & MUTABLE
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'
CONSTANTS & VARIABLES
UNICODE CHARACTERS IN CONSTANT & VARIABLE NAMES
let !!!! = 4
var """"" = 5
! KILLER APPLICATION "
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.
STRUCTURES
MANY SWIFT LIBRARY'S BASE TYPES ARE STRUCTURES
// String
let string = "Swift"
// Character
let character: Character = "c"
// Array
let array = ["A", "B"]
// Dictionary
let dictionary = ["First" : 1, "Second" : 2]
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"]
FUNCTIONS & CLOSURES
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, ...
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)
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.
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
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)
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 } )
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, >)
TUPLES & PATTERN MATCHING
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
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")
}
DATA TYPES & INSTANCES
ENUMERATIONS, STRUCTURES & CLASSES
COMMON CAPABILITIES
▸ Stored & Computed Properties
▸ Methods, Subscripts & Initializers
▸ Protocols & Extensions
▸ Access Control
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() { /* ... */ }
}
CLASSES Only
ADDITIONAL CAPABILITIES:
▸ Inheritance
▸ Type casting
▸ Deinitializers
▸ Reference counting
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
PROTOCOLS & EXTENSIONS
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
}
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
}
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! !
GENERICS & OPTIONALS
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
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
}
}
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
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 !!!
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?
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)
FINAL
THOUGHTS
SWIFT VS ... ?
▸ Swift vs Scala
▸ Swift vs Rust
▸ Swift vs C#
Swift is Objective-C without the C
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
WHAT SWIFT IS MISSING?
[ SWIFT 1.2 IN XCODE 6.3 ]
▸ Compiler attributes and Preprocessor
▸ Exceptions, KVO, KVC and proper Reflection
HTTPS://GITHUB.COM/KSM/SWIFTINFLUX
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
WWDC
next week (8-12 June)
Great expectations for Swift...
THANKSYou can find me on the Internet!
twitter ! @m4dbat
github ! madbat
" matteo.battaglio@pragmamark.org

Introduction to Swift

  • 1.
    IOS BOOTCAMP 7° EDITION #pragmamark @ WCAP Catania 06/06/2015, v 1.2-S
  • 2.
  • 3.
    #PRAGMA MARK Started bya group of friends in 2012 Aim: create a community of iOS developers Non-profit org since Sept. 2013
  • 4.
    #PRAGMA MARK In 3years: Organized a dozen events in northern Italy all over Italy! ! Created an active on-line community: fb.com/groups/pragmamark 2 editions of the #Pragma Conference
  • 5.
    #PRAGMA MARK Next edition:Florence, 9-10 Oct 2015 www.pragmaconference.com
  • 6.
    JUST FOR TODAY'SATTENDEES 15% DISCOUNT CODE: ! PragmaLovesCatania " (limited to 30 tickets, so be quick!)
  • 7.
  • 8.
    HELLO WORLD ▸ MatteoBattaglio ▸ iOS dev @ Codermine ▸ #pragma mark co-founder
  • 9.
  • 10.
  • 11.
  • 12.
    LANGUAGE BIRTH I startedwork 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
  • 13.
    LANGUAGE INSPIRATION The SwiftProgramming 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
  • 14.
  • 15.
    SWIFT PROGRAMMING LANGUAGE imperative,functional, object oriented, multi-paradigm, static, strong typed, type safe, inferred, general purpose, compiled, fast, modern, elegant, clean, funny, happy, ❤
  • 16.
  • 17.
    Immutable & Mutable Functions& Closures Tuples & Pattern Matching Data Types & Instances Protocols & Extensions Generics & Optionals
  • 18.
  • 19.
    CONSTANTS & VARIABLES TYPEANNOTATIONS & 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'
  • 20.
    CONSTANTS & VARIABLES UNICODECHARACTERS IN CONSTANT & VARIABLE NAMES let !!!! = 4 var """"" = 5 ! KILLER APPLICATION "
  • 21.
    VALUE & REFERENCETYPES 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.
  • 22.
    STRUCTURES MANY SWIFT LIBRARY'SBASE TYPES ARE STRUCTURES // String let string = "Swift" // Character let character: Character = "c" // Array let array = ["A", "B"] // Dictionary let dictionary = ["First" : 1, "Second" : 2]
  • 23.
    STRUCTURES CONSTANT & VARIABLEARRAYS 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"]
  • 24.
  • 25.
    FUNCTIONS FIRST-CLASS FUNCTION ▸ assigna function to variable ▸ pass function as argument to another function ▸ return a function from a function ▸ functional programming patterns: map, filter, ...
  • 26.
    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)
  • 27.
    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.
  • 28.
    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
  • 29.
    FUNCTIONS VS CLOSURES SORTINGWITHOUT 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)
  • 30.
    FUNCTIONS VS CLOSURES SORTINGWITH 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 } )
  • 31.
    FUNCTIONS VS CLOSURES SORTINGWITH 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, >)
  • 32.
  • 33.
    TUPLES LIGHTWEIGHT CONTAINERS FORMULTIPLE 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
  • 34.
    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") }
  • 35.
    DATA TYPES &INSTANCES
  • 36.
    ENUMERATIONS, STRUCTURES &CLASSES COMMON CAPABILITIES ▸ Stored & Computed Properties ▸ Methods, Subscripts & Initializers ▸ Protocols & Extensions ▸ Access Control
  • 37.
    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() { /* ... */ } }
  • 38.
    CLASSES Only ADDITIONAL CAPABILITIES: ▸Inheritance ▸ Type casting ▸ Deinitializers ▸ Reference counting
  • 39.
    CLASSES Only public classCar: 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
  • 40.
  • 41.
    PROTOCOLS // Available forEnumerations, 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 }
  • 42.
    EXTENSIONS // Available forEnumerations, 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 }
  • 43.
    EXTENSIONS EXTENSIONS CAN EXTENDALSO SWIFT LIBRARY TYPES extension Int { func times(task: () -> ()) { for i in 0 ..< self { task() } } } 3.times({ println("Developer! ") }) // Developer! Developer! Developer! !
  • 44.
  • 45.
    GENERICS // Specific Functions funcswapTwoStrings(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
  • 46.
    GENERICS WHERE CLAUSES ONTYPE 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 } }
  • 47.
    OPTIONALS AN OPTIONAL VALUEEITHER 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
  • 48.
    OPTIONALS // Force unwrap letoptionalInt: 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 !!!
  • 49.
    OPTIONALS class Car { varmodel: 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?
  • 50.
    OPTIONALS A GENERIC ENUMERATIONWITH 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)
  • 51.
  • 52.
    SWIFT VS ...? ▸ Swift vs Scala ▸ Swift vs Rust ▸ Swift vs C# Swift is Objective-C without the C
  • 53.
    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
  • 54.
    WHAT SWIFT ISMISSING? [ SWIFT 1.2 IN XCODE 6.3 ] ▸ Compiler attributes and Preprocessor ▸ Exceptions, KVO, KVC and proper Reflection HTTPS://GITHUB.COM/KSM/SWIFTINFLUX
  • 55.
    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
  • 56.
    WWDC next week (8-12June) Great expectations for Swift...
  • 57.
    THANKSYou can findme on the Internet! twitter ! @m4dbat github ! madbat " matteo.battaglio@pragmamark.org