Introduction to F# for the New England Visual Basic Professionals User Group.

1. Introduction to F# Talbott Crowell

2. Functional programming has been around a long time Not new Long history Functional programming is safe A concern as we head toward manycore and cloud computing Functional programming is on the rise Why another language?

3. 1930’s: lambda calculus (roots) 1956: IPL (Information Processing Language) “the first functional language 1958: LISP “a functional flavored language” 1962: APL (A Programming Language) 1973: ML (Meta Language) 1983: SML (Standard ML) 1987: Caml (Categorical Abstract Machine Language ) and Haskell 1996: OCaml (Objective Caml) Functional programming has been around a long time

4. Side effects Modifies some state Has observable interaction with calling functions Has observable interaction with the outside world Example: a function or method with no return value Most functional languages encourage programmers to avoid side effects Haskell (a “pure” functional language) restricts side effects with a static type system Functional programming is safe

5. Language Evolution (Simon Payton-Jones) C#, VB, Java, C are imperative programming languages. Very useful but can change the state of the world at anytime creating side effects. Nirvana! Useful and Safe F# Haskell is Very Safe, but not very useful. Used heavily in research and academia, but rarely in business . http://channel9.msdn.com/posts/Charles/Simon-Peyton-Jones-Towards-a-Programming-Language-Nirvana/

6. Long relegated to academia Industrial and commercial applications Scheme, Erlang, OCaml, Haskell F# at Grange Insurance, Ohio: http://bit.ly/GrangeFSharp F# used by XBox Live Trueskill: http://bit.ly/trueskill DSL’s Mathematica XSLT Excel can be viewed as a functional programming language Functional programming on the rise

7. Functional language developed by Microsoft Research By Don Syme and his team, who productized Generics Based on OCaml (influenced by C# and Haskell) History 2002: F# language design started 2005 January: F# 1.0.1 releases to public Not a product. Integration with VS2003 Works in .NET 1.0 through .NET 2.0 beta, Mono 2005 November: F# 1.1.5 with VS 2005 RTM support 2009 October: VS2010 Beta 2, CTP for VS2008 & Non-Windows users 2010: F# is “productized” and baked into VS 2010 What is F#

8. Interactive Scripting Good for prototyping Succinct = Less code Type Inference Strongly typed, strict Automatic generalization (generics for free) Few type annotations 1st class functions (currying, lazy evaluations) Pattern matching Key Characteristics of F#

9. Multi-Paradigm Functional Programming Imperative Programming Object Oriented Programming Language Oriented Programming Task Oriented Programming F# is not just Functional

10. Dynamically compiles code on the fly Example: Demo F# Interactive open System.Drawing;; open System.Windows.Forms;; let myform = new Form(Text="Hello Everybody", Visible=true);; myform.BackColor <- Color.Blue;; let mybutton = new Button(Text = "Click Me");; myform.Controls.Add(mybutton);; mybutton.BackColor <- Color.White;; mybutton.Click.Add(fun _ -> MessageBox.Show("Clicked") |> ignore);;

11. Type inference Expressions F# Basics let x = 5 let y = 5.0 let files = Directory.GetFiles(@"C:magesriginal") let x = 5 * 5 let y = 5.0 / 3.0 let width = image.Width / 8

12. Function Anonymous functions F# Functions let sqr x = x * x sqr 5 (fun x -> x * x) 5

13. The |> Combinator “Pipe Forward” Example F# Combinators x |> f is the same as f x let sqr x = x * x sqr x 5 |> sqr

14. Partial functions Don’t have to pass all parameters at once Curried Functions letDivideBy y x = x / y let result = DivideBy 2.0 3.0 valDivideBy : float -> float -> float val result : float = 1.5 let HalfOf = DivideBy 2.0 let result2 = HalfOf 3.0 valHalfOf : (float -> float) val result2 : float = 1.5

15. Pass curried function to another function Power of Curried Functions letDivideBy y x = x / y letnumbers = [1.0; 2.0; 3.0] let result3 = List.map (DivideBy 2.0) numbers valDivideBy : float -> float -> float val numbers : float list = [1.0; 2.0; 3.0] val result3 : float list = [0.5; 1.0; 1.5]

16. Compare with VB Function DivideBy(ByVal y As Single, _ ByVal x As Single) As Single Return x / y End Function Sub Main() Dim numbers = New Single() {1.0, 2.0, 3.0} Dim result3 As New List(Of Single) For Each number In numbers result3.Add(DivideBy(2.0, number)) Next End Sub

17. used to group values together without creating a class or struct Tuple Tuple as a function parameter #light open System let swap (x, y) = (y, x) let rotate (x, y, z) = (y, z, x) let circleDetails radius = let area = Math.PI * (radius * radius) let circumference = 2.0 * Math.PI * radius (area, circumference) let result1 = swap(3, 2) let result2 = rotate(5, 6, 7) let details = circleDetails 4.0 let (a, c) = details Tuple as a return value Tuple as left side of an assignment

18. Similar to Object Oriented inheritance Useful in pattern matching Discriminated Unions type Suit = | Spades | Hearts | Clubs | Diamonds let suits = [Spades; Hearts; Clubs; Diamonds]

19. Discriminated Unions cont. type Suit = | Spades | Hearts | Clubs | Diamonds type Card = | Ace of Suit | RankCard of int * Suit | Jack of Suit | Queen of Suit | King of Suit | Joker let card1 = Ace(Diamonds) let card2 = RankCard(3, Spades) let card3 = Joker

20. Used often in F# programs Syntax (source: http://en.wikibooks.org/wiki/F_Sharp_Programming/Pattern_Matching_Basics ) Pattern Matching

21. Mouse event handler in DirectX Demo Checking mouse button and shift key modifiers Pattern Matching Example match b.Button, Form.ModifierKeys with | MouseButtons.Left, Keys.Shift -> view.AdjustZoom(dx,dy) | MouseButtons.Left, _ -> view.AdjustYawPitchRoll(dx,dy) | _ -> view.AdjustFocus(dx,dy)

22. FSharp Samples v0.2 The DirectX Demo More F# Interactive http://code.msdn.microsoft.com/fsharpsamples

23. The Power Wall Manycore FUD Free lunch is over Parallel programming in .NET Where F# fits into this future F# and Impact on the Future

24. The Power Wall: CPU Clock Speed From Katherine Yelick’s “Multicore: Fallout of a Hardware Revolution”

25. Fear, Uncertainty, and Doubt Talbott’s FUD slide: why you should be concerned Moore’s Law Predicted in 1965 that transistor density in semiconductor chips would double every 18 months Clock speed on chips plateaued in 2005 at 3 GHz due to the “Power Wall” Intel and AMD have now begun doubling cores every 18 months to keep up with Moore’s Law AMD Opteron Istanbul and Intel Xeon have 6 cores per socket used in Servers Dell Studio XPS (2009 price of $750) comes with Intel i7 with 4 cores with 2 way hyper-threading (8 virtual cores) Intel Larrabee on the horizon with 32 cores with 4 way hyper-threading (128 virtual cores) FUD

26. Source: Wikipedia entry for Larrabee (GPU) Intel Larrabee

27. Free lunch is over Programs are not doubling in speed every couple of years for free anymore We need to start writing code to take advantage of many cores Currently painful and problematic to take advantage of many cores because of shared memory, locking, and other imperative programming techniques Problem

28. Libraries and Framework Improvements TPL (Included in .NET 4.0) PLINQ Programming Approaches Functional programming Immutable data No side effects Task oriented programming Solution

29. Parallel Programming in the .NET Framework 4 Beta 2

30. “F# is, technically speaking, neutral with respect to concurrency - it allows the programmer to exploit the many different techniques for concurrency and distribution supported by the .NET platform” F# FAQ: http://bit.ly/FSharpFAQ Functional programming is a primary technique for minimizing/isolating mutable state Asynchronous workflows make writing parallel programs in a “natural and compositional style” F# and Multi-Core Programming

31. Problem Resize a ton of images Demo of Image Processor let files = Directory.GetFiles(@"C:magesriginal") for file in files do use image = Image.FromFile(file) use smallImage = ResizeImage(image) let destFileName = DestFileName("s1", file) smallImage.Save(destFileName)

32. Asynchronous Workflows let FetchAsync(file:string) = async { use stream = File.OpenRead(file) let! bytes = stream.AsyncRead(intstream.Length) use memstream = new MemoryStream(bytes.Length) memstream.Write(bytes, 0, bytes.Length) use image = Image.FromStream(memstream) use smallImage = ResizeImage(image) let destFileName = DestFileName("s2", file) smallImage.Save(destFileName) } let tasks = [for file in files -> FetchAsync(file)] let parallelTasks = Async.Parallel tasks Async.RunSynchronouslyparallelTasks

33. Almost 2x on 2 cores About 3.5x faster on 8 cores Demo Asynchronous Workflow

34. Thank you for attending Intro to F#Questions? F# User Group http://fsug.org Twitter: @FSUG Talbott Crowell, ThirdM.com http://talbottc.spaces.live.com Twitter: @Talbott