F# and SignalR for a FastWeb

Riccardo Terrell – Zurich F# UG

F# and SignalR for a FastWeb

The tools we use have a profound (and devious!) influence on our thinking habits, and, therefore, on our thinking abilities.

— Edsger Dijkstra

Agenda

Why F# on the Web

F# Magic

SignalR and F#

CQRS and F#

Code & Code

Goals - Plan of the talk

F# is a great and mature language for Web Development

F# has built in features to develop Fast and Scalable Web App

F# |> RX |> SignalR

|> CQRS |>

Technology trends

Mobile

Claud computing

Real Time notification

Single Page Apps

Big Data

Scalable

Maintanable & Readable

Reliable & Testable

Composable & Reusable

Concurrent

…F# and Functional Paradigm can help

F# helps with the mission statement simple code for complex problem… F# great for scalability and concurrent ready F# play well together with Web Application Use function and composition as building block

Why F# on the web? Really?

Is functional programming and F# mostly targeted at scientific or financial domains?

Is functional programming and F# just for Server Side computations?

Is functional programming and F# mostly about algorithms and calculations?

Why F# on the web?

Succinct - F# is concise, readable and type-safe, for fast development of robust web solutions

Reactive and Scalable - F# asynchronous programming simplifies scalable, reactive web programming, and Agent too!

Fast - F# code execution is fast, using native code generation from scripted or project code

Interoperable - F# interoperates seamlessly with languages such as C#, JavaScript and TypeScript, F# is JavaScript-ready through WebSharper and FunScript

F# Type Providers on the Web ¤  JSON Type Provider ¤  CSV ¤  WSDL ¤  WMI ¤  Data Access – SQL and EF ¤  Funscript to Javascript ¤  And more, write your own

Type provider

IDE

IntelliSense for Generated Types

Compiler

Type-Check Imported Types

Compile using Type Provider

F# Type Providers on the Web

Function Composition

Asynchronous Workflows

¤  Software is often I/O-bound, it provides notable performance benefits n Connecting to the Database n  Leveraging web services n  Working with data on disk

¤ Network and disk speeds increasing slower ¤  Not Easy to predict when the operation will complete (no-

deterministic)

¨  Easy transition from synchronous ¤  Wrap in asynchronous workflow with the async keyword, use let! for async

calls and add return ¤  No need of explicit callback ¤  Easy to debug

¨  Supports loops, recursion, exceptions, cancellation, resource management ¨  Operation complete in the same scope

let getLength url = let wc = new WebClient() let data = wc.DownloadString(url) data.Length

Anatomy of Async Workflows




let getLength url = async { let wc = new WebClient() let data = wc.DownloadString(url) data.Length }





let getLength url = async { let wc = new WebClient() let data = wc.DownloadString(url) return data.Length }





let getLength url = async { let wc = new WebClient() let! data = wc.AsyncDownloadString(url) return data.Length }


Asynchronous Workflows let openFileAsynchronous : Async<unit> async { use fs = new FileStream(@"C:\Program Files\..., …)

let data = Array.create (int fs.Length) 0uy let! bytesRead = fs.AsyncRead(data, 0, data.Length) do printfn "Read Bytes: %i, First bytes were: %i %i %i ..." bytesRead data.[1] data.[2] data.[3] }

¤  Async defines a block of code we would like to run asynchronously ¤  We use let! instead of let

n  let! binds asynchronously, the computation in the async block waits until the let! completes

n  While it is waiting it does not block n  No program or OS thread is blocked

F# MailboxProcessor – aka Agent

¨  F# really shines in the area of distributed computing ¤  Language features such as Async Workflow

and MailboxProcessor (a.k.a. agent) open the doors for computing that focuses on message passing concurrency

¤  Scaling Up & Scaling Out easy to implement

Concurrent Model Programming

An Agent is an independent computational entity which contains a queue, and receives and

processes messages

It provides immutability and isolation

(it enforces coarse-grained isolation through message-passing)

IObserver & IObservable

When to use Rx

http://www.introtorx.com/content/v1.0.10621.0/01_WhyRx.html

F# to JavaScript - FunScript

¨  FunScript is Javascript compiler ¤ Write F# client-side code with full intellisense ¤ Leverage F# functional goodies that compiles in JS

n Higher Order functions n Pattern Matching n Type Inference

Full functional Data-Structure

Records

Discriminated Union

Tuples

List Map Set seq

.Net mutable Collections Array – Dictionary - List

F# to JavaScript - FunScript

¨  F# unique Features ¤ Async Workflow ¤ Reactive Extensions

¤ Type Providers ¤ Computation Expression

F# and MVC - Web Api

WPF Android

iPad

Pc Win Os

iPhone Mac

Web API

F# and MVC - Web Api

F# Magic in review TypeProvider

Function Composition - ROP

Async Workflow

MailboxProcessor – aka Agent

Reactive Extensions

FunScript

Full integration with Asp.Net MVC & Web API

RX the Dual of IEnumerable http://en.wikipedia.org/wiki/Dual_(category_theory)

Reversing arrows The input becomes output and <->

IObserver & IObservable

When to use Rx http://www.introtorx.com/content/v1.0.10621.0/01_WhyRx.html

Subject<‘a>.. as a bus

What is SignalR?

Asp.Net

Self-Host Owin

javaScript

.Net WinRT

What is SignalR?

SignalR

Client Server

Why SignalR?

… the real questions are ¨  When the Web users want their Data? ¨  When the Web user want the latest info?

Why SignalR?

What can SignalR do? SignalR can be used to add any sort of "real-time" web functionality to your application… ¨  Anything that needs live data

¤  Chat Room application

¤  Broadcasting (Stock Tickers, Live Scores…) ¤  Internet Games ( http://shootr.signalr.net/default.aspx# )

¤  Social Media ¤  Collaborative Apps

SignalR levels of abstraction

Hubs

Persistent Connection

Transports

Internet protocols

Abs

tract

ion

leve

l

WebSockets Server-Sent

Events Long polling Forever frame

Persistent Connection

Client (javascript)

var conn = $.connection(“myChat”); conn.start(); conn.send(“Hello F#!!”); conn.receive(function(text){ $(“#log”).append(“<li>” + text …

type MyChat() = inherit PersistentConnection() override x.OnConnected() : Task = … override x.OnReceived(data) : Task = Connection.Broadcast(data) override x.OnDisconnected() : Task =

Hubs

Client (javascript)

var chat = $.connection.myChat $.connection.hub.start(); chat.server.message(“Hello F#!!”); chat.client.notify = function(text){ $(“#log”).append(“<li>” + text …

[<HubName(”myChat")>] type MyChat() =

inherit Hub member x.Message(text) : Task = Clients.All.notify(text)

Hubs – Sending Message

Clients.All Clients.Group(groupName, excludeConnectionIds)

Clients.AllExcept(connections) Clients.Groups(groupNames, excludeConnectionIds)

Clients.Caller Clients.OthersInGroup(groupName)

Clients.Client(connectionId) Clients.OthersInGroups(groupNames)

Clients.Clients(connestionIds Clients.User(userName)

Clients.Others

SignalR ? Dynamic

SignalR & JavaScript

F# Type Provider for SignalR

Type provider giving a typed view of a .NET SignalR server Hub to client-side code compiled from F# to JavaScript with FunScript.

Scale-out SignalR (backplane)

Web N-Tier Architecture In the case of three-tier architecture 1)  Presentation tier 2)  Business logic tier 3)  Data storage tier Problems: 1)  The project can become very difficult to

maintain 2)  Scalability as only one data base

handles read/write

CQRS pattern Command Query Responsibility Segregation

CQRS is sort of data flow pattern

Filter Transform Buffer Enriched Persisted Broadcast And more…

CQRS benefits ¨  “Almost” infinite scalability

¤  Performance and scalability are always concerns when handling a large volume of transactions over the internet

¨  Clear understanding what the application does ¨  Separation of concerns

.. scalability, simplicity, and maintainability…

How to handle UI-Eventual Consistency

Building a UI for a CQRS system is challenging

¨  The commands could complete fast ¨  The read model is eventually consistent ¨  The read of the data store may return stale results

SignalR to replace Query

CQRS pattern Command Query Responsibility Segregation

CQRS CAP ¨  This works when the user actually expects some sort of “background” work to happen, or that we present

this to the user in a meaningful way. ¨  But when doing CQRS, eventual consistency is an orthogonal choice. They are two completely separate

concerns. Going back to our new CQRS design: ¨  We have many choices here on what should be synchronous, and what should not. It can all be

synchronous, all be async, it’s just a separate decision. ¨  What I have found though that is if we build asynchronous denormalization in the back-end, but try to

mimic synchronous results in the front end, we’re really just choosing async where it’s not needed. Not in all cases of course, but for most of the ones I’ve seen.

¨  Some async-sync mimicry I’ve seen includes:

¨  Using Ajax from the server to ping the read store to see if denormalization is “done” ¨  Using SignalR to notify the client when the denormalization is “done”

¨  Writing to the read store synchronously, but then allowing eventual consistency to fix any mistakes

SAGA ¨  A Saga is a distribution

of multiple workflows across multiple systems, each providing a path (fork) of compensating actions in the event that any of the steps in the workflow fails.

¨  “Sagas and persistence ¨  In general, a saga must be persistent

and persistence of the saga is a typical responsibility of the bus. In this regard, it might completely be transparent to you if you don’t write a bus class yourself. In the sample Bus class, we simulated persistence through an in-memory dictionary—whereas, for example, NServiceBus uses SQL Server. For persistence to happen, it is key that you give a unique ID to each saga instance.”

When to use CQRS ¨  In general, the CQRS pattern could be very valuable in situations when you have highly

collaborative data and large, multi-user systems, complex, include ever-changing business rules, and delivers a significant competitive advantage of business. It can be very helpful when you need to track and log historical changes.

¨  With CQRS you can achieve great read and write performance. The system intrinsically supports scaling out. By separating read and write operations, each can be optimized.

¨  CQRS can by very helpful when you have difficult business logic. CQRS forces you to not mix domain logic and infrastructural operations.

¨  With CQRS you can split development tasks between different teams with defined interfaces.

¨  When not to use CQRS ¨  If you are not developing a highly collaborative system where you don't have multiple

writers to the same logical set of data you shouldn't use CQRS.

SignalR Stock Ticker http://www.asp.net/signalr/overview/getting-started/tutorial-server-broadcast-with-signalr

The stock ticker application represents of real-time applications in which you want to periodically "push," or broadcast, notifications from the server to all connected clients.

C# F# Diff

Lines of code 365 142 -62%

Demo Project

StockTicker Hub

Agent Supervisor

Web API [Post]

Command

SignalR

Validation Command Publish Command

Stock-Market UpdateStocks

Open/Close Market Event Store

Update UI SignalR Client

Actor

Actor

Actor Actor Actor

Summary

F# is a great and mature language for Web Development

F# has built in features to develop Fast and Scalable Web App

F# |> RX |> SignalR

|> CQRS |>

Q & A ?

The tools we use have a profound (and devious!) influence on our thinking habits, and, therefore, on our thinking abilities.

-- Edsger Dijkstra

References ¨  https://wizardsofsmart.wordpress.com

¨  http://www.todobackend.com

¨  http://funscript.info

Online resources

¨  www.fsharp.org Information & community www.tryfsharp.org Interactive F# tutorials

How to reach me

https://github.com/rikace/FS-SignalR http://meetup.com/DC-fsharp @DCFsharp @TRikace [email protected]

How to reach me github.com/DCFsharp meetup.com/DC-fsharp/ @DCFsharp [email protected]

F# and SignalR for a FastWeb

Technology

Transcript of F# and SignalR for a FastWeb