Your SlideShare is downloading. ×
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Introduction to F#
Upcoming SlideShare
Loading in...5

Thanks for flagging this SlideShare!

Oops! An error has occurred.

Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Introduction to F#


Published on

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

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

Published in: Technology
  • Be the first to comment

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

No notes for slide


  • 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
    Haskell is Very Safe, but not very useful. Used heavily in research and academia, but rarely in business .
  • 6. Long relegated to academia
    Industrial and commercial applications
    Scheme, Erlang, OCaml, Haskell
    F# at Grange Insurance, Ohio:
    F# used by XBox Live Trueskill:
    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)
    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
    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");;
    mybutton.BackColor <- Color.White;;
    mybutton.Click.Add(fun _ -> MessageBox.Show("Clicked") |> ignore);;
  • 11. Type inference
    F# Basics
    let x = 5
    let y = 5.0
    let files = Directory.GetFiles(@"C:imagesoriginal")
    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”
    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 = (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))
    End Sub
  • 17. used to group values together without creating a class or struct
    Tuple as a function parameter
    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: )
    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
  • 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)
  • 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
  • 28. Libraries and Framework Improvements
    TPL (Included in .NET 4.0)
    Programming Approaches
    Functional programming
    Immutable data
    No side effects
    Task oriented programming
  • 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:
    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:imagesoriginal")
    for file in files do
    use image = Image.FromFile(file)
    use smallImage = ResizeImage(image)
    let destFileName = DestFileName("s1", file)
  • 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)
    let tasks = [for file in files -> FetchAsync(file)]
    let parallelTasks = Async.Parallel tasks
  • 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
    Twitter: @FSUG
    Talbott Crowell,
    Twitter: @Talbott