Let the |> fun beginAn introduction to F# (part 2)

Bogdan Brinzarea-IamandiBanca Romaneasca

25 February 2010

AgendaTopic Covered

TodayHistory 22 february

2010From imperative to functional 22 february

2010Fundamentals 22 february

2010Data structures 22 february

2010Pattern Matching 22 february

2010Immutability vs. Mutability 22 february

2010Object Oriented Programming 22 february

2010Async and Parallel Programming

Unit testing

Asynchronous and parallel programming

Why should these matter to me?Problem SolutionI/O bound application Asynchronous processingCPU bound application Parallel and distributed

processingFreezing UI Asynchronous processingSharing state Immutability

Why should these matter to me? Working with threads is difficult Synchronizing and sharing state are

difficult Introducing bugs is easy The code is complicated

Parallel and reactive language Multiple active evaluations (threads

computing results) Multiple pending reactions (callbacks

and agents waiting for events and messages)

Background worker pattern Not useful for asynchronous

operations Imperative programming Sharing mutable data between

threads Cancellations Raising events in the right thread

Immutability

Optimization opportunities Easily transferable between threads Reliability

Async advantages

Ease of change Cancellation checking Simple resource management Exception propagation

async {…}

Creates async objects These tasks can be run

In the current thread In a background thread In parallel using fork/join mechanism As continuations

Async.Parallel

Takes async objects and creates async tasks

Uses QueueUserWorkItem Fork/join patternDoes not report progress

seq<Async<'T>> -> Async<'T Array>

Async.RunSynchronously Runs synchronous computation Waits for the result Batch processing jobs Matrix multiplication

Async.StartWithContinuations Starts and ends in the same thread Useful for UI updating Continuations for:

Complete Exception Cancellation

! = async

let! for async method calls The thread is suspended until the

result in available The rest of the code runs as a

continuation use! resource disposing equivalent

of let!

Parallel programming

Leverage parallel hardware capabilities

Data parallel programming with PLinq Easy to implement Abstracts away complexity Transparent partition and merge

operations Works on seq<a> and IEnumerable<T>

Task parallel programming using the new Task Parallel Library in .NET 4.0

Agent model concurrency Erlang message passing style “An actor is a computational entity that, in

response to a message it receives, can concurrently:▪ send a finite number of messages to

other actors;▪ create a finite number of new actors;▪ designate the behavior to be used for

the next message it receives.”

Agent model concurrency Asynchronous message passing Can have even 1000 agents Agents are lightweight Based on async programming State isolation between agents No concurrency and data races

Unit testing

Object oriented approach NUnit xUnit.net

Functional approach

FsUnit based on NUnit FsCheck inspired from Haskell’s

QuickCheck FsTest based on xUnit.net NaturalSpec based on NUnit FsSpec readable DSL

Resources Expert F# by Don Syme Programming F# by Chris Smith CTO Corner - http://ctocorner.com/fsharp/book/ HubFS

http://cs.hubfs.net/ Matthew Podwysocki

http://weblogs.asp.net/podwysocki/ Don Syme

http://blogs.msdn.com/dsyme Chris Smith

http://blogs.msdn.com/chrsmith/