Server Side Swift

Server Side Swift
Chad Moone
WP Dev Day 2017

• A new programming language (2014)
• Developed by Chris Lattner & Apple
• Compiled, based on LLVM stack
• Static, strong, and inferred typing
• Multi-paradigm (OO, functional, imperative, protocol-oriented)
• Focused on speed & safety
Swift
What even is it?

• A Joy to Work In
• Expressive, yet concise
• Safety Front-and-Center
• Incredibly Intelligent Compiler
• Robust Type System
• Rapidly growing in popularity
Why Swift?
Here’s why we love it

Swift Evolution
• Hello World!
• Core language features
• Apple platform support
Initial Release
1.0 (2014)

Swift Evolution
• Hello World!
Initial Release Open Source
1.0 (2014) 2.0 (2015)
• OSS compiler & standard
library
• Linux support
• Error handling
• Protocol extensions

Swift Evolution
• Hello World!
Initial Release Open Source Community-Driven
Refinement
1.0 (2014) 2.0 (2015) 3.0 (2016)
library
• Linux support
• Error handling
• All changes via community
evolution process
• Major syntax changes for
coherence & consistency
• Std Lib rewrite
• Official API design
guidelines

Swift Evolution
• Hello World!
Initial Release Open Source Community-Driven
Refinement Stability & Polish
1.0 (2014) 2.0 (2015) 3.0 (2016) 4.0 (2017)
library
• Linux support
• Error handling
• All changes via community
evolution process
• Major syntax changes for
coherence & consistency
• Std Lib rewrite
• Official API design
guidelines
• Strings enhancements
• Automatic archival &
serialization
• Reached top 10 in both
TIOBE & IEEE language
indexes
• Server APIs Working
Group

Swift Server-Side Frameworks
The Major Players
10k ⭐️
Community-Driven
Version 2.1
Vapor
12k ⭐️
Driven by community &
PerfectlySoft
Version 2.0
Perfect
6k ⭐️
Driven by IBM & community
Version 1.7
Kitura

• github.com/rymcol/Linux-Server-Side-Swift-Benchmarking
• Used an identical simple blog application
• Both HTML & bare-bones JSON versions
• Express.js was used for the Node comparison
Server Performance Shootout

0
3000
6000
9000
12000
Perfect Kitura Vapor Node
11K 11K
9K
7K
Requests/Second
• HTML Requests/Second
https://github.com/rymcol/Linux-Server-Side-Swift-Benchmarking

0
0.7
1.4
2.1
2.8
2
2
1
3
Average Latency (ms)
• HTML Average Latency

0
5000
10000
15000
20000
20K
11K
14K
9K
Requests/Second
• JSON API Requests/Second

0
0.6
1.2
1.8
2.4
1.0
1.9
0.8
2.2
Average Latency (ms)
• JSON API Average Latency

0
4
8
12
16
1.30 1.40 1.40
15.30
Memory Footprint (MB)
• Memory Footprint (Startup)

0
75
150
225
300
3
174
246
61
Memory Footprint (MB)
• Memory Footprint (Startup)
• Memory Footprint (High Load)

1
Named Arguments
Clarity at the point of use

func logMessage(message:String,
prefix: String,
suffix: String) {
print("(prefix)-(message)-(suffix)")
}
Named Arguments
SWIFT’S GREATEST HITS

prefix: String,
suffix: String) {
}
logMessage("Beautiful",
"Hello",
“World”)
Named Arguments

prefix: String,
suffix: String) {
}
logMessage(message: “Beautiful”,
prefix: "Hello",
suffix: “World”)
Named Arguments

func logMessage(_ message:String,
withPrefix prefix: String,
andSuffix suffix: String) {
}
logMessage("Beautiful",
withPrefix: "Hello",
andSuffix: “World")
Named Arguments

2
Type Inference
Only what’s needed

let meaningOfLife: Int = 42
let pi: Double = 3.14159
let anotherPi: Double = 3 + 0.14159
let apple: Apple = Apple()
let appleDescription: String = apple.toString()
Type Inference

let meaningOfLife = 42
let pi = 3.14159
let anotherPi = 3 + 0.14159
let apple = Apple()
let appleDescription = apple.toString()
Type Inference

let currentPoints: UInt = 42
let miniPi: Float = 3.14159
var color: UIColor
if pi > 4 {
color = .green
} else {
color = .red
}
Type Inference

3
Extensions & Protocols
Redefining Definition TM

extension String {
func exclaimed() -> String {
return "(self)!"
}
}
let greeting = "Hello".exclaimed() // "Hello!"
Redefining Definition

protocol FullyNamed {
var fullName: String {get}
}

}
protocol Introducing: FullyNamed {
func introduce() -> String
}

}
}
extension Introducing {
func introduce() -> String { return : "Hi, I’m (fullName)!” }
}

}
}
extension Introducing {
func introduce() -> String { return : "Hi, I’m (fullName)!” }
}
struct Person: Introducing {
var fullName: String { return "(firstName) (lastName)" }
}
let p = Person(firstName: "Chad", lastName: "Moone")
p.introduce() // "Hi, I'm Chad Moone!"

4
Optionality
Make nil Great Again

Optionality
var myObject: Object = nil

Optionality
myObject.toString()

myObject.toString() // <—- 💣💥💀
Optionality

var myObject: Object = nil // <—- 🚨👾🚨*
*👾 == “compiler”
Optionality

var myObject: Object = Object()
var optionalObject: Object? = nil
Optionality

var myObject = Object()
var optionalObject: Object?
Optionality

myObject = nil
Optionality

myObject = nil // <—- 🚨👾🚨
Optionality

myObject = otherObject // <—- ✅👾✅
Optionality

myObject = otherObject
optionalObject = Object()
optionalObject = nil
Optionality

Optionality

myObject.print()
optionalObject.print()
Optionality

myObject.print() // <—- guaranteed to be ✅
optionalObject.print()
Optionality

optionalObject.print() // <—- 🚨👾🚨
Optionality

optionalObject?.print()
Optionality

optionalObject?.print() // <—- has value, so ✅
Optionality

optionalObject?.print() // <—- has value, so ✅
optionalObject = nil
optionalObject?.print() // <—- no value == no op
Optionality

func setAlarm(time: Date, message: String?) {
alarmTime = time
if let message = message {
message.uppercased()
addExclamations(message)
emojify(message)
alarmMessage = message
}
}
Optionality

func setAlarm(time: Date, message: String?) {
alarmTime = time
guard let message = message else {
return
}
message.uppercased()
addExclamations(message)
emojify(message)
alarmMessage = message
}
Optionality

5
Enums & Generics
Safe, yet flexible

Enums & Generics
enum CompassPoint {
case north
case south
case east
case west
}
var directionToHead = CompassPoint.west
var directionToShore: CompassPoint = .east
Safe, yet flexible

Enums & Generics
switch directionToTravel {
case .north:
print("To Canada!")
case .south:
print("To Mexico!")
}
Safe, yet flexible

Enums & Generics
case .north:
print("To Canada!")
case .south:
print("To Mexico!")
} // <—- 🚨👾🚨 Must be exhaustive!!
Safe, yet flexible

Enums & Generics
case .north:
print("To Canada!")
case .south:
print("To Mexico!")
default:
print("Into the ocean!")
}
Safe, yet flexible

Enums & Generics
enum Planet: Int {
case mercury = 1
case venus = 2
case earth = 3
case mars = 4
case jupiter = 5
case saturn = 6
case uranus = 7
case neptune = 8
}
Safe, yet flexible

Enums & Generics
enum Planet: Int {
case mercury = 1, venus, earth, mars, jupiter,
saturn, uranus, neptune
}
Safe, yet flexible

Enums & Generics
enum Planet: Int {
case mercury = 1, venus, earth, mars, jupiter,
saturn, uranus, neptune
}
if let somePlanet = Planet(rawValue: 11) {
switch somePlanet {
case .earth:
print("Mostly harmless")
default:
print("Not a safe place for humans")
}
} else {
print("There isn't a planet at position (positionToFind)")
} // Prints "There isn't a planet at position 11"
Safe, yet flexible

Enums & Generics
enum Either {
case str(String)
case num(Double)
}
var a = Either.str("hello")
a = .num(1.0)
Safe, yet flexible

Enums & Generics
enum Trade {
case Buy(stock: String, amount: Int)
case Sell(stock: String, amount: Int)
}
Safe, yet flexible

Enums & Generics
enum Trade {
}
func executeTrade(_ trade: Trade) { /* magic */ }
Safe, yet flexible

Enums & Generics
enum Trade {
}
func executeTrade(_ trade: Trade) { /* magic */ }
let purchase = Trade.Buy(stock: "AAPL", amount: 20)
executeTrade(purchase)
let sale = Trade.Sell(stock: "SNAP", amount: 500)
executeTrade(sale)
Safe, yet flexible

Enums & Generics
enum Optional<Wrapped> {
case some(Wrapped)
case none
}
var possibleInteger: Optional<Int> = .none
possibleInteger = .some(100)
Safe, yet flexible

6
Automatic Reference Counting
The “other” ARC

class Person {
let name: String
init(name: String) { self.name = name }
var apartment: Apartment?
deinit { print("Bye, (name)!") }
}
var p1: Person? = Person(name: "Chad")
p1 = nil // "Bye, Chad”
p1 = Person(name: "Murray")
var p2 = p1
p1 = nil // Murray still has an active reference
p2 = Person(name: "Bruce") // "Bye, Murray"
The “other” ARC

class Person {
let name: String
}
class Apartment {
let unit: String
init(unit: String) { self.unit = unit }
var tenant: Person?
deinit { print("Apartment (unit) is being deinitialized") }
}
The “other” ARC

class Person {
let name: String
}
class Apartment {
let unit: String
var tenant: Person?
}
var p: Person? = Person(name: "Chad")
var a: Apartment? = Apartment(unit: "5C")
p?.apartment = a
a?.tenant = p
p = nil // a still has a reference
a = nil // p still has a reference
The “other” ARC

class Person {
let name: String
}
class Apartment {
let unit: String
weak var tenant: Person?
}
p?.apartment = a
a?.tenant = p
The “other” ARC

class Person {
let name: String
}
class Apartment {
let unit: String
weak var tenant: Person?
}
p?.apartment = a
a?.tenant = p
p = nil // "Bye, Chad!"
a = nil // "Apartment 5C is being deinitialized"
The “other” ARC

Swift Playgrounds
• For macOS & iPad
• Start playing with the full power of
swift in seconds
• Tons of tutorials and other
resources
• REPL on Steroids

• swift.org
• developer.apple.com/swift
• github.com/apple/swift
• Free Swift programming book series (regularly updated)
Getting Started

Server Side Swift

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Server Side Swift

Similar a Server Side Swift (20)

Último

Último (20)

Server Side Swift

Notas del editor