the joy of serverside swift development

The Joy Of Server Side Swift Development

In 1943 Konrad Zuse invented Plankalkül

1940s

9 Programming languages

1950s

... - Fortran(concept) - Fortran II - ALGOL 58(IAL) - LISP(implementation) ...

1950s


1960s

...- ALGOL 60 - COBOL 61(implementation) - FORTRAN IV - APL(concept) - Simula(concept) - SNOBOL - CPL - SNOBOL3 - ALGOL 68(concept) - BASIC ...

1960s


1970s

... - Pascal - Smalltalk - C - Prolog - Structured Query language ( SQL) - Bourne Shell(sh) - Modula-2 - AWK...

1970s


1980s

... - Ada 80(MIL-STD-1815) - GW-BASIC - Turbo Pascal - Objective-C - C++ - Eiffel - Erlang...

1980s


1990s

... - AMOS BASIC - Haskell - Python - Visual Basic - Brainfuck - Borland Delphi - Java - PHP - Ruby - JavaScript - Standard C++...

1990s


2000s

...- ActionScript- C#- D- Scala- Groovy- F#- Clojure- Go...

2000s


2010s

... - Rust - Elm - Kotlin - Elixir - Hack - C++14 ...

2010s


and then...

Do we really need another programming language?

Who Am I?@giordanoscalzohttps://github.com/gscalzo

A developer

After one year

For Real!

Officially, only Linux is Supported

Being Open-Source...

Server side development without a web framework?

We have a few...

Perfect: github.github.com/PerfectlySoft/Perfect (8829) Vapor: github.com/vapor/vapor (6763) Kitura: github.com/IBM-Swift/Kitura (4578) Swifton: github.com/necolt/Swifton (2016) Zewo: github.com/Zewo/Zewo (1358) Blackfish: github.com/elliottminns/blackfish (932) Slimane: github.com/noppoMan/Slimane (61) Tailor: github.com/brownleej/tailor (55) Kunugi: github.com/novi/Kunugi (35) Quark: github.com/QuarkX/Quark (33)

"Perfect is a complete and powerful toolbox,

framework, and application server for Linux, iOS, and

macOS"

They got money(Even without React. js!)

Open-source-ish, but enterprise-ish...

Sean StephensChief Executive Officer

let server = HTTPServer()

var routes = Routes()routes.add(method: .get, uri: "/", handler: { request, response in response.setHeader(.contentType, value: "text/html") response.appendBody(string: "<html><title>Hello, world!</title><body>Hello, world!</body></html>") response.completed() })

server.addRoutes(routes)server.serverPort = 8181server.documentRoot = "./webroot"configureServer(server)

do { try server.start()} catch PerfectError.networkError(let err, let msg) { print("Network error thrown: \(err) \(msg)")}

4 Laravel inspired

4 Easy to setup

4 Fantastic Command Line Tool

let drop = Droplet()drop.get("/") { request in return try drop.view.make("welcome.html")}drop.get("plaintext") { request in return "Hello, World!"}drop.serve()

4 Backed by IBM

4 Express.js-like

4 Perfectly integrated in IBM cloud solution BlueMix

import Kitura

let router = Router()

router.get("/") { request, response, next in response.send("Hello, World!") next()}

Kitura.addHTTPServer(onPort: 8080, with: router)Kitura.run()

Let's talk now of...

Performance!

Benchmarks are difficult

and useless...

Swift Frameworks Benchmarks

Fair Enough

Let's do some code

You can write Basic in Swift...

You can write Haskell-ish in Swift...

The sense of Swift

An Isomorphic Swift App!

A Universal Swift App!

Introducing

Mr Drizzle!

An hyper local weather app

MrDrizzle Server Requirements:4 Convert from Wunderground Models to MrDrizzle

Model

4 Refresh cache every hour

MrDrizzle Server

mkdir MrDrizzleServercd MrDrizzleServerswift package init --type executable

Swift Package Managerimport PackageDescription

let package = Package( name: "MrDrizzleServer", dependencies: [ .Package(url: "https://github.com/vapor/vapor.git", majorVersion: 1, minor: 0) ])

Let's make it run

// main.swiftimport Foundationimport HTTPimport Vapor

let wheaterUndergroundKey = "KEY"let wheaterUndergroundDomain = "api.wunderground.com"

let drop = Droplet()

drop.get("/hello") { _ in return "Hello World"}

drop.run()

$ swift build

> Cloning https://github.com/vapor/vapor.git> HEAD is now at 453f7cf Merge pull request #628> Resolved version: 1.0.3> Cloning https://github.com/vapor/crypto.git> HEAD is now at 0aaa68b Merge pull request #15> Resolved version: 1.0.1> Cloning https://github.com/vapor/core.git........> Compile Swift Module 'TypeSafeRouting' (3 sources)> Compile Swift Module 'Vapor' (83 sources)> Compile Swift Module 'MrDrizzleServer' (1 sources)> Linking ./.build/debug/MrDrizzleServer

$ .build/debug/MrDrizzleServer

> Could not load localization files> No cipher key was set, using blank key.> Chacha20 cipher requires an initialization > No command supplied, defaulting to serve> No preparations.> No servers.json configuration found.> Starting server at 0.0.0.0:8080

$ swift package generate-xcodeproj> generated: ./MrDrizzleServer.xcodeproj

Hello World for dummies

This version:

drop.get("/hello") { _ in return "Hello World"}

Is equivalent to:

func handler(request: Request) throws -> ResponseRepresentable { return Response(status: .ok, body: "Hello, World")}drop.get("/hello", handler: handler)

because:

extension Swift.String: ResponseRepresentable { public func makeResponse() -> Response { return Response(body: self.bytes) }}

Go back to MrDrizzleServer

The list of the stations:

struct StationInfo { let name: String let stationId: String let lat: Float let lon: Float}

let stationsInfo = [ StationInfo(name: "Chelsea", stationId: "ILONDON330", lat: 51.479633, lon:-0.180277), StationInfo(name: "Westminster", stationId: "ILONDON120", lat: 51.65343, lon:-0.183732) //...]

Let's define a schema for our models

Model schema in pseudocode

object Stations { Array of Station stations }object Station { string id float lat float lon string name Array of HourlyMeasure measures}object HourlyMeasure { int32 hour float temp_f float temp_c}

syntax = "proto3";

message Stations { repeated Station stations = 1;}message Station { string id = 1; float lat = 2; float lon = 3; string name = 4; repeated HourlyMeasure measures = 5;}message HourlyMeasure { int32 hour = 1; float temp_f = 2; float temp_c = 3;}

protobuf

Invented by Apple

Given this:

syntax = "proto3";

message Stations { repeated Station stations = 1;}message Station { string id = 1; float lat = 2; float lon = 3; string name = 4; repeated HourlyMeasure measures = 5;}message HourlyMeasure { int32 hour = 1; float temp_f = 2; float temp_c = 3;}

/* * DO NOT EDIT. * * Generated by the protocol buffer compiler. * Source: mrdrizzle.proto * */

public struct Stations: ProtobufGeneratedMessage { public var swiftClassName: String {return "Stations"} public var protoMessageName: String {return "Stations"} public var protoPackageName: String {return ""} //...}

public struct Station: ProtobufGeneratedMessage { public var swiftClassName: String {return "Station"} public var protoMessageName: String {return "Station"} public var protoPackageName: String {return ""} //...}

public struct HourlyMeasure: ProtobufGeneratedMessage { public var swiftClassName: String {return "HourlyMeasure"} public var protoMessageName: String {return "HourlyMeasure"} public var protoPackageName: String {return ""}

//...}

We extend these structs to instantiate from the wunderground JSON

Wheater Underground JSON:

{ "response": { "version": "0.1", }, "hourly_forecast": [ { "FCTTIME": { "hour": "22", "mday": "19", "mday_padded": "19", "yday": "292", "isdst": "1", "age": "", "UTCDATE": "" }, "temp": { "english": "52", "metric": "11" }, "condition": "Clear", "icon": "clear", "metric": "-9999" }, ...

extension Station { init?(stationInfo: StationInfo, json: JSON) { guard let hourly_forecast = json["hourly_forecast"]?.array as? [JSON] else { return nil }

let measures = hourly_forecast.flatMap { HourlyMeasure(json: $0) }

self.init(lat: stationInfo.lat, lon: stationInfo.lon, name: stationInfo.name, measures: measures) }}

extension HourlyMeasure { init?(json: JSON) { guard let fctTime = json["FCTTIME"]?.object, let hour = fctTime["hour"]?.string, let temp = json["temp"]?.object, let tempF = temp["english"]?.string, let tempC = temp["metric"]?.string else { return nil }

self.init(hour: Int32(hour), tempF: Float(tempF), tempC: Float(tempC)) }}

Retrieving from Wunderground Server

extension Station { init?(stationInfo: StationInfo, client: ClientProtocol.Type) { let url = "http://\(wheaterUndergroundDomain)/api/" + "\(wheaterUndergroundKey)/hourly/q/pws:" + "\(stationInfo.stationId).json" guard let response = try? client.get(url), case .data(let bytes) = response.body, let json = try? JSON(bytes: bytes) else { return nil }

self.init(stationInfo: stationInfo, json: json) } }

Refreshing every hour

We cannot use URLSession :-(class WeatherService { private let refreshQueue = DispatchQueue(label: "com.mrdrizzle.refresh") private(set) var stations = Stations()

init(stationsInfo: [StationInfo], client: ClientProtocol.Type) { refresh(stationsInfo: stationsInfo, client: client) }

private func refresh(stationsInfo: [StationInfo], client: ClientProtocol.Type) { stations = stations.refreshed(given: stationsInfo, client: client) refreshQueue.asyncAfter(deadline: .now() + 3600) { [weak self] in self?.refresh(stationsInfo: stationsInfo, client: client) } } }

private extension Stations { func refreshed(given stationsInfo: [StationInfo], client: ClientProtocol.Type) -> Stations { return Stations(stations: stationsInfo.flatMap { Station(stationInfo: $0, client: client) }) }}

Putting everything together

//main.swiftlet drop = Droplet()

let stationsInfo = [ StationInfo(name: "Chelsea", stationId: "ILONDON330", lat: 51.479633, lon:-0.180277), StationInfo(name: "Westminster", stationId: "ILONDON120", lat: 51.65343, lon:-0.183732) //...]

let weatherService = WeatherService(stationsInfo: stationsInfo, client: drop.client)

drop.get("/api/weather") { _ in let stations = weatherService.stations

guard let data = try? stations.serializeProtobuf(), let bytes = try? data.makeBytes() else { throw Abort.serverError }

return Response(status: .ok, body: .data(bytes))}

drop.run()

Job done!

MrDrizzle Client

Networking classes from

https://talk.objc.io/episodes/S01E01-

networking

struct Resource<A> { let url: URL let parse: (Data) -> A?}

for example:

let url = URL(string: "http://mrdrizzle.com:8080/hello")!let helloResource = Resource<String>(url: url, parse: { data in return String(data: data, encoding: .utf8)})

class ApiService { func load<A>(resource: Resource<A>, completion: @escaping (A?) -> ()) { URLSession.shared.dataTask(with: resource.url) { data, response, error in guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200, let data = data else { completion(nil) return }

completion(resource.parse(data)) }.resume() }}

let url = URL(string: "http://mrdrizzle.com:8080/hello")!let helloResource = Resource<String>(url: url) { data in return String(data: data, encoding: .utf8)}

ApiService().load(resource: helloResource) { guard let hello = $0 else { print("ERROR - Hello") return }

print(hello)}

let url = URL(string: "http://mrdrizzle.com:8080/hello")!let stationResources = Resource<Stations>(url: url) { data in return try? Stations(protobuf: data)}

ApiService().load(resource: stationResources) { guard let stations = $0 else { print("ERROR - Stations") return }

print(stations)}

It's ok :-)

However...

Apps are so 2014!

Let's do something modern

A Deep Learning Functional Reactive Chatbot!

Story behind it

Diagram of a Facebook Messenger ChatBot

Chat Flow

Let's do it

import PackageDescription

let package = Package( name: "UncleLucio", dependencies: [ .Package(url: "https://github.com/vapor/vapor.git", majorVersion: 1, minor: 0) ])

// main.swiftimport Foundationimport Vaporimport HTTP

let PAGE_ACCESS_TOKEN = "STUFF"let fbURL = "https://graph.facebook.com/v2.6/me/messages?access_token=" + PAGE_ACCESS_TOKEN

let uncleLucio = UncleLucio(jokesDB: JokesDB())let drop = Droplet()

// main.swiftdrop.get("fbwebhook") { request in guard let token = request.data["hub.verify_token"]?.string, let response = request.data["hub.challenge"]?.string else { throw Abort.badRequest }

if token == "UNCLELUCIO_VERIFICATION_TOKEN" { return response // Response(status: .ok, text: response) } else { return "Error, invalid token"//Response(status: .ok, text: "Error, invalid token") }}

// main.swiftdrop.post("fbwebhook") { request in

request.log()

guard let jsonBody = request.json, let chatMessage = ChatMessage(message: jsonBody) else { throw Abort.badRequest }

let replyMessage = uncleLucio.message(after: chatMessage) return try drop.client.post(fbURL, headers: ["Content-Type": "application/json; charset=utf-8"], body: replyMessage.toJSON())}

drop.run()

// ChatMessage.swiftimport Foundationimport Vaporimport HTTP

struct ChatMessage { let sender: String let recipient: String let text: String?}

Payload send by Facebook callback

{ "object": "page", "entry": [ { "id": "1677732245875632", "time": 1476209402183, "messaging": [ { "sender": { "id": "1243544059050238" }, "recipient": { "id": "1677732245875632" }, "timestamp": 1476209402090, "message": { "mid": "mid.1476209402075:82aff934133d72d746", "seq": 17, "text": "Knock knock" } } ] } ]}

// ChatMessage.swiftextension ChatMessage { init?(message: JSON) { guard let entry = message["entry"]?.array?.first as? JSON else { return nil }

guard let messaging = entry["messaging"]?.array?.first as? JSON else { return nil }

guard let senderWrapper = messaging["sender"]?.object, let sender = senderWrapper["id"]?.string else { return nil } self.sender = sender guard let recipientWrapper = messaging["recipient"]?.object, let recipient = recipientWrapper["id"]?.string else { return nil } self.recipient = recipient guard let message = messaging["message"]?.object else { return nil } self.text = message["text"]?.string }}

// ChatMessage.swiftextension ChatMessage { func toJSON() throws -> JSON { return try JSON(node: [ "sender": try JSON(node: [ "id": sender ]), "recipient": try JSON(node: [ "id": recipient ]), "message": try JSON(node: [ "text": text ]), ]) }}

// UncleLucio.swiftclass UncleLucio { private let jokesDB: JokesDB private var sessions = [String: State]()

init(jokesDB: JokesDB) { self.jokesDB = jokesDB }

func message(after chatMessage: ChatMessage) -> ChatMessage { //... return replyMessage }}

// UncleLucio.swift func message(after chatMessage: ChatMessage) -> ChatMessage { let state = sessions[chatMessage.sender] ?? StartState(joke: jokesDB.randomJoke())

let (text, newState) = state.nextState(when: chatMessage.text ?? "pota")

if newState is Done { sessions.removeValue(forKey: chatMessage.sender) } else { sessions[chatMessage.sender] = newState } let replyMessage = ChatMessage(sender: chatMessage.recipient, recipient: chatMessage.sender, text: text) return replyMessage }

// UncleLucio.swift

protocol State { func nextState(when message: String) -> (String, State)}

// UncleLucio.swift

struct StartState: State { let joke: Joke func nextState(when message: String) -> (String, State) { if message.lowercased().contains("joke") { return ("Knock Knock", WaitingForReplyState(joke: joke)) } return ("pota", self) }}

struct WaitingForReplyState: State { let joke: Joke func nextState(when message: String) -> (String, State) { let text = message.lowercased() if text.contains("who's there") || text.contains("who is there") { return ("\(joke.subject)!", WaitingForSubjectReplyState(joke: joke)) } return ("pota", StartState(joke: joke)) }}

struct WaitingForSubjectReplyState: State { let joke: Joke func nextState(when message: String) -> (String, State) { let text = message.lowercased() if text.contains("\(joke.subject.lowercased()) who") { return ("\(joke.punchline)\nahahah", Done()) } return ("pota", StartState(joke: joke)) }}

struct Done: State { func nextState(when message: String) -> (String, State) { return ("pota", Done()) }}

Really easy to test

func testInStart_ReceivingGarbage_SaysSlogan_GoesStart() { let state = StartState(joke: joke())

let (text, nextState) = state.nextState(when: "foobar") XCTAssertEqual(text, "pota")

XCTAssertTrue(nextState is StartState) }

func testWaitingForSubjectReply_ReceivingReply_SaysPunchline_GoesDone() { let state = WaitingForSubjectReplyState(joke: joke())

let (text, nextState) = state.nextState(when: "\(joke().subject) who") XCTAssertEqual(text, "\(joke().punchline)\nahahah") XCTAssertTrue(nextState is Done) }

class JokesDB { private let jokes: [Joke] = [ ("Harry", "Harry up and let me in!"), ("Wanda", "Wanda hang out with me right now?"), ("Olive", "Olive you and I don’t care who knows it!"), ("Ho-ho", "You know, your Santa impression could use a little work."), ("Hanna", "...Hanna partridge in a pear tree!"), ("Mary and Abbey", "Mary Christmas and Abbey New Year!"), ("Irish", "Irish you a Merry Christmas!"), ("Yule log", "Yule log the door after you let me in, won’t you?"), ("Ya", "I’m excited to see you too!"), ("Sherlock", "Sherlock your door shut tight!"), ("Scold", "Scold outside—let me in!"), ("Robin", "Robin you! Hand over your cash!"), ("Needle", "Needle little help gettin’ in the door."), ("Nana", "Nana your business who’s there."), ("Luke", "Luke through the keyhole to see!"), ("Isabelle", "Isabelle working, or should I keep knocking?"), ].map { Joke(subject: $0.0, punchline: $0.1) }

func randomJoke() -> Joke { return jokes.randomItem() }}

extension Array { func randomItem() -> Element { let index = Int(arc4random_uniform(UInt32(self.count))) return self[index] }}

https://github.com/gscalzo/UncleLucio

Finally...

A reason for using Swift in Server...

Often in our job...

But sometimes...

"Everything in Its Right Place" (cit.)

Thank You!

the joy of serverside swift development

Mobile