1 / 21

Introduction to F#: Asynchronous and Parallel Programming Explained

This presentation by Bogdan Brinzarea-Iamandi, held on February 25, 2010, delves into the intricacies of asynchronous and parallel programming using F#. It emphasizes the challenges of working with threads, such as complexity, synchronization, and the introduction of bugs. The session covers key topics like immutability, the async/await pattern, parallel programming with PLinq, and the Agent model for concurrency. Learn how to leverage parallel hardware capabilities and utilize asynchronous programming to enhance the reliability and efficiency of your applications.

wesley-bates
Télécharger la présentation

Introduction to F#: Asynchronous and Parallel Programming Explained

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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/

More Related