Let the |> fun begin

1. An introduction to F# (part 2) Let the |> fun begin Bogdan Brinzarea-Iamandi BancaRomaneasca 25 February 2010

2. Agenda

3. Asynchronous and parallel programming

4. Why should these matter to me?

5. 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

6. Parallel and reactive language • Multiple active evaluations (threads computing results) • Multiple pending reactions (callbacks and agents waiting for events and messages)

7. Background worker pattern • Not useful for asynchronous operations • Imperative programming • Sharing mutable data between threads • Cancellations • Raising events in the right thread

8. Immutability • Optimization opportunities • Easily transferable between threads • Reliability

9. Async advantages • Ease of change • Cancellation checking • Simple resource management • Exception propagation

10. 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

11. Async.Parallel • Takes async objects and creates async tasks • Uses QueueUserWorkItem • Fork/join pattern • Does not report progress seq<Async<'T>> -> Async<'T Array>

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

13. Async.StartWithContinuations • Starts and ends in the same thread • Useful for UI updating • Continuations for: • Complete • Exception • Cancellation

14. ! = 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!

15. 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

16. 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.”

17. 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

18. Unit testing

19. Object oriented approach • NUnit • xUnit.net

20. Functional approach • FsUnit based on NUnit • FsCheck inspired from Haskell’s QuickCheck • FsTest based on xUnit.net • NaturalSpec based on NUnit • FsSpec readable DSL

21. 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/