Download as PDF, PPTX
![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](https://image.slidesharecdn.com/fs-signalrontheweb-150403044419-conversion-gate01/85/F-and-SignalR-for-a-FastWeb-18-320.jpg)
![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)](https://image.slidesharecdn.com/fs-signalrontheweb-150403044419-conversion-gate01/85/F-and-SignalR-for-a-FastWeb-40-320.jpg)
![Demo Project
StockTicker Hub
Agent
Supervisor
Web API
[Post]
Command
SignalR
Validation Command
Publish
Command
Stock-Market
UpdateStocks
Open/Close MarketEvent
Store
Update UI SignalR Client
Actor
Actor
Actor
Actor Actor](https://image.slidesharecdn.com/fs-signalrontheweb-150403044419-conversion-gate01/85/F-and-SignalR-for-a-FastWeb-58-320.jpg)
![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](https://image.slidesharecdn.com/fs-signalrontheweb-150403044419-conversion-gate01/75/F-and-SignalR-for-a-FastWeb-18-2048.jpg)
![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)](https://image.slidesharecdn.com/fs-signalrontheweb-150403044419-conversion-gate01/75/F-and-SignalR-for-a-FastWeb-40-2048.jpg)
![Demo Project
StockTicker Hub
Agent
Supervisor
Web API
[Post]
Command
SignalR
Validation Command
Publish
Command
Stock-Market
UpdateStocks
Open/Close MarketEvent
Store
Update UI SignalR Client
Actor
Actor
Actor
Actor Actor](https://image.slidesharecdn.com/fs-signalrontheweb-150403044419-conversion-gate01/75/F-and-SignalR-for-a-FastWeb-58-2048.jpg)
Uploaded byRiccardo Terrell
F# and SignalR for a FastWeb
F# and SignalR can be used to create fast and scalable web applications. F#'s support for asynchronous and reactive programming simplifies building real-time web functionality. SignalR enables adding real-time functionality like live data updates and chat to web apps using technologies like websockets, server-sent events and long polling. The CQRS pattern also supports scalability by separating command and query operations.
More Related Content
Similar to F# and SignalR for a FastWeb
F# and SignalR for a FastWeb
- 1. 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
- 2. Agenda Why F# onthe Web F# Magic SignalR and F# CQRS and F# Code & Code
- 3. Goals - Planof 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 |>
- 4. Technology trends Mobile Claud computing RealTime notification Single Page Apps Big Data Scalable Maintanable & Readable Reliable & Testable Composable & Reusable Concurrent
- 5. …F# and FunctionalParadigm 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
- 6. Why F# onthe 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?
- 7. Why F# onthe 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
- 9. F# Type Providerson 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
- 10. F# Type Providerson the Web
- 11.
- 12.
- 13. Asynchronous Workflows ¤ Softwareis 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)
- 14. ¨ Easy transitionfrom 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
- 15. ¨ Easy transitionfrom 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 = async { let wc = new WebClient() let data = wc.DownloadString(url) data.Length } Anatomy of Async Workflows
- 16. ¨ Easy transitionfrom 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 = async { let wc = new WebClient() let data = wc.DownloadString(url) return data.Length } Anatomy of Async Workflows
- 17. ¨ Easy transitionfrom 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 = async { let wc = new WebClient() let! data = wc.AsyncDownloadString(url) return data.Length } Anatomy of Async Workflows
- 18. 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
- 19. 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
- 20. Concurrent Model Programming AnAgent 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)
- 21.
- 22. When to useRx http://www.introtorx.com/content/v1.0.10621.0/01_WhyRx.html
- 23. 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
- 24. Full functional Data-Structure Records DiscriminatedUnion Tuples List Map Set seq .Net mutable Collections Array – Dictionary - List
- 25. F# to JavaScript- FunScript ¨ F# unique Features ¤ Async Workflow ¤ Reactive Extensions ¤ Type Providers ¤ Computation Expression
- 26. F# and MVC- Web Api WPF Android iPad Pc Win Os iPhone Mac Web API
- 27. F# and MVC- Web Api
- 28. F# Magic inreview TypeProvider Function Composition - ROP Async Workflow MailboxProcessor – aka Agent Reactive Extensions FunScript Full integration with Asp.Net MVC & Web API
- 29. RX the Dualof IEnumerable http://en.wikipedia.org/wiki/Dual_(category_theory) Reversing arrows The input becomes output and <->
- 30.
- 31. When to useRx http://www.introtorx.com/content/v1.0.10621.0/01_WhyRx.html
- 32.
- 33.
- 34.
- 35. Why SignalR? … thereal questions are ¨ When the Web users want their Data? ¨ When the Web user want the latest info?
- 36.
- 37. What can SignalRdo? 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
- 38. SignalR levels ofabstraction Hubs Persistent Connection Transports Internet protocols Abstractionlevel WebSockets Server-Sent Events Long polling Forever frame
- 39. Persistent Connection Client (javascript) varconn = $.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 =
- 40. 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)
- 41. Hubs – SendingMessage Clients.All Clients.Group(groupName, excludeConnectionIds) Clients.AllExcept(connections) Clients.Groups(groupNames, excludeConnectionIds) Clients.Caller Clients.OthersInGroup(groupNam e) Clients.Client(connectionId) Clients.OthersInGroups(groupNa mes) Clients.Clients(connestionIds Clients.User(userName) Clients.Others
- 42.
- 43.
- 44. F# Type Providerfor SignalR Type provider giving a typed view of a .NET SignalR server Hub to client- side code compiled from F# to JavaScript with FunScript.
- 45.
- 46. Web N-Tier Architecture Inthe 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
- 47. CQRS pattern Command QueryResponsibility Segregation
- 48. CQRS is sortof data flow pattern Filter Transform Buffer Enriched Persisted Broadcast And more…
- 49. 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…
- 50. How to handleUI-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
- 51.
- 52. SignalR to replaceQuery
- 53. CQRS pattern Command QueryResponsibility Segregation
- 54. CQRS CAP ¨ Thisworks 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
- 55. SAGA ¨ A Sagais 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.”
- 56. When to useCQRS ¨ 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.
- 57. SignalR Stock Ticker http://www.asp.net/signalr/overview/getting-started/tutorial-server-broadcast-with-signalr Thestock 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%
- 58. Demo Project StockTicker Hub Agent Supervisor WebAPI [Post] Command SignalR Validation Command Publish Command Stock-Market UpdateStocks Open/Close MarketEvent Store Update UI SignalR Client Actor Actor Actor Actor Actor
- 60. Summary F# is agreat and mature language for Web Development F# has built in features to develop Fast and Scalable Web App F# |> RX |> SignalR |> CQRS |>
- 61. Q & A? The tools we use have a profound (and devious!) influence on our thinking habits, and, therefore, on our thinking abilities. -- Edsger Dijkstra
- 62. References ¨ https://wizardsofsmart.wordpress.com ¨ http://www.todobackend.com ¨ http://funscript.info
- 63. Online resources ¨ www.fsharp.orgInformation & community www.tryfsharp.org Interactive F# tutorials
- 64. How to reachme https://github.com/rikace/FS-SignalR http://meetup.com/DC-fsharp @DCFsharp @TRikace rterrell@microsoft.com
- 65. How to reachme github.com/DCFsharp meetup.com/DC-fsharp/ @DCFsharp rterrell@microsoft.com