• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content

Loading…

Flash Player 9 (or above) is needed to view presentations.
We have detected that you do not have it on your computer. To install it, go here.

Like this presentation? Why not share!

2010.11.26 F# questo sconosciuto

on

  • 726 views

In Visual Studio 2010 è apparso un nuovo linguaggio: F#. Volete sapere cos'è, da dove nasce e come si scrive in F# ? Ve lo spiegherà il nostro illustre socio Marco Parenzan, che non dimenticherà ...

In Visual Studio 2010 è apparso un nuovo linguaggio: F#. Volete sapere cos'è, da dove nasce e come si scrive in F# ? Ve lo spiegherà il nostro illustre socio Marco Parenzan, che non dimenticherà di illustrarvi perchè in tanti stanno iniziando ad apprezzarlo ancor più del C#... il che è tutto dire!

Statistics

Views

Total Views
726
Views on SlideShare
726
Embed Views
0

Actions

Likes
0
Downloads
8
Comments
0

0 Embeds 0

No embeds

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

    2010.11.26 F# questo sconosciuto 2010.11.26 F# questo sconosciuto Presentation Transcript

    • Iniziare con F#
      Marco Parenzan
    • Non è possibile insegnare a programmare in F# in un’ora
      Si vuole rispondere a due domande:
      Perchè apprendere l’approccio funzionale?
      Vale la pena imparare F#?
      Obiettivi
      19/11/2010
      www.xedotnet.org
      2
    • 19/11/2010
      www.xedotnet.org
      3
      Programmazione Imperativa
      Da Wikipediahttp://en.wikipedia.org/wiki/Imperative_programming
      «...la computazione viene espressa in termini di istruzioni che cambiano lo stato di un programma...»
      Nella programmazione imperativa, noi...
      ...NON diciamo COSA vogliamo....
      ...ma DICIAMO COME fare per ottenere quello che vogliamo
    • 19/11/2010
      www.xedotnet.org
      4
      Programmazione Imperativa
      Nella programmazione imperativa, i concetti principali sono:
      • Lo stato (le variabili)
      • L’assegnazione (delle variabili)
      • La sequenza delle operazioni (che cambiano lo stato delle variabili)
      Pros
      • Approccio «naturale»
      • «The hardware implementation of almost all computers is imperative»
      • Ad un certo punto l’esecuzione va fatta
      • Quando viene insegnato il concetto astratto di algoritmo, viene implicitamente richiesto di essere gli «esecutori»
      Cons
      • La gestione dello stato può essere complicata ed è spesso causa di errori
      • Forse abusiamo delle variabili
      • Sempre di più ora che si parla di parallel e distributed programming
    • 19/11/2010
      www.xedotnet.org
      5
      Programmazione Orientata agli Oggetti
      Da Wikipediahttp://en.wikipedia.org/wiki/Object-oriented_programming
      • «...i dati vengono espressi in termini di strutture contenenti campi e metodi...»
      La programmazione orientata agli oggetti è implicitamente imperativa, in quanto è «stato» assieme ai metodi che permetto di «cambiare questo stato»
      Nel nostro ragionamento, quindi, non ci interessa
      • I concetti di OOP non ci danno niente in più nel confronto Imperativo vs. Funzionale
      • Comunque parleremo di F# e OOP
    • Trends [Source: PDC 2010 – Anders Heijsberg]
    • C# and VB Evolution [Source: PDC 2010 – Anders Heijsberg]
      C# + VB v.Next
      Asynchronous Programming
      C# 4.0 + VB 10.0
      Dynamic + Language Parity
      C# 3.0 + VB 9.0
      Language Integrated Query
      C# 2.0 + VB 8.0
      Generics
      C# 1.0 + VB 7.0
      Managed Code
    • 19/11/2010
      www.xedotnet.org
      8
      Programmazione Funzionale e .NET
      C# 3.0 (rilasciato con .NET Framework 3.5) implementa alcuni aspetti della programmazione funzionale (http://tomasp.net/articles/csharp3-concepts.aspx)
      • Lambda Expression
      • Quando le funzioni possono essere create a runtime, possono essere memorizzate in strutture dati, essere passate come parametri o ritornate come risultati
      • Type Inference (Inferenza di tipo)
      • Dedurre il tipo dall’espressione, non dalla annotazione della variabile (che, in caso di ambiguità, si può ancora usare)
      • Anonymous Types
      • Tipi definiti dall’uso
      • Metaprogramming
      • È lo scrivere programmi che scrivono o manipolano altri programmi (se scrivono o manipolano se stessi, si dice «reflection»)
      • Le Expressions e gli Expression Trees sono i fondamenti del metaprogramming in .NET 3.5/sp1/4.0 (oltre alla Reflection...)
      • In realtà sono: syntactic sugar e librerie
      • Cosa succede se questi concetti entrano nella definizione del linguaggio sin dall’inizio?
    • 19/11/2010
      www.xedotnet.org
      9
      Programmazione Dichiarativa
      Da Wikipediahttp://en.wikipedia.org/wiki/Declarative_programming
      «...esprime la logica della computazione SENZA descrivere il flusso di controllo...»
      Nella programmazione dichiarativa, noi...
      ...DICIAMO COSA vogliamo....
      ...ma NON diciamo come fare per ottenere quello che vogliamo
      È l’esatto complemento della programmazione dichiarativa
    • 19/11/2010
      www.xedotnet.org
      10
      Programmazione Dichiarativa
      Nella programmazione dichiarativa, i concetti principali sono:
      • Le proprietà (esplicitare dei valori)
      • I vincoli (esplicitare le regole cui devono sottostare valori non esplicitati)
      Pros
      • Migliore astrazione
      • Non devo pensare alla gestione dello stato
      Cons
      • Approccio (forse) non «naturale» (?!?!?!)
      • Lo usiamo, ma non sappiamo che lo stiamo facendo
    • 19/11/2010
      www.xedotnet.org
      11
      Domain Specific Languages
      Tra i linguaggi «dichiarativi» (cioè quelli che implementano un paradigma di programmazione «dichiarativo») troviamo i Domain Specific Languages
      Ne usiamo ogni giorno
      • HTML
      • Descriviamo cosa vogliamo vedere
      • Non descriviamo COME faremo a rappresentarlo (non disegnamo linee, lettere, colori)
      • SQL
      • Nella selezione (SELECT) descriviamo i vincoli sui dati che vogliamo ottenere,
      • Non descriviamo COME estrarre i dati da un database (generazione dell’execution plan)
    • 19/11/2010
      www.xedotnet.org
      12
      Programmazione Funzionale
      Da Wikipediahttp://en.wikipedia.org/wiki/Functional_programming
      • «...la computazione viene espressa in termini di funzioni ed evita l’uso di stato e dati mutabili...»
      Nella programmazione funzionale...
      • Le funzioni sono First-Class Types (High Order Functions)
      • Inferenza dei tipi
      • Immutabilità
      • La scelta di essere «mutabile» (ed essere a rischio di «side effectes», è esplicita)
      • Evita l’uso di stato per evitare insidiosi «side-effects»
      • Specie in concurrent programming
      • Enfatizza la forma dei dati, non l’implementazione
      • Uso di dati polimorfici e di pattern matching
      • Modellato sul lambda calcolo
      • Expression Oriented
      • Promuove la «lazy evaluation»
      • Valutazione «pigra», il più tardi possibile (non «eager», «impaziente», «anticipato»)
      • Riduce l’enfasi sull’approccio imperativo
      • Preferisce la ricorsione all’iterazione
      • Innalza il livello di astrazione
    • 19/11/2010
      www.xedotnet.org
      13
      Programmazione Funzionale
      Nella programmazione funzionale, i concetti principali sono:
      • I valori e la loro immutabilità
      • Non ci sono variabili
      • Il lambda calcolo
      Pros
      • Migliore astrazione
      • «... l'aumento delle prestazioni dei calcolatori ha tuttavia spostato l'attenzione della comunità informatica sullo sviluppo rapido del software, sulla sua correttezza e manutenibilità...»
      Cons
      • Approccio (forse) non «naturale» (?!?!?!)
      • Lo usiamo, ma non sappiamo che lo stiamo facendo
    • 19/11/2010
      www.xedotnet.org
      14
      Cos’è F#
      È un linguaggio funzionale
      • Deriva la sua sintassi dal linguaggio Ocaml
      • È il suo obiettivo principale
      È un linguaggio imperativo
      • Se non si può fare altrimenti
      È un linguaggio OOP
      • Perchè deve essere interoperabile con .NET
      Links
      • http://msdn.microsoft.com/en-us/fsharp/default.aspx
      • http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/
      • http://en.wikipedia.org/wiki/F_Sharp_(programming_language)
    • F# Evolution [Source: PDC 2010 – Don Syme]
      Language foundations for strongly typed access to external named data and services
      F# 3.0
      F# 2.0
      Visual Studio 2010
      Asynchronous, Parallel, Units of Measure

      Visual Studio 2008
      Interactive, Objects
      F# 1.0
      Functional, Generics (Microsoft Research)
    • 19/11/2010
      www.xedotnet.org
      16
      Storia
      Iniziato nel 2002 in Microsoft Research ad opera principalmente di Don Syme
      http://blogs.msdn.com/b/dsyme/
      http://en.wikipedia.org/wiki/Don_Syme
      A Don si deve anche l’implementazione dei generics nel CLR 2.0 (usati poi pesantemente in F#)
      A inizio 2005 viene rilasciata la prima release pubblica di F#
      http://blogs.msdn.com/b/dsyme/archive/2005/01/05/346857.aspx
      Nel 2009 Somasegar annuncia l’inclusione di F# (2.0) in Visual Studio 2010
      http://blogs.msdn.com/b/somasegar/archive/2009/10/09/f-in-vs2010.aspx
      Il 4 novembre 2010 il source code di F# viene rilasciato come Open Source
      http://blogs.msdn.com/b/dsyme/archive/2010/11/04/announcing-the-f-compiler-library-source-code-drop.aspx
      Si può anche installare sotto Linux e Mac OSX con MONO
      http://fsxplat.codeplex.com/
    • 19/11/2010
      www.xedotnet.org
      17
      Applicazioni tipiche per F#
      ...fermo restando che F# è un General Purpose Language
      Implementa anche l’approccio imperativo
      Alcuni domini importanti
      Financial Modeling
      Data Mining
      Scientific Analisys
      Academic
    • Shell per lo scripting interattivo
      • Ottimo per la prototipazione
      Conciso
      Type Inference
      • Strongly Typed
      • Automatic Generalization (sempregenerico, se ha senso)
      • Poca Type Annotation (attributi)
      First Class Functions
      • Currying, Lazy Evaluations
      Pattern matching
      Caratteristiche di F#
    • 19/11/2010
      www.xedotnet.org
      19
      Scripting Interattivo
      Utilizzato in ambito amministrativo, matematico o Dynamic Languages
      • Cmd, PowerShell, Mathematica, (Iron)Python, (Iron)Ruby
      L’utente inserisce i comandi uno alla volta, eseguendoli
      • Normalmente, i linguaggi di scripting sono interpretati
      • F# è compilato
      Uno scripting è di successo quanto più semplice è scrivere il codice
      • In F# è possibile avere la verifica (statica) dei tipi
    • 19/11/2010
      www.xedotnet.org
      20
      L’ambiente interattivo
      Da riga di comando, digitare fsi.exe
      Da Visual Studio 2010, due opzioni
      CTRL+ALT+F per una console F# interactive
      Creare un progetto F#, inserire un file .fsx ed eseguire «selezioni» di codice con ALT+INVIO
    • Elementi di F#
      19/11/2010
      www.xedotnet.org
      21
    • 19/11/2010
      www.xedotnet.org
      22
      Shell Interattiva
      > 3+4
      > 3+4;;
      val it : int = 7
      >it
      val it : int = 7
      >It
      Script.fsx(3,1): error FS0039: The value or constructor 'It' is not defined
      Shell interattiva
      In una shell interattiva, i comandi vengono terminati con il doppio carattere ;;
      it è l’ultimo valore calcolato
      It non è it
      • F# è Case Sensitive
    • 19/11/2010
      www.xedotnet.org
      23
      Tipi di dati
      >let lista = [1..10];;val lista : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
      >let tupla = (1, "due", 3.0, false);;
      val tupla : int * string * float * bool = (1, "due", 3.0, false)
      >let a,b,c,d = tupla;;
      val d : bool = false
      val c : float = 3.0
      val b : string = "due"
      val a : int = 1
      >type Person = { Name: string; Surname: string; };;type Person =
      {Name: string;
      Surname: string;}
      >let p = { Name="Mario"; Surname="Rossi" };;val p : Person = {Name = "Mario";
      Surname = "Rossi";}
      >let values = [|10; 20; 30|val values : int [] = [|10; 20; 30|]
      Liste
      Tuple
      Record
      Array
    • 19/11/2010
      www.xedotnet.org
      24
      Concetti Chiave
      Immutability
      Side-effects
      Composition / Currying
      Pattern Matching
      Type inference
      Recursion
      Workflows
    • 19/11/2010
      www.xedotnet.org
      25
      Valori, non variabili
      > let a = 4;;val a : int = 4
      > let a = 5;;
      Script.fsx(5,5): error FS0037: Duplicate definition of value 'a'
      let permette di definire valori
      • F# applica sempre la Type Inference (a : int)
      • Simile a var in C#...
      • ...ma il feeling è quello dello scripting...
      a è un valore, non una variabile
      • a è immutabile
    • 19/11/2010
      www.xedotnet.org
      26
      Valori «mutabili», allora variabili
      > let mutable a = 4;;val a : int = 4
      > let a = a + 1;;
      val a : int = 5
      let mutable permette di definire valori mutabili
      a diventa sostanzialmente una variabile
      Motto:
      «se proprio serve...»
    • 19/11/2010
      www.xedotnet.org
      27
      Funzioni come valori
      > let f x = x + 1;;val f : int -> int
      > f 5;;
      val it : int = 6
      >
      let permette di definire funzioni
      Le funzioni sono valori
      Le funzioni associano ad valori in ingresso dei valori in uscita
      Le funzioni sono valori
    • 19/11/2010
      www.xedotnet.org
      28
      Pipelining operator
      > let incr x = x + 1val incr : int -> int
      > 10 |> incrval it : int = 11
      >let f x y = x*2+y*3
      val f : int -> int -> int
      > 10 |> f 20
      val it : int = 70
      >let values = [1..10]
      let sumOfValues = values |> List.filter (fun x -> (x % 2 = 0))
      |> List.map (fun x -> x*2)
      |> List.fold (+) 0
      val values : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
      val sumOfValues : int = 60
      f x si può anche scrivere come x |> f
      In caso di due parametri, il parametro in pipelining è quello più a destra
      • y |> f x
      • È ottimo quando si usano applicazioni in sequenza
    • 19/11/2010
      www.xedotnet.org
      29
      Composition
      >let f x y = x + y
      >let incr x = f x 1
      >incr 5
      val f : int -> int -> intval incr : int -> intval it : int = 6
      È possibile valorizzare parzialmente i parametri di una funzione componendo un nuovo valore (partial function application)
      Infatti notiamo che dopo una let viene sempre mostrato il formato del valore
      Il meccanismo si chiama «currying»http://en.wikipedia.org/wiki/Currying
      • È una tecnica che permette di trasformare una funzione di n parametri in una «catena di funzioni di un solo parametro»
    • 19/11/2010
      www.xedotnet.org
      30
      F# e Reflector
      Reflector supportà già F# (con un suo plug-in, non ancora completo)
    • 19/11/2010
      www.xedotnet.org
      31
      F# e Immutability dal punto di vista di .NET
      Cosa genera questo programma in F#? (che non significa niente...)
      let a = 4let mutable b = a + 5let f x = x + alet g = f b
      Se si usa Reflector...
    • 19/11/2010
      www.xedotnet.org
      32
      Pattern
      let restituisce sempre il pattern della definizione del valore
    • 19/11/2010
      www.xedotnet.org
      33
      Discriminated Unions
      >type Veicolo = | Auto| Moto| Camion
      ;;
      >let veicolo = Auto;;
      val veicolo : Veicolo = Auto
      Anche chiamate «option types»
      Simile all’ereditarietà in OOP
      «functional inheritance»
      Anche il tipo diventa un valore
      Simile a una Enum???
    • 19/11/2010
      www.xedotnet.org
      34
      Discriminated Union
      >type Nome = string>type Marca= string>type Colore = string>type Veicolo = | Auto of Colore| Moto of Marca| Camion of Nome>let veicolo = Auto("rossa")val veicolo : Veicolo = Auto "rossa"
      È possibile adornare l’alternativa del tipo con degli attributi
    • 19/11/2010
      www.xedotnet.org
      35
      Pattern Matching
      type Nome = stringtype Marca= stringtype Colore = stringtype Veicolo = | Auto of Colore| Moto of Marca| Camion of Nomelet veicolo = Auto("rossa")match veicolo with| Auto(colore) -> printfn "Un' auto %s" colore| Moto(marca) -> printfn "Una moto %s" marca| _ -> printfn "un veicolo qualsiasi"
      La «sequenza» di informazioni di tipo e di attributi può essere usata per «discriminare» il tipo
      La sequenza di tipo e di attributi è un «pattern»
      È uno dei meccanismi fondamentali di F#
      • http://en.wikibooks.org/wiki/F_Sharp_Programming/Pattern_Matching_Basics
    • 19/11/2010
      www.xedotnet.org
      36
      Un esempio evoluto di pattern matching
      type Expr =
      | Num of int
      | Add of Expr * Expr
      | Mul of Expr * Expr
      | Var of string
      val Evaluate : Map<string,int> -> Expr -> int
      val envA : Map<string,int> = map [("a", 1); ("b", 2); ("c", 3)]
      val expT1 : Expr = Add (Var "a",Mul (Num 2,Var "b"))
      val resT1 : int = 5
      type Expr =
      | Num of int
      | Add of Expr * Expr
      | Mul of Expr * Expr
      | Var of string
      letrec Evaluate (env:Map<string,int>) exp =
      match exp with
      | Num n -> n
      | Add (x,y) ->Evaluateenv x + Evaluateenv y
      | Mul (x,y) ->Evaluateenv x * Evaluateenv y
      | Var id -> env.[id]
      let envA = Map.ofList [ "a",1 ;
      "b",2 ;
      "c",3 ]
      let expT1 = Add(Var "a",Mul(Num 2,Var "b"))
      let resT1 = Evaluate envA expT1
    • 19/11/2010
      www.xedotnet.org
      37
      Discriminated Union, Pattern Matching e Reflector
      Osservare cosa F# ha generato a fronte del codice scritto prima, descrive molto bene il concetto di «declarative programming» detto all’inizio
      Classi già implementate (e spesso lo si faceva a mano)
      Uso estensivo di:
      • IEquatable
      • IStructuralEquatable
      • IComparable
      Sono i concetti trovati negli «anonymous types» in C# 3.0
      In C# lo si poteva fare, ma non siamo mai stati realmente abituati a farlo
    • 19/11/2010
      www.xedotnet.org
      38
      Ricorsione
      > let rec factorial = function    | 0 | 1 -> 1    | n -> n * factorial (n - 1)> factorial 10
      val it : int = 3628800
      Una funziona viene dichiarata ricorsiva con la parola chiave rec
      È l’equivalente funzionale dell’iterazione
      Si ha spesso paura di usare le funzioni ricorsive per le prestazioni e il «consumo» dello stack
    • 19/11/2010
      www.xedotnet.org
      39
      Tail Recursion
      Tail Call Optimization è unacaratteristica del compilatoreF# (e in alcunicasianche del JITer .NET) chetrasformaunafunzionericorsiva in un ciclo while se la chiamataricorsiva è l’ultima.
      Questa ottimizzazionerisolveilproblemadello stack overflow
      Bisognasempretentare di pensare ad unafunzioneaffinchèsia “tail optimizable”
      • Perchèilcompilatore (o ilJITer) non fannotutto da solo
      Il TCO è disponibilenel CLR 4.0
      • Quindianche in C#!
    • 19/11/2010
      www.xedotnet.org
      40
      Automatic Generalization
      >let max a b = if a>b then a else bval max : 'a -> 'a -> 'a when 'a : comparison
      Il codice che è applicabile a più tipi, viene automaticament generalizzato
      È interessante notare come il codice generato dipenda fortemente da funzioni standard di libreria
    • 19/11/2010
      www.xedotnet.org
      41
      Computational Workflow
      Sono un concetto complicato
      Permette di definire un DSL
      • F# mette a disposizione delle parole chiave, integrate nel linguaggio (let, let!, use, use!, do, do!, for, while if, yield, yield!, return, return!)
      • «Mappa» queste parole chiave sui metodi di una classe «builder» (Let, Bind, Using, For, While, if, Combine, Yield, YieldFrom, Return, ReturnFrom)
      • Questi metodi possono essere implementati da un programma
      • Quindi un «workflow» scritto con quelle parole chiave viene eseguito come sequenza di metodi dell’oggetto builder, di cui noi abbiamo pienamente il controllo
      È un approccio AOP (Aspect Oriented Programming)http://en.wikipedia.org/wiki/Aspect-oriented_programming
      • I metodi (Let, Bind, ....) «osservano» l’esecuzione del programma e agiscono in background
      • Ad esempio per un logging...
    • 19/11/2010
      www.xedotnet.org
      42
      Tracing Workflow
      >val bind : 'a -> ('a -> 'b) -> 'b
      val result : 'a -> (unit -> 'a)
      val delay : (unit -> 'a) -> unit -> 'a
      type TraceBuilder =
      class
      new : unit -> TraceBuilder
      member Bind : value1:'c * function1:('c -> 'd) -> 'd
      member Delay : function1:(unit -> 'a) -> (unit -> 'a)
      member Return : value1:'b -> (unit -> 'b)
      end
      val trace : TraceBuilder
      Starting traced execution.
      val trace1 : (unit -> unit -> int)
      Bind 7.
      Bind 5.
      Bind 12.
      Returning result: 12
      val it : (unit -> int) = <fun:result@40>
      let bind value1 function1 =
      printfn "Bind %A." value1
      function1 value1
      let result value1 =
      printfn "Returning result: %A" value1
      fun () -> value1
      let delay function1 =
      fun () -> function1()
      type TraceBuilder() =
      member x.Bind(value1, function1) =
      bind value1 function1
      member x.Return(value1) = result value1
      member x.Delay(function1) =
      printfn "Starting traced execution."
      delay function1
      let trace = new TraceBuilder()
      let trace1 = trace {
      let! x = 7
      let! y = 5
      let! sum = x + y
      return sum
      }
      trace1()
    • NASA Mars Climate Orbiter, 1999 [Source: PDC 2010 – Andrew Kennedy]
    • 19/11/2010
      www.xedotnet.org
      44
      Unità di Misura
      >[<Measure>]type m;;[<Measure>]
      type m
      >[<Measure>]type s;;[<Measure>]
      type s
      >let space = 10.0<m>;;
      val space : float<m> = 10.0
      >let time = 2.0<s>;;val time : float<s> = 2.0
      >let speed = space/time;;val speed : float<m/s> = 5.0
      >let acc = space/time/time;;val acc : float<m/s ^ 2> = 2.5
      È un estensione al Type system extension
      Non è invasivo
      • È un meccanismo di annotazione basato sul processo di inferenza
      Non ha costo a runtime
      Attenzione!
      • È una prima versione
      • Ci sono diverse cose da fare
      • Ma è già un gran bel lavoro
    • Iniziare con F#
      Esempi, Programmazione Imperativa e Interoperabilità con .NET
    • Iniziare con F#
      Conclusioni
      17/01/2008
      www.xedotnet.org
      46
    • Perchè apprendere l’approccio funzionale
      Maggiore controllo del codice
      Minimizzare lo stato (mutable)
      Organizzare il codice
      Applicazione di Pattern
      Esaltal’immutabilitàdeidati
    • Vale la pena imparare F#?
      Tuttociòchesipuò fare in C# lo sipuò fare in F# (almeno, al momento, mi pare…)
      È multiparadigma (supportal’approccioimperativo)
      Esaltal’immutabilitàdeidati e la valutazione di espressioni (sembratutto LINQ!)
      È interoperabile con .NET
      Alcunecosesonopiùsemplici
      Applicare i design patterns
      Sintassipiùsuccinta
      Task asincroni (workflow)
      Operazioni di trasformazione
      Computazioni
      Domain Specific Languages
      Aspect Oriented Programming
      Alcunecosesonopiù complicate
      GUI programming
      C’ègià un sacco di codice F# in Internet da riusare
    • Libri & Blog
      Beginning F#
      • Robert Pickering - APress
      • http://www.amazon.com/Beginning-F-Robert-Pickering/dp/1430223898/ref=sr_1_1?ie=UTF8&s=books&qid=1290127128&sr=8-1-spell
      • Blog: http://strangelights.com/blog/
      Expert F# 2.0
      • Don Syme, Adam Granicz, Antonio Cisternino - APress
      • http://www.amazon.com/Expert-2-0-Experts-Voice-Syme/dp/1430224312/ref=pd_sim_b_3
      • Blog: http://blogs.msdn.com/b/dsyme/
      Programming F#
      • Chris Smith - O’Reilly
      • http://www.amazon.com/Programming-comprehensive-writing-complex-problems/dp/0596153643/ref=pd_bxgy_b_img_b
      • Blog: http://blogs.msdn.com/b/chrsmith/
      Real World Functional Programming: With Examples in F# and C#
      • Tomas Petricek – Manning
      • http://www.amazon.com/Real-World-Functional-Programming-Examples/dp/1933988924/ref=pd_bxgy_b_img_b
      • Blog: http://tomasp.net/
      Professional F#
      • Ted Neward, Aaron Erickson, Talbott Crowll, Rick Minerich – Wrox
      • http://www.amazon.com/Professional-F-2-0-Ted-Neward/dp/047052801X/ref=sr_1_1?ie=UTF8&s=books&qid=1290127457&sr=1-1
      • Blog: http://blogs.tedneward.com/
      19/11/2010
      www.xedotnet.org
      49
    • Link
      21 maggio 2010
      www.xedotnet.org
      50
      Marco Parenzan
      http://blog.codeisvalue.com/
      marco.parenzan@libero.it
      http://www.codeisvalue.com/
      marco_parenzan
      http://www.slideshare.com/marco.parenzan