• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Introduction to F#
 

Introduction to F#

on

  • 3,258 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,258
Views on SlideShare
3,245
Embed Views
13

Actions

Likes
6
Downloads
88
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