Introduction to F#
Upcoming SlideShare
Loading in...5
×
 

Introduction to F#

on

  • 3,394 views

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

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

Statistics

Views

Total Views
3,394
Views on SlideShare
3,381
Embed Views
13

Actions

Likes
6
Downloads
91
Comments
0

3 Embeds 13

http://www.slideshare.net 10
http://www.linkedin.com 2
https://twitter.com 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Introduction to F# Introduction to F# Presentation Transcript

  • Introduction to F#
    Talbott Crowell
  • 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?
  • 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
  • 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
  • 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/
  • 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
  • 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#
  • 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#
  • Multi-Paradigm
    Functional Programming
    Imperative Programming
    Object Oriented Programming
    Language Oriented Programming
    Task Oriented Programming
    F# is not just Functional
  • 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);;
  • Type inference
    Expressions
    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
  • Function
    Anonymous functions
    F# Functions
    let sqr x = x * x
    sqr 5
    (fun x -> x * x) 5
  • The |> Combinator “Pipe Forward”
    Example
    F# Combinators
    x |> f is the same as f x
    let sqr x = x * x
    sqr x
    5 |> sqr
  • 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
  • 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]
  • 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
  • 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
  • Similar to Object Oriented inheritance
    Useful in pattern matching
    Discriminated Unions
    type Suit =
    | Spades
    | Hearts
    | Clubs
    | Diamonds
    let suits = [Spades; Hearts; Clubs; Diamonds]
  • 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
  • Used often in F# programs
    Syntax (source: http://en.wikibooks.org/wiki/F_Sharp_Programming/Pattern_Matching_Basics )
    Pattern Matching
  • 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)
  • FSharp Samples v0.2
    The DirectX Demo
    More F# Interactive
    http://code.msdn.microsoft.com/fsharpsamples
  • 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
  • The Power Wall: CPU Clock Speed
    From Katherine Yelick’s “Multicore: Fallout of a Hardware Revolution”
  • 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
  • Source: Wikipedia entry for Larrabee (GPU)
    Intel Larrabee
  • 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
  • Libraries and Framework Improvements
    TPL (Included in .NET 4.0)
    PLINQ
    Programming Approaches
    Functional programming
    Immutable data
    No side effects
    Task oriented programming
    Solution
  • Parallel Programming in the .NET Framework 4 Beta 2
  • “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
  • 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)
    smallImage.Save(destFileName)
  • 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
  • Almost 2x on 2 cores
    About 3.5x faster on 8 cores
    Demo Asynchronous Workflow
  • 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