Upload
talbott-crowell
View
2.640
Download
2
Tags:
Embed Size (px)
DESCRIPTION
Introduction to F# for the New England Visual Basic Professionals User Group.
Citation preview
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
1 2 3 4 5 6 7 8 9 10 110
2
4
6
8
10
12
C#NirvanaHaskellLINQ
Safety
Usefulness
C#, VB, Java LINQ Nirvana
Haskell
Language Evolution (Simon Payton-Jones)
http://channel9.msdn.com/posts/Charles/Simon-Peyton-Jones-Towards-a-Programming-Language-Nirvana/
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 .
F#
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 = 5let y = 5.0 let files = Directory.GetFiles(@"C:\images\original")
let x = 5 * 5let y = 5.0 / 3.0let width = image.Width / 8
Function
Anonymous functions
F# Functions
let sqr x = x * xsqr 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
let DivideBy y x = x / ylet result = DivideBy 2.0 3.0
val DivideBy : float -> float -> floatval result : float = 1.5
let HalfOf = DivideBy 2.0let result2 = HalfOf 3.0
val HalfOf : (float -> float)val result2 : float = 1.5
Pass curried function to another function
Power of Curried Functions
let DivideBy y x = x / ylet numbers = [1.0; 2.0; 3.0]let result3 = List.map (DivideBy 2.0) numbers
val DivideBy : float -> float -> floatval numbers : float list = [1.0; 2.0; 3.0]val result3 : float list = [0.5; 1.0; 1.5]
Compare with VBFunction DivideBy(ByVal y As Single, _
ByVal x As Single) As Single Return x / yEnd 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)) NextEnd Sub
used to group values together without creating a class or struct
Tuple#lightopen 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.0let (a, c) = details
Tuple as a
function
parameter
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# Interactivehttp://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
for file in files do use image = Image.FromFile(file) use smallImage = ResizeImage(image) let destFileName = DestFileName("s1", file) smallImage.Save(destFileName)
let files = Directory.GetFiles(@"C:\images\original")
Asynchronous Workflowslet FetchAsync(file:string) = async { use stream = File.OpenRead(file) let! bytes = stream.AsyncRead(int stream.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 tasksAsync.RunSynchronously parallelTasks
Almost 2x on 2 cores
About 3.5x faster on 8 cores
Demo Asynchronous Workflow
F# User Group
http://fsug.org
Twitter: @FSUG
Talbott Crowell, ThirdM.com
http://talbottc.spaces.live.com
Twitter: @Talbott
Thank you for attending Intro to F#
Questions?