2010.11.19 iniziare con f#

In collaborazione con

Iniziare con F#

» Marco Parenzan

19/11/2010 www.xedotnet.org 2

» 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


» 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

Programmazione Imperativa

http://en.wikipedia.org/wiki/Imperative_programming


» 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

Programmazione Imperativa


» 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

Programmazione Orientata agli Oggetti

http://en.wikipedia.org/wiki/Object-oriented_programming

http://en.wikipedia.org/wiki/Object-oriented_programming

Trends [Source: PDC 2010 – Anders Heijsberg]

Declarative

ConcurrentDynamic

C# and VB Evolution [Source: PDC 2010 – Anders Heijsberg]

Managed Code

Generics

Language Integrated Query

Dynamic + Language Parity

C# + VB v.NextAsynchronous Programming

C# 1.0 + VB 7.0

C# 2.0 + VB 8.0

C# 3.0 + VB 9.0

C# 4.0 + VB 10.0


» 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?

Programmazione Funzionale e .NET

http://tomasp.net/articles/csharp3-concepts.aspx




» 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

Programmazione Dichiarativa

http://en.wikipedia.org/wiki/Declarative_programming


» 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

Programmazione Dichiarativa


» 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)

Domain Specific Languages


» 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

Programmazione Funzionale

http://en.wikipedia.org/wiki/Functional_programming


» 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

Programmazione Funzionale


» È 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 )

Cos’è F#

http://msdn.microsoft.com/en-us/fsharp/default.aspx

http://msdn.microsoft.com/en-us/fsharp/default.aspx

http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/

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]

F# 1.0Functional, Generics (Microsoft Research)

…Visual Studio 2008Interactive, Objects

F# 2.0Visual Studio 2010Asynchronous, Parallel, Units of Measure

Language foundations for strongly typed access to external named data and services

F# 3.0


» 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/

Storia

http://blogs.msdn.com/b/dsyme/

http://en.wikipedia.org/wiki/Don_Syme

http://blogs.msdn.com/b/dsyme/archive/2005/01/05/346857.aspx

http://blogs.msdn.com/b/somasegar/archive/2009/10/09/f-in-vs2010.aspx

http://blogs.msdn.com/b/dsyme/archive/2010/11/04/announcing-the-f-compiler-library-source-code-drop.aspx

http://blogs.msdn.com/b/dsyme/archive/2010/11/04/announcing-the-f-compiler-library-source-code-drop.aspx

http://fsxplat.codeplex.com/


» ...fermo restando che F# è un General Purpose Language• Implementa anche l’approccio imperativo

» Alcuni domini importanti• Financial Modeling• Data Mining• Scientific Analisys• Academic

Applicazioni tipiche per F#

» Shell per lo scripting interattivo• Ottimo per la prototipazione

» Conciso» Type Inference• Strongly Typed• Automatic Generalization (sempre generico, se ha senso)• Poca Type Annotation (attributi)

» First Class Functions• Currying, Lazy Evaluations

» Pattern matching

Caratteristiche di F#


» 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

Scripting 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

L’ambiente interattivo


Elementi di F#



» 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

Shell Interattiva

> 3+4> 3+4;;val it : int = 7

>itval it : int = 7>ItScript.fsx(3,1): error FS0039: The value or constructor 'It' is not defined


» Liste

» Tuple

» Record

» Array

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 = falseval c : float = 3.0val 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|]


» Immutability• Side-effects

» Composition / Currying» Pattern Matching» Type inference» Recursion» Workflows

Concetti Chiave


» 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

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 mutable permette di definire valori mutabili

» a diventa sostanzialmente una variabile

» Motto:• «se proprio serve...»

Valori «mutabili», allora variabili

> let mutable a = 4;;val a : int = 4

> let a = a + 1;;val a : int = 5


» let permette di definire funzioni• Le funzioni sono valori• Le funzioni associano

ad valori in ingresso dei valori in uscita

» Le funzioni sono valori

Funzioni come valori

> let f x = x + 1;;val f : int -> int

> f 5;;val it : int = 6

>


» 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

Pipelining operator

> let incr x = x + 1val incr : int -> int> 10 |> incrval it : int = 11

> let f x y = x*2+y*3val f : int -> int -> int> 10 |> f 20val 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 (+) 0val values : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]val sumOfValues : int = 60


» È 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»

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

http://en.wikipedia.org/wiki/Currying

http://en.wikipedia.org/wiki/Currying


» Reflector supportà già F# (con un suo plug-in, non ancora completo)

F# e Reflector


» 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...

F# e Immutability dal punto di vista di .NET


» let restituisce sempre il pattern della definizione del valore

Pattern


» Anche chiamate «option types»

» Simile all’ereditarietà in OOP• «functional

inheritance»» Anche il tipo diventa

un valore• Simile a una Enum???

Discriminated Unions

>type Veicolo = | Auto| Moto| Camion;;

>let veicolo = Auto;;val veicolo : Veicolo = Auto


» È possibile adornare l’alternativa del tipo con degli attributi

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"


» 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

Pattern Matching

type Nome = stringtype Marca= stringtype Colore = string

type Veicolo = | Auto of Colore| Moto of Marca| Camion of Nome

let veicolo = Auto("rossa")

match veicolo with| Auto(colore) -> printfn "Un' auto %s" colore| Moto(marca) -> printfn "Una moto %s" marca| _ -> printfn "un veicolo qualsiasi"

http://en.wikibooks.org/wiki/F_Sharp_Programming/Pattern_Matching_Basics




type Expr = | Num of int | Add of Expr * Expr | Mul of Expr * Expr | Var of string let rec Evaluate (env:Map<string,int>) exp = match exp with | Num n -> n | Add (x,y) -> Evaluate env x + Evaluate env y | Mul (x,y) -> Evaluate env x * Evaluate env 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

Un esempio evoluto di pattern matching

type Expr = | Num of int | Add of Expr * Expr | Mul of Expr * Expr | Var of stringval Evaluate : Map<string,int> -> Expr -> intval 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


» 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

Discriminated Union, Pattern Matching e Reflector


» 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

Ricorsione

> let rec factorial = function | 0 | 1 -> 1 | n -> n * factorial (n - 1)> factorial 10val it : int = 3628800


» Tail Call Optimization è una caratteristica del compilatore F# (e in alcuni casi anche del JITer .NET) che trasforma una funzione ricorsiva in un ciclo while se la chiamata ricorsiva è l’ultima.

» Questa ottimizzazione risolve il problema dello stack overflow

» Bisogna sempre tentare di pensare ad una funzione affinchè sia “tail optimizable”• Perchè il compilatore (o il JITer) non fanno tutto da solo

» Il TCO è disponibile nel CLR 4.0• Quindi anche in C#!

Tail Recursion


» Il codice che è applicabile a più tipi, viene automaticament generalizzato

» È interessante notare come il codice generato dipenda fortemente da funzioni standard di libreria

Automatic Generalization

>let max a b = if a>b then a else bval max : 'a -> 'a -> 'a when 'a : comparison


» 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...

Computational Workflow

http://en.wikipedia.org/wiki/Aspect-oriented_programming

http://en.wikipedia.org/wiki/Aspect-oriented_programming


let bind value1 function1 = printfn "Bind %A." value1 function1 value1let result value1 = printfn "Returning result: %A" value1 fun () -> value1let 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()

Tracing Workflow

>val bind : 'a -> ('a -> 'b) -> 'bval result : 'a -> (unit -> 'a)val delay : (unit -> 'a) -> unit -> 'atype 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) endval trace : TraceBuilder

Starting traced execution.val trace1 : (unit -> unit -> int)

Bind 7.Bind 5.Bind 12.Returning result: 12val it : (unit -> int) = <fun:result@40>

NASA Mars Climate Orbiter, 1999 [Source: PDC 2010 – Andrew Kennedy]


» È 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

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

Iniziare con F#

ESEMPI, PROGRAMMAZIONE

IMPERATIVA E INTEROPERABILITÀ

CON .NET


Iniziare con F#Conclusioni


Perchè apprendere l’approccio funzionale

» Maggiore controllo del codice• Minimizzare lo stato (mutable)• Organizzare il codice• Applicazione di Pattern• Esalta l’immutabilità dei dati

Vale la pena imparare F#?

» Tutto ciò che si può fare in C# lo si può fare in F# (almeno, al momento, mi pare…)• È multiparadigma (supporta l’approccio imperativo)• Esalta l’immutabilità dei dati e la valutazione di espressioni (sembra tutto LINQ!)• È interoperabile con .NET

» Alcune cose sono più semplici• Applicare i design patterns• Sintassi più succinta• Task asincroni (workflow)• Operazioni di trasformazione• Computazioni• Domain Specific Languages• Aspect Oriented Programming

» Alcune cose sono più 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=bo

oks&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_b

xgy_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

http://www.amazon.com/Beginning-F-Robert-Pickering/dp/1430223898/ref=sr_1_1?ie=UTF8&s=books&qid=1290127128&sr=8-1-spell

http://www.amazon.com/Beginning-F-Robert-Pickering/dp/1430223898/ref=sr_1_1?ie=UTF8&s=books&qid=1290127128&sr=8-1-spell

http://strangelights.com/blog/

http://strangelights.com/blog/

http://www.amazon.com/Expert-2-0-Experts-Voice-Syme/dp/1430224312/ref=pd_sim_b_3



http://www.amazon.com/Programming-comprehensive-writing-complex-problems/dp/0596153643/ref=pd_bxgy_b_img_b

http://www.amazon.com/Programming-comprehensive-writing-complex-problems/dp/0596153643/ref=pd_bxgy_b_img_b

http://blogs.msdn.com/b/chrsmith/

http://blogs.msdn.com/b/chrsmith/

http://www.amazon.com/Real-World-Functional-Programming-Examples/dp/1933988924/ref=pd_bxgy_b_img_b

http://www.amazon.com/Real-World-Functional-Programming-Examples/dp/1933988924/ref=pd_bxgy_b_img_b

http://tomasp.net/

http://tomasp.net/

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



http://blogs.tedneward.com/

http://blogs.tedneward.com/

http://www.amazon.com/gp/reader/1430223898/ref=sib_dp_pt




http://www.amazon.com/gp/product/images/047052801X/ref=dp_image_0?ie=UTF8&n=283155&s=books

blog:

email:

web:

twitter:

slideshare:

Link

21 maggio 2010 www.xedotnet.org 50

»Marco Parenzan

http://blog.codeisvalue.com/

[email protected]

http://www.codeisvalue.com/

marco_parenzan

http://www.slideshare.com/marco.parenzan

2010.11.19 iniziare con f#

Technology

Transcript of 2010.11.19 iniziare con f#