Async Programming in F#

Zhao Jie - SNDA - June 2010

About Me

• 赵劼 / 老赵 / Jeffrey Zhao / 赵姐夫

• Programmer

• Blogger - http://blog.zhaojie.me/

• Twitterer: @jeffz_cn

• F#, Scala, JavaScript, Python, .NET, mono...

• Java (as the language) hater

What’s F#

• Languages by Don Syme, MS Research

• Strongly Statically Typed Language

• Functional Language with OO Ability

• General Purpose Language

Async programming is complex ...

...and will only getmore complex in the

near future

Four Big Concurrency Challenges

• Shared State

• Code Locality

• I/O Parallelism

• Scaling Up

Shared State

• Difficult to maintain and test

• Very difficult to parallelize

• Locking is fundamentally error prone‣ Must guess where parallelism is needed

‣ All consumers need to participate

Demo: Immutability

Immutability in F#

• Immutable Union

• Immutable Record

• Immutable Set

• Immutable Objects

• Immutable Tuple

• Immutable List

• Immutable Map

• Immutable ...

Code Locality

• Used to expressing algorithms linearly

• Async requires logical division of algorithms

• Very difficult to‣ Combine multiple asynchronous operations

‣ Deal with exceptions and cancellation

Asynchronous Workflow

async  {  ...  }

async  {        let!  res  =  <async  work>        ...  }

React

an HTTP Responsean UI Event

a Timer Callbacka Query Response

a Web Servcie Responsea Disk I/O Completion

an Agent Message

async  {        let!  img  =  AsyncRead  "http://..."        printfn  "loaded!"        do!  AsyncWrite  img  @"c:\..."        printfn  "saved!"  }

async.Delay(fun  -­‐>        async.Bind(AsyncRead  "http://...",  (fun  img  -­‐>                printfn  "loaded!"                async.Bind(AsyncWrite  img  @"c:\...",  (fun  ()  -­‐>                        printfn  "saved!"                        async.Return())))))

=

Demo: Code Locality

I/O Parallelism

• Software is often I/O-bound‣ Leveraging web services

‣ Working with data on disk

• Network and disk speeds increasing slower

• I/O resources are inherently parallel‣ Huge opportunity for performance

Demo: I/O Parallelism

Scaling to Multi-Machine

• To scale up, must to go beyond a single machine

• Multi-machine resources becoming common‣ Roll-you-own clusters with cheap hardware

‣ On-demand cloud compute with Azure

• But‣ Shared memory doesn’t scale

... the principle we go by is, don't expect to see a particular concurrency model put into C# because there're many different concurrency model ... it's more about finding things are common to to all kinds of concurrency ...

- Anders Hejlsberg

Demo: Agents

Concurrency Challenges

• Shared State - Immutability

• Code Locality - async { ... }

• I/O Parallelism - async { ... }

• Scaling to Multi-Machine - Agents

F#

• Modern, simple, powerful and productive

• Ready for production use with VS 2010

• Simplified parallel and async programming for today and tomorrow

• Support .NET 4.0 / 3.5 and mono

• Open Source *

F# Resourceshttp://fsharp.net

Programming F# Expert F# 2.0 Real World FP

Q & A

Thanks!