Archivio dell'autore: Mario De Ghetto

Console application in F#: first time

Dopo circa un mese (troppo tempo!) sono riuscito a trovare il tempo necessario per scrivere l’articolo anticipato nel post precedente.
L’obbiettivo è semplice: creare un piccolo progetto console nel linguaggio F# e scoprire insieme le potenzialità che offre.

Aprendo Visual Studio 2013 ho creato un progetto “Console Application” nel linguaggio F# e subito ho notato due dettagli che meritano la nostra riflessione:

  • La versione del framework 4.5.1, ottenuta direttamente durante l’installazione di VS 2013, aggiunge diverse novità al linguaggio F# (rispetto a VB.NET e C#), tanto da meritarsi una nuova versione F# 3.1.
    Di conseguenza, se entriamo nelle proprietà del progetto, la schermata ci permette di scegliere quale runtime del linguaggio possiamo utilizzare per sviluppare la nostra applicazione.
  • Inoltre visual studio ci offre la possibilità di creare un tipo di progetto a se stante, denominato Tutorial, contenente un file ricco di esempi e di oggetti in codice F# utili per capire e soprattutto memorizzare la sintassi di questo linguaggio.

Tornando al nostro progetto, troveremo il “solito file program” che al suo interno racchiude l’entrypoint della nostra applicazione. Per chi non lo sapesse è il metodo eseguito per primo durante l’esecuzione del progetto e in F# la funzione di ingresso viene identificata con l’attributo [<EntryPoint>].
Nel nostro esempio faremo a meno di identificare l’entrypoint eseguendo il codice proceduralmente, in ordine di scrittura.

Esempio…

using System;
class Program
{
    static void Main(string[] args)
    {
         Console.WriteLine("Il risultato è: {0}",
CalcolaFattoriale(Convert.ToInt32(Console.ReadLine()))); Console.ReadLine(); } private static int CalcolaFattoriale(int _numero) { if (_numero > 0) return _numero * CalcolaFattoriale(_numero - 1); else return 1; } }

Come punto di partenza ho preso questo semplice codice C# che, sostanzialmente, dato un numero, ne calcola il fattoriale e restituisce il risultato. Naturalmente ci sono diversi modi per scrivere questa funzione e allo stesso modo la ricorsività del metodo di calcolo è utile esclusivamente a scopo dimostrativo. Inoltre, sempre per lo stesso motivo, ho cercato di tenere gli esempi più simili possibile, per evidenziare le vere differenze tra i due linguaggi.

Passiamo ora allo stesso codice scritto all’interno del nostro progetto F#

open System;

printf("Inserisci numero per calcolo fattoriale: ")

let _numero = Convert.ToInt32(Console.ReadLine())

let rec CalcoloFattoriale _numero =
    if _numero > 0 then _numero * CalcoloFattoriale (_numero-1) else 1

let res = CalcoloFattoriale _numero
printfn "Il risultato è: %A" res

let fine = Console.ReadLine()

Analizziamo ora, riga per riga questo codice.

  1. Nella prima semplicemente viene richiamato il namespace “System” come per il linguaggio C# o VB.NET rispettivamente attraverso “using” e “import”.
  2. Nella seconda inviamo alla console la stringa di testo, ma questa funzione è già stata introdotta nei primi post del blog da Mario de Ghetto.
  3. Nella terza eseguiamo un operazione di assegnazione di un valore. In verità però è molto interessante. Infatti possiamo notare quanto sia semplice far interagire oggetti di natura OOP del framework nei costrutti di F# di natura funzionale. Questo è possibile grazie alla interoperabilità intrinseca del Framework.
  4. Nella quarta riga invece avviene il cambiamento più radicale rispetto all’esempio C#. Con la parola chiave “rec”, preceduta da “let”, dichiariamo una funzione ricorsiva, ovvero in grado di richiamare se stessa. Questo permette di eseguire “calcoli ciclici” al proprio interno, restituendo ciò che ci interessa una volta soddisfatta la condizione.
    Da notare, come la possibilità di utilizzare funzioni ricorsive rende facile e veloce (in alcuni casi) la scrittura di codice rispetto che dichiarare una nuova funzione o utilizzare dei cicli for usati nella programmazione ad oggetti.
  5. Nelle ultime righe, viene chiamata la funziona ricorsiva, successivamente viene scritto il risultato nella console e infine con l’ultima si chiede alla console di aspettare l’input dell’utente prima di terminare l’esecuzione e chiudersi prematuramente.

Per concludere possiamo notare quanto sia immediato e di veloce scrittura utilizzare F# una volta afferrati i concetti base della programmazione funzionale.
Inoltre ho fatto un piccolo test, puramente indicativo, utilizzando la classe Stopwatch del namespace System.Diagnostic sulla funzione ricorsiva di F# e sulla chiamata ricorsiva di C# e, come mi aspettavo, è risultata molto più performante quella funzionale.
In questo esempio è comunque poco indicativo, infatti utilizzando dei cicli while o for nel codice C# si otterrebbero dei risultati migliori.

Nel prossimo post vorrei approfondire meglio con qualche esempio più complesso quando è effettivamente utile integrare nelle nostre applicazioni codice funzionale o meno. Vedere quando esso porti un netto miglioramento nelle prestazioni o nell’immediatezza e facilità di scrittura delle nostre applicazioni.

Un saluto, a presto
Michael

if … then … elif … else

Uno dei costrutti più facili da capire in F# è il costrutto if … then, anche perché è estremamente simile all’istruzione If … Then di Visual Basic.

La forma più semplice è quella che potete vedere in questo frammento di codice:

System.Console.Write("Inserisci la tua età: ")
let eta = System.Console.ReadLine()
let numero = int eta
if numero < 18 then
   System.Console.WriteLine("Sei minorenne!")
else
   System.Console.WriteLine("Sei maggiorenne")

System.Console.ReadLine() |> ignore

    Il funzionamento è il seguente:

  1. nella prima riga viene mostrata una stringa che rappresenta il “prompt”, cioè la richiesta all’utente;

  2. nella seconda riga leggiamo una stringa di input dall’utente e la associamo all’identificatore “eta”;

  3. nella terza riga effettuiamo una conversione della stringa in intero (int) e associamo il risultato all’identificatore numero;

  4. nella quarta riga inizia il costrutto “if … then” con il test sul numero inserito. Il test verifica se l’età è inferiore a 18. Notare che il test fornisce un risultato che è un booleano (vero o falso);

  5. la quinta riga viene eseguita se l’età è inferiore a 18 e quindi visualizza la stringa “Sei minorenne!”;

  6. nella sesta riga troviamo la parola “else” che indica un ramo alternativo del costrutto “if … then” che viene percorso se il test è falso;

  7. nella settima riga viene visualizzata la stringa “Sei maggiorenne”;

  8. infine, nell’ultima riga, attendiamo la pressione di un tasto per chiudere la finestra della Console (altrimenti non vedremmo il risultato del programma). Notare l’operatore di “pipe” |> che invia il risultato della funzione a “ignore”, per ignorarlo ed evitare segnalazioni di errore da parte del compilatore.

    1. Una possibile variante del costrutto “if … then” prevede l’aggiunta di ulteriori “rami” di scelta, con la parola “elif” (che in Visual Basic si leggerebbe Else If).

      System.Console.Write("Inserisci la tua età: ")
      let eta = System.Console.ReadLine()
      let numero = int eta
      if numero < 18 then
         System.Console.WriteLine("Sei minorenne!")
      elif numero > 64 then
         System.Console.WriteLine("Sei anziano")
      else
         System.Console.WriteLine("Sei maggiorenne")
      
      System.Console.ReadLine() |> ignore

      Come potete vedere abbiamo aggiunto il ramo “elif” che verifica se l’età è superiore a 64 e, in tal caso, visualizza la stringa “Sei anziano” (il termine “anziano” viene comunemente utilizzato per definire le persone da 65 anni in su, mentre “grande anziano” è la persona con un’età uguale o superiore a 75 anni).

      Esploriamo anche la possibilità di aggiungere un numero indefinito di “elif”:

      System.Console.Write("Inserisci la tua età: ")
      let eta = System.Console.ReadLine()
      let numero = int eta
      if numero < 18 then
         System.Console.WriteLine("Sei minorenne!")
      elif numero > 74 then
         System.Console.WriteLine("Sei un 'grande anziano'")
      elif numero > 64 then
         System.Console.WriteLine("Sei anziano")
      else
         System.Console.WriteLine("Sei maggiorenne")
      
      System.Console.ReadLine() |> ignore

      Una cosa che si può fare in F#, diversamente da Visual Basic e da C#, è utilizzare il costrutto “if … then” come funzione, all’interno di un’istruzione di assegnazione. Ecco un esempio:

      System.Console.Write("Inserisci la tua età: ")
      let eta = System.Console.ReadLine()
      let numero = int eta
      let risposta = 
          if numero < 18 then
             "Sei minorenne!"
          elif numero > 74 then
             "Sei un 'grande anziano'"
          elif numero > 64 then
             "Sei anziano"
          else
             "Sei maggiorenne"
      System.Console.WriteLine(risposta)
      System.Console.ReadLine() |> ignore

      Come potete vedere, nella quarta riga abbiamo definito l’identificatore “risposta” e gli abbiamo assegnato il risultato del costrutto “if … then”. Inoltre, nei vari rami di questo costrutto abbiamo inserito solamente la stringa da restituire e che sarà il valore che verrà assegnato all’identificatore “risposta”. Subito dopo abbiamo inserito un’istruzione per scrivere il risultato nella Console.

      Articolo di presentazione di Michael Ciceri

      Con questo articolo dò il benvenuto a Michael Ciceri che ha aderito al mio progetto di studio e di divulgazione del linguaggio F#. Lascio subito a lui la parola!

      Salve a tutti,

      Prima di iniziare a discutere con voi delle mie prime impressioni su questo fantastico linguaggio, F#, vorrei ringraziare Mario de Ghetto per avermi dato la possibilità di pubblicare questo post nel suo blog.

      Mi presento. Mi chiamo Michael Ciceri. Per chi non mi conoscesse sono un appassionato di tutto ciò che riguarda l’informatica, in particolare del “.Net World” e di conseguenza di tutte le sue implicazioni, e
      svolgo l’attività di analista programmatore come consulente.

      Finalmente, dopo molte peripezie, ho trovato il tempo di intraprendere la conoscenza di questo linguaggio funzionale che fin dai suoi esordi mi ha sempre suscitato enorme interesse, per una serie di motivi e caratteristiche fulcro di questo mio primo post.

      Pensare di avere la possibilità di coniugare programmazione ad oggetti e programmazione funzionale è stato il primo vero interesse che mi ha motivato a provare questo linguaggio. Come accade per C# e VB.Net è possibile utilizzare F# e integrarlo perfettamente nelle nostre applicazioni e viceversa, in vero stile .Net, ovvero senza sforzi.

      Questo porta direttamente al secondo punto a suo favore: la programmazione funzionale offre caratteristiche diverse che permettono di estendere e migliorare le nostre applicazioni utilizzando però una architettura o semplicemente un metodo diverso per costruire il nostro “core”.
      In parole povere, ci sono funzioni o porzioni della struttura dell’applicazione che, scritte in F# e quindi pensate in ambito funzionale, hanno molto più senso.

      Questo mi porta a vedere F# come un’estensione del mondo .Net ad oggetti, migliorandone appunto il suo utilizzo. Infatti negli ultimi anni ci siamo già abituati ad utilizzare concetti funzionali. Basta pensare a LINQ e alle Lambda expression. Tuttavia, ciò non toglie il fatto che come ogni altro linguaggio o tipo di programmazione, sia possibile programmare interamente in F# in molti, se non tutti gli ambiti con i pro e contro del caso.

      Dopo queste macro riflessioni, che pur essendo interessanti rimangono comunque teoriche, è fondamentale provare ad utilizzare F#.
      Mario de Ghetto con i suoi post sta già facendo un gran bel lavoro certosino, completo e semplice.
      Nel prossimo topic cercherò di puntare, con qualche esempio, a concetti un po’ diversi con un approccio differente. Partiremo con la creazione di un progetto console in F# e vedremo insieme come sviluppare una semplice funzione con lo scopo preciso di scoprire le caratteristiche del linguaggio stesso.

      Un saluto, Michael

      Visual Studio 2015

      20 luglio 2015: ancora una volta Microsoft arriva all’appuntamento puntuale, con l’atteso rilascio di Visual Studio 2015 per gli abbonati MSDN e, in versione di prova, per chi non è abbonato (https://www.visualstudio.com/downloads).

      image

      Nella pagina di download potete trovare anche la versione Visual Studio Community, una particolare versione che include tutti i template delle varie versioni di Visual Studio Express, in modo che possiate avere tutto in un unico prodotto, come nel caso di Visual Studio “full”. Ovviamente questa è una versione che ha alcune limitazioni, in particolare non può essere utilizzata in organizzazioni che non abbiano una piccola dimensione. Nelle organizzazioni medio-grandi è opportuno utilizzare Visual Studio “full”, soprattutto se lavorate in team di sviluppo abbastanza strutturati e “corposi”.

      Ecco un po’ di documentazione, per capire quali sono le novità…

      Annuncio ufficiale nel blog di Somasegar

      http://blogs.msdn.com/b/somasegar/archive/2015/07/20/visual-studio-2015-and-net-4-6-available-for-download.aspx

      Channel 9 – Visual Studio 2015 Final Release Event

      https://channel9.msdn.com/Events/Visual-Studio/Visual-Studio-2015-Final-Release-Event

      Channel 9 – oltre 60 video on-demand sulle caratteristiche

      http://blogs.msdn.com/b/somasegar/archive/2015/07/20/visual-studio-2015-and-net-4-6-available-for-download.aspx

      image

      ATTENZIONE: dato che il 29 luglio 2015 è la data prevista per l’aggiornamento automatico di Windows 7 e di Windows 8.x alla versione Windows 10 e dato che Visual Studio necessità di Windows 10 per installare i tool di sviluppo aggiornati per le Universal Apps per Windows 10, è opportuno che l’installazione di Visual Studio 2015 avvenga dopo l’aggiornamento di Windows, altrimenti qualcosa non funzionerà. Vi consiglio quindi di effettuare l’installazione in una virtual machine “usa e getta”, se proprio non riuscite a trattenervi…  :-)

      Le costanti Infinity e -Infinity

      Trattando con espressioni matematiche può capitare di incorrere nella divisione di un numero per zero. Normalmente una divisione per zero incorre in un’eccezione DivideByZeroException, come si può vedere nella figura seguente:

      image

      Notate però che l’operazione di divisione è eseguita tra due valori interi.

      Se invece degli interi utilizziamo valori reali (cioè numeri a virgola mobile o floating-point), il risultato sarà il seguente:

      image

      Come potete vedere, le due operazioni danno un risultato completamente differente: +Infinito e –Infinito.

      +Infinito e –Infinito (o +Infinity e –Infinity nella versione inglese) sono due costanti a virgola mobile utilizzate da F#.

      Unità di misura

      Una delle caratteristiche di F# di cui non troviamo corrispondenza in Visual Basic e in C# è quella delle “units-of-measure”, cioè delle unità di misura.

      Nei calcoli scientifici è molto importante utilizzare le corrette unità di misura: per esempio, per una distanza si utilizzano i metri <m>, per una unità di tempo si potrebbero utilizzare i secondi <sec>, per una velocità i metri al secondo <m/sec>, mentre per un’accelerazione si utilizzano i metri al secondo al quadrato <m/sec^2>.

      Un altro aspetto importante delle unità di misura è la possibilità di effettuare delle conversioni da un’unità di misura ad un’altra (per esempio da gradi Centigradi a gradi Fahrenheit) oppure da un’unità di misura a unità di misura più piccole o più grandi (da chilogrammi a grammi oppure a tonnellate).

      Una unità di misura di dichiara come segue:

         1: [<Measure>] type m
         2: [<Measure>] type sec
         3: [<Measure>] type kg

      poi si utilizza come segue:

         1: let distance = 1.0<m>    
         2: let time = 2.0<sec>    
         3: let speed = 2.0<m/sec>    
         4: let acceleration = 2.0<m/sec^2>    
         5: let force = 5.0<kg m/sec^2>   

      Come potete vedere, abbiamo dichiarato le unità di misura m (metri), sec (secondi) e kg (chilogrammi) e poi abbiamo dichiarato degli identificatori come la distanza (espressa in metri), un tempo (espresso in secondi), una velocità (espressa in metri al secondo), un’accelerazione (espressa in metri al secondo quadrato) e una forza (chilogrammi per metro al secondo quadrato).

      Naturalmente è possibile definire anche delle unità di misura derivate, come nel seguente esempio:

         1: [<Measure>] type N = m/sec^2
         2: let force1 = 5.0<kg m/sec^2>    
         3: let force2 = 5.0<N>

      Il vantaggio di dichiarare una unità di misura è il fatto che il compilatore è in grado di verificare tutte le espressioni utilizzate e segnalare quelle che sono incongruenti. In sostanza non è possibile “sommare mele e pere”, perché sono due entità diverse. Si possono sommare metri a metri, chilogrammi a chilogrammi, non è possibile invece sommare metri a chilogrammi perché è un calcolo che non ha alcun senso.

      Alcuni articoli utili su questo argomento sono i seguenti (in lingua inglese):

      http://msdn.microsoft.com/it-it/library/dd233243.aspx
      http://fsharpforfunandprofit.com/posts/units-of-measure/
      http://davefancher.com/2012/11/18/f-more-on-units-of-measure/
      http://trelford.com/blog/post/Runtime-Units-of-Measure-for-F.aspx

      I cicli For

      In questo post voglio mostrarvi come si usa un ciclo for, costrutto importantissimo che è probabilmente presente in tutte le applicazioni.

      Partiamo da un frammento di codice come questo:

         1: #light
         2: let results = [ for i in 0 .. 100 -> (i, i*i) ] 
         3: printfn "results = %A" results 

      Notate, nella prima riga, la direttiva #light che abbiamo già incontrato in un post precedente. Questa è una semplificazione per i programmatori “non-OCaml” che si avvicinano al linguaggio F# e può anche essere omessa, perché è predefinita.
      Il frammento di codice sembra banale, ma non lo è. Come potete vedere dalla figura seguente, restituisce un risultato che corrisponde a una lista.

      image

      Una lista è un costrutto primitivo utilizzato di frequente nei linguaggi funzionali e molto simile a una matrice. Tuttavia, una lista non consente un accesso basato sulla posizione, come la tradizionale sintassi a[i] di C#. Le liste sono utilizzate in molte occasioni nella programmazione funzionale e possono essere considerate l’equivalente in F# di List<T> del .NET Framework, anche se con alcune funzionalità migliorate.

      Una lista è sempre di tipo particolare e, in questo caso, l’identificatore results rappresenta un elenco di tuple, specificamente il tipo di tupla identificato in F# come tipo (int * int).

      Questa idea di una lista di tuple è familiare se considerata come l’equivalente di una coppia di colonne restituite da un’istruzione SELECT in SQL. Pertanto, nell’esempio viene creata essenzialmente una lista di coppie di numeri interi composto da 100 elementi.

      Comunemente, nei linguaggi funzionali, le definizioni delle funzioni vengono utilizzate ovunque sia possibile utilizzare il codice stesso. Pertanto, se si desidera estendere l’esempio precedente, potete scrivere quanto riportato di seguito:

         1: let compute2 x = (x, x*x)
         2: let compute3 x = (x, x*x, x*x*x)
         3: let results2 = [ for i in 0 .. 100 -> compute2 i ]
         4: let results3 = [ for i in 0 .. 100 -> compute3 i ] 

      Ecco quindi le due liste risultanti dall’esecuzione del frammento di codice riportato qui sopra:

      image

      Questa idea di eseguire un ciclo in una lista (o una matrice o qualche altro costrutto iterabile) è un’attività talmente comune nei linguaggi funzionali che è stata generalizzata come chiamata di metodo di base: List.iter. Questa funzione prevede semplicemente una chiamata a una funzione in ciascun elemento della lista.

      Funzionalità molto utili sono inoltre fornite da altre funzioni di libreria simili. Ad esempio, List.map accetta una funzione come argomento e applica la funzione a ciascun elemento della lista, restituendo una nuova lista nel processo.

      Utilizzare F# su LINUX, MAC, Android, iPhone ecc. ecc.

      Oltre che su Windows, F# può essere utilizzato su Linux, a patto di aver installato Mono. Inoltre può essere utilizzato anche su altre piattaforme come MAC, Android, iPhone, FreeBSD ecc. ecc… Il problema è: “come si fa?”.

      Alla pagina http://fsharp.org/use/linux/ trovate la guida per installare Mono e F# su Linux, mentre nelle altre pagine (i cui link sono elencati nella colonna di sinistra, nella stessa pagina, nella sezione “Getting F#”) trovate i riferimenti per le altre piattaforme.

      image

      F# in pillole: Unit Type ovvero ()

      Nella programmazione funzionale deve essere sempre restituito un valore. Tuttavia ci sono alcuni casi in cui il valore non c’è, per esempio quando utilizziamo la funzione printf. In questi casi, in fase di compilazione riceviamo un warning, cioè un avvertimento di possibile errore.

      Per risolvere in modo pulito queste situazioni, possiamo utilizzare il tipo unit che è rappresentato da una coppia di parentesi tonde, cioè (). La restituzione di uno unit equivale più o meno al void di altri linguaggi.

      In F# non c’è il concetto di Null, non esiste un valore o meglio un “non-valore” nullo, mentre esiste il tipo unit che fornisce un unico valore: ().

      Un codice di esempio che rappresenta quanto detto è questo:

      // con questo codice si ottiene un warning in compilazione:
      let function1 x y = x + y
      function1 10 20 
      
      // questo è invece valido e restituisce uno unit = ()
      let result = function1 10 20
      function1 10 20 |> ignore

      L’operatore |> indica un “pipe”, ovvero un redirezionamento del risultato verso un’altra funzione o verso un’output. In questo caso si ottiene uno unit.

      Anche se F# permette l’utilizzo di funzioni/istruzioni non prettamente funzionali, è opportuno utilizzare il paradigma funzionale in tutti i casi in cui è possibile, per poter ottenere un codice il più possibile sicuro e “pulito”.

      “Eager evaluation” (detta anche “greedy evaluation”) e l’opposto “Lazy evaluation”

      F# include un componente di programmazione funzionale che supporta la cosiddetta “Eager evaluation”, detta anche “Greedy evaluation”. Per la programmazione funzionale, questo componente fornisce vari costrutti e un insieme di tipi immutabili: tuple, record, unioni discriminate e liste.

      Il termine “Eager” significa sostanzialmente “impaziente, avido” ed è all’opposto di “Lazy”, ovvero “pigro”.

      Nella eager evaluation, un’espressione è valutata non appena viene assegnata a una variabile (che nel caso di F# è opportuno chiamare “identificatore”), mentre nella lazy evaluation l’espressione è valutata solo nel momento in cui è richiesto il risultato.

      Vediamo ora i tipi immutabili di cui ho fatto cenno all’inizio di questo post.

      n-tuple

      Una n-tupla rappresenta una collezione di “n” valori, dove “n” è maggiore o uguale a zero.

      Il tipo  unit  corrisponde alla 0-tupla e ha un solo valore:  (), che indica “nessuna informazione” (sostanzialmente l’insieme vuoto).

      Il tipo unit è utilizzato per implementare funzioni che non hanno necessità di input e/o non restituiscono valori.

      Una 3-tupla potrebbe essere rappresentata da  (A, B, C), dove A, B e C sono valori di possibili differenti tipi.

      Una tupla può essere utilizzata solo per memorizzare valori quando il numero di valori stessi è conosciuto al momento della definizione (a design-time) e rimane costante durante l’esecuzione.

      record

      Un record è una specializzazione delle tuple dove gli elementi dei dati sono denominati, come in { Name: string; Age: int}.

      I record possono essere creati con la forma  { Name = “AB”; Age = 42 }.

      La parola riservata with è utilizzata per creare una copia di un record, per esempio { r with Name = “CD” }, che crea un nuovo record copiando r e cambiando il valore del campo Name (assumendo che il record creato nell’ultimo esempio sia denominato r).

      liste

      Il tipo list è una normale linked list rappresentata in due varianti:

      • una notazione head::tail (:: è l’operatore cosiddetto “cons”, per dividere due parti di una lista)

      • una notazione abbreviata come [item1; item2; item3].

      Una lista vuota è scritta con la notazione [].

      unioni discriminate

      E’ un altro tipo di dati algebrico che può essere definito per mantenere un valore di un tipo previsto tra quelli predefiniti. Per esempio:

      type A = 
         | valX of string
         | valY of int

      let

      Per dichiarare un identificatore (non chiamateli variabili, per favore!), si utilizza la parola riservata let.

      Ma questa è un’altra storia…

      (F#) Project Euler .net – Problema n. 1

      Molto spesso, per imparare un nuovo linguaggio di programmazione, si esaminano alcuni problemi matematici. Questo avviene per due motivi: il primo è motivo deriva dal fatto che molti piccoli problemi matematici sono molto semplici e quindi non aggiungono livelli di complessità all’attuale nostro problema di imparare un particolare linguaggio di programmazione. Il secondo motivo è dato dal fatto che questo approccio consente di imparare in modo più efficace i costrutti di base della programmazione nel linguaggio scelto: cicli, istruzioni condizionali, assegnazione di valori, visualizzazione del risultato e così via.

      Un sito interessante che raccoglie molti di questi problemi matematici, in ordine di difficoltà crescente, è “Project Euler .net” (http://projecteuler.net). Potete registrarvi al sito per provare a dare le vostre soluzioni. Quando fornirete una soluzione corretta, vedrete nel vostro “pannello” dei problemi le soluzioni trovate e potrete anche visualizzare un file PDF contenente una spiegazione dettagliata della soluzione proposta.

      Utilizzerò pertanto qualcuno di questi problemi per costruire il nostro “vocabolario” delle istruzioni di F#. Il fatto che il sito abbia il suffisso “.net” è solamente un caso: non ha alcuna attinenza con il Framework .NET  clip_image001

      Il primo problema consiste nell’esaminare e sommare tra loro tutti i multipli di 3 e di 5 in un intervallo di numeri naturali che va da 1 a “x”. Per esempio, tra 1 e 9, la somma dei multipli di 3 e 5 è pari a 23 (= 3+5+6+9).

      Trovare la somma di tutti i numeri multipli di 3 e di 5, tra 1 e 999.

      Possiamo risolvere questo problema in almeno due modi (ma probabilmente anche in molti altri). In entrambi i casi otteniamo il numero 233168.

      La prima soluzione è la seguente:

      #light
      let rec sum_mul xs =
         match xs with
            | [] -> 0
            | y::ys when y % 3 = 0 || y % 5 = 0 -> y + sum_mul ys
            | y::ys -> sum_mul ys
      let sum = sum_mul [1 .. 999]
      printfn "%d" sum

      Esaminiamo come funziona questa prima soluzione.

      La direttiva #light permette di scrivere il codice in modo più semplice, senza le parole chiave begin … end e senza altri caratteri che indicano il termine delle righe di istruzione (come il “;” di C#, per esempio). I cicli o i blocchi di codice sono definiti dall’indentazione del codice (cioè dai rientri), mentre il termine delle istruzioni è semplicemente riconosciuto dalla presenza di spazi e di ritorni a capo.

      Nella seconda riga abbiamo inserito una funzione ricorsiva, denominata sum_mul, che accetta il parametro xs.

      Nelle righe dalla 3^ alla 6^ c’è un esempio di pattern matching: un metodo elegante per gestire varie alternative (come uno switch o un select case). Il programma confronta xs con alcuni pattern, ciascuno scritto in una riga separata e preceduti dal simbolo “|” (pipe). Nel primo caso il confronto ha successo quando xs è una lista vuota e in tal caso sum_mul restituisce 0 (zero).

      Negli altri casi, xs corrisponde a una lista, in cui il primo elemento (la testa della lista) viene chiamato y e il resto della lista (la coda della lista) viene chiamato ys.

      Se y è divisibile per 3 o per 5 (utilizzando l’operatore modulo: %) aggiungiamo il numero al risultato e poi eseguiamo la stessa funzione ricorsivamente per la coda della lista. In caso contrario, semplicemente saltiamo il valore di testa e continuiamo ad esaminare la coda della lista.

      Nell’8^ riga chiamiamo effettivamente la funzione sum_mul passando una lista come argomento. Questa lista è composta da tutti i numeri interi da 1 a 999 (o qualsiasi altro numero abbiate fissato come numero finale).

      Per eseguire il programma e visualizzare il risultato potete premere F5 come al solito (l’istruzione printfn stamperà il risultato in una finestra analoga al prompt di comandi), oppure potete evidenziare la porzione di codice da eseguire e premere contemporaneamente ALT + INVIO. In quest’ultimo caso, il programma sarà eseguito e il risultato sarà visibile nella finestra “F# interactive” che comparirà nella parte inferiore del video.

      La seconda soluzione invece è maggiormente ottimizzata:

      #light
      let sum_mult max step =
        let n = max / step
        step*n*(n + 1)/2
      
      let max = 999
      let sum2 = 
         sum_mult max 3 + sum_mult max 5 - sum_mult max 15
      printfn "%d" sum2

      Partendo dal presupposto che stiamo sommando tutti i multipli di 3 e di 5, possiamo anche effettuare una semplice operazione per trovare tutti i multipli dell’uno e dell’altro valore, invece di provare tutti i valori nell’intervallo considerato (da 1 a 999). In tal caso dobbiamo anche sottrarre tutti i multipli di 15, perché 15 è divisibile sia per 3 sia per 5, e quindi dobbiamo evitare di contare tali valori per due volte.

      Ricordando che la somma dei primi n numeri interi è uguale a n*(n+1)/2, possiamo utilizzare questa semplice formula per eseguire l’operazione desiderata, prima con il numero 3, poi con il numero 5 e infine con il numero 15.

      Nella 2^ linea definiamo la funzione sum_mult che prende due argomenti interi: max e step.

      Nella linea successiva, definiamo un identificatore locale denominato n, il cui ambito di visibilità è limitato all’interno della funzione sum_mult.

      Il resto del codice è estremamente semplice, dato che applichiamo la formula sopra indicata.

      Confrontando la complessità computazionale dei due programmi (chiamata “O grande”), troviamo che nel primo caso abbiamo una complessità O(n), mentre nel secondo caso abbiamo O(1). Nel secondo caso, quindi, la complessità (e la durata di esecuzione) è indipendente dal numero di valori da esaminare (in questo caso 999).

      N.B. lo spunto per questo post e l’informazione sul sito Project Euler .net è stato gentilmente concesso da Claudio Cherubino (http://www.fsharp.it e http://www.claudiocherubino.it/). Grazie!

      F# “tail”

      (Riporto questa discussione avvenuta la sera del 9 novembre 2010 sul forum dedicato a F#, nel portale di DotNetWork.it, poiché un problema al server l’ha purtroppo cancellata)

      Arcopal:
      Ciao e complimenti per il forum.
      Ho trovato in giro la seguente funzione:

      let rec length list = 
         match list with 
         | [] -> 0 
         | _ :: tail -> 1 + length tail

      Volevo capire come si interpreta. Specialmente l’ultima riga dove c’è la parola “tail”.

      Mia risposta:
      Ciao Arcopal.
      Partiamo dalla fine: la parola “tail” è in inglese e significa “coda” (così come “head” significa “testa”). Anzi, head e tail vengono utilizzati in particolare in algoritmi ricorsivi… Per esempio, proviamo a vedere questo codice che ho trovato in un libro su F#:

      // concatenate a list of strings 
      // into single string 
      let rec conactStringList = 
         function head :: tail -> head + conactStringList tail 
            | [] -> ""// test data 
      let jabber = 
         ["'Twas "; "brillig, "; "and ";
            "the "; "slithy "; "toves "; "..."] 
      // call the function 
      let completJabber = conactStringList jabber 
      // print the result 
      printfn "%s" completJabber

      Dovrebbe (in teoria) essere abbastanza chiaro che “head” indica il primo elemento di una lista, mentre “tail” indica la coda, cioè tutto il resto. Separando le due parti, diventa semplice gestire una lista di stringhe (come nell’esempio) con una funzione ricorsiva (che nel codice F# è indicata con la parola riservata “rec”). Riprendendo il codice che hai pubblicato tu e inserendo la parte del codice che ti ho appena fatto vedere, possiamo scrivere qualcosa come questo codice:

      let rec length list = 
         match list with 
            | [] -> 0 
            | _ :: tail -> 1 + length tail 
      // test data 
      let elenco = 
         ["'Twas "; "brillig, "; "and "; 
            "the "; "slithy "; "toves "; "..."] 
      // call the function 
      let l = length elenco

      Se avvii il programmino in F# interactive (selezionando tutto il codice di cui sopra e avviandolo con la combinazione ALT+INVIO), otterrai il seguente risultato:

      val length : 'a list -> int 
      val elenco : string list = 
         ["'Twas "; "brillig, "; "and "; 
            "the "; "slithy "; "toves "; "..."] 
      val l : int = 7

      F# in pillole: ancora stringhe

      Come in qualsiasi altro linguaggio di programmazione, una stringa è un gruppo di caratteri o simboli considerati come unica entità.

      Per inizializzare una stringa si può includere il suo valore tra doppi apici. Per esempio:

      let message = "Benvenuti nel mondo della programmazione funzionale!";

      Per visualizzare una variabile stringa utilizzando le funzioni printf o printfn, si può utilizzare %s come segnaposto della variabile. Ecco un esempio:

      let message = "Benvenuti nel mondo della programmazione funzionale!"
      printfn "%s" message;

      Dichiarando una variabile, se volete che sia proprio una stringa, potete utilizzare il tipo di dati string. Ecco un esempio:

      let message:string =
      "Benvenuti nel meraviglioso mondo della programmazione funzionale!"
      printfn "%s" message;

      Talvolta è necessario utilizzare una stringa il cui valore non è conosciuto in precedenza. Nessun problema: è possibile dichiarare prima una variabile stringa e poi utilizzare la variabile. Potete utilizzare le parole chiave “let” o “string” seguite dal nome della variabile che volete definire. Il nome deve rispettare le regole che abbiamo già indicato.

      Dichiarando una variabile stringa, è possibile inizializzarla con uno spazio vuoto, un carattere, un simbolo, una parola o un insieme di parole. Il valore fornito a una stringa deve essere incluso tra doppi apici. Per esempio:

      let nome = "Mario De Ghetto"
      let url = "http://books.deghetto.it"
      printfn "Benvenuti nel mondo della programmazione F#!"
      printfn "Nome: %s" nome
      printfn "URL: %s" url

      Questo codice produce il seguente risultato:

      > Benvenuti nel mondo della programmazione F#!
      Nome: Mario De Ghetto
      URL: http://books.deghetto.it
      val nome : string = "Mario De Ghetto"
      val url : string = “http://books.deghetto.it”

      Se si vuole dividere su più righe una stringa troppo lunga, è possibile tagliarla utilizzando un simbolo di “back slash” (“\”). Ecco un esempio

      printfn "Benvenuti nel mondo \
      della programmazione F#!"

      I hate Null, I prefer F#!

      image

      Pillole di F#: tipi di dati – string

      Il tipo stringa di F# si chiama “string” (con la “s” minuscola) e corrisponde al tipo System.String di .NET.

      Se la stringa contiene un carattere di “backslash” (\), si tratta in genere di un carattere di escape, ovvero un carattere di controllo. Per esempio:

      printf "Ciao\t "
      printf "Mondo!\n"
      • \t = carattere di tabulazione

      • \n = carattere di nuova linea (ritorno a capo)

      Per maggiori indicazioni sui caratteri di controllo potete leggere il mio post di ieri.

      Selezionando le due istruzioni dell’editor di codice di Visual Studio 2010 e premendo la combinazione ALT+Invio (F# interactive), otterrete questo risultato:

      > Ciao     Mondo!

      In alcuni casi è necessario definire una stringa che abbia un carattere backslash da considerare come vero e proprio carattere, non come un carattere di escape. Per esempio il carattere “\” utilizzato per definire un percorso di un file:

      printf @"c:\esempi\fsharp"
      printf "\n"
      printf @""""
      printf "\n"
      printf @"<"">"
      printf "\n"

      Il risultato sarà il seguente:

      c:\esempi\fsharp
      "
      <">

      Come potete vedere, per “stampare” il carattere delle virgolette (“) ossia i doppi apici, bisogna inserire due volte il carattere ” all’interno delle virgolette: il primo e l’ultimo carattere ” servono per delimitare la stringa, mentre i due caratteri ” (“”) indicano che bisogna stampare proprio il carattere “.

      Un altro esempio:

      let message = "Ciao
      Mondo\r\n\t!"
      let dir = @"c:\progetti"

      Ecco il risultato:

      val message : string = "Ciao
      Mondo
      !"
      val dir : string = "c:\progetti"

      F# in pillole: caratteri e stringhe – le sequenze di escape

      Una sequenza di “escape” è uno speciale carattere non visualizzabile, cioè generalmente un carattere di controllo. E’ possibile utilizzare questo tipo di carattere, per esempio, per indicare il termine della linea e il ritorno a capo.

      Una sequenza di escape è rappresentata dal carattere “backslash” (\), seguito da un altro carattere o simbolo. Per esempio, la sequenza di escape che ci permette di andare a capo nella linea successiva è \n.

      Una sequenza di escape può essere inserita anche tra i doppi apici di un’istruzione printf o printfn. Ecco l’elenco delle sequenze di escape:

      • \b – backspace: fa retrocedere il cursore

      • \t – tabulazione orizzontale: fa avanzare il cursore al prossimo punto di tabulazione

      • \n – nuova linea: sposta il cursore all’inizio della linea successiva

      • \r – ritorno carrello: sposta il cursore all’inizio della linea corrente

      • \” – doppi apici: visualizza un carattere di doppi apici (“)

      • \’ – apostrofo: visualizza un apostrofo (‘)

      • \\ – backslash: visualizza un carattere di barra inversa (\)

      • \o – null: visualizza un carattere Null

      • \uXXXX oppure \UXXXX – carattere Unicode: è utilizzato per visualizzare il carattere equivalente di un simbolo rappresentato con un valore esadecimale

      Ecco un esempio:

      let genere:char = 'M';
      printf "Genere: ";
      printfn "%c\n" genere;

      F# in pillole: tipi di dati – caratteri

      Come tutti sanno, un carattere può essere:

      • una lettera, maiuscola o minuscola (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y o Z)
      • una cifra (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
      • un simbolo rappresentabile dal computer (` ~ ! @ # $ % ^ & * ( ) – _ = + [ ] \ | ; : ‘ < ? . / , > “)

      Per rappresentare un valore di tipo carattere è necessario dichiarare una variabile e inizializzarla con una lettera, una cifra o un simbolo incluso tra due apici singoli (‘). Ecco un esempio:

      let gender = 'F';

      Per visualizzare il valore, all’interno dei doppi apici di un’istruzione printf o printfn, si utilizza un segnaposto per la variabile: %c. Ecco l’esempio:

      let gender = 'F';
      printf "Student Gender: ";
      printfn "%c" gender;

      Si otterrà così il seguente risultato:

      Student Gender: M

      Se vogliamo indicare esplicitamente che si tratta di un carattere, possiamo utilizzare la parola chiave char quando dichiariamo la variabile. Ecco l’esempio:

      let gender:char = 'F';
      printf "Student Gender: ";
      printfn "%c" gender;

      F# in pillole: introduzione alle variabili

      Una variabile è una sezione della memoria centrale che viene utilizzata per mantenere temporaneamente un valore.

      Per riservare una porzione di memoria bisogna dichiarare una variabile. Naturalmente in tutti i linguaggi ci sono delle regole da seguire: F# non fa eccezione su questo fatto.

      Per dichiarare una variabile bisogna utilizzare l’operatore let, seguito dal nome di una variabile, e assegnare a tale variabile un valore utilizzando l’operatore di assegnazione “=”. Lo schema da seguire è il seguente:

      let variabile = "pippo"

      Altro esempio:

      let numero = 1234

      Come abbiamo visto in precedenza (funzioni printf e printfn), le dichiarazioni possono terminare con un punto e virgola (;) oppure no. La dichiarazione di cui sopra può essere scritta anche come

      let numero = 1234;

      Anche se abbiamo dichiarato e inizializzato la variabile in una unica riga, possiamo comunque spostare l’inizializzazione in una riga diversa. In questo caso, il codice della riga successiva deve essere “indentato” (cioè fatto rientrare di qualche carattere). Ecco un esempio:

      let numero = 
      1234

      oppure, ancora:

      let numero = 
      1234;

      Invece di dichiarare una variabile sola, ovviamente è possibile dichiararne più di una. Ogni variabile deve essere dichiarata su una riga diversa, senza indentazione, utilizzando per ciascuna dichiarazione la parola chiave let e la sua inizializzazione. Ecco alcuni esempi:

      let numero1 = 1234
      let numero2 = 5678
      let numero3 = 4433

      C’è un’alternativa: è possibile dichiarare con una sola parola let tutte le variabili separate da una virgola e inserendo le assegnazioni dopo l’operatore di assegnazione “=”, anche queste separate da una virgola. Le assegnazioni saranno effettuate nell’ordine in cui i vari elementi appaiono. Ecco l’esempio equivalente all’esempio precedente:

      let numero1, numero2, numero3 = 1234, 5678, 4433

      Le variabili non devono essere necessariamente dello stesso tipo. Per esempio:

      let numero1, cognome, genere = 1234, "Rossi", 'M'

      Se una istruzione di inizializzazione è troppo lunga, ricordatevi che potete sempre dividere la stessa e continuare nella riga successiva (in questo caso sempre indentando il codice). Ecco l’esempio:

      let numero1, cognome, genere = 
      1234, "Rossi", 'M'

      Pillole di F#: variabili e identificatori

      Ogni volta che presento il linguaggio F# a un evento tecnico e spiego che in F# non dobbiamo parlare di “variabili” ma di “identificatori“, perché la definizione di un identificatore associa a quest’ultimo un valore che non è più modificabile, vedo sempre facce sorprese, quasi sconvolte.

      Il concetto stravolge le nostre abitudini, ci spaventa e quindi rischia di frenare sul nascere l’apprendimento di questo linguaggio.

      In realtà le cose sono più semplici di quelle che sembrano:

      • nei linguaggi che abbiamo utilizzato finora (VB, C#, Java ecc.) la principale istruzione è l’assegnazione di un valore a una variabile. Una variabile può sempre cambiare valore nel corso del programma a meno che non venga preventivamente dichiarata come costante. La norma, quindi, è la mutabilità del valore (variabile), l’eccezione è l’immutabilità del valore (costante);

      • in F# il concetto è esattamente l’opposto: gli identificatori vengono dichiarati e assumono un valore che non cambia più nel corso del programma (immutabili), mentre se vogliamo un identificatore che possa cambiare il valore (mutabile) dobbiamo dichiararlo esplicitamente con la parola riservata  mutable.

      Nel linguaggi .NET “classici” (per esempio VB e C#), il concetto di variabile immutabile c’è in un preciso e conosciuto contesto: le stringhe. Una stringa viene definita con un valore ben preciso. Possiamo ridefinire la stringa assegnando un valore diverso, ma in questo caso in memoria succede qualcosa di particolare: la stringa precedente viene “abbandonata” e viene creata una nuova stringa in un’altra posizione di memoria. Non viene modificata la stringa originaria, quindi possiamo considerarla immutabile! Per modificare una variabile stringa senza ridefinirla possiamo, naturalmente, utilizzare un oggetto di tipo StringBuilder.

      Vediamo un esempio di identificatori mutabili e immutabili:

      // identificatore immutabile let stringA = “Hello” let stringB = “world” let stringC = stringA + ” “ + stringB // identificatore mutabile let mutable stringD = “Hello” stringD <- “Ciao”

      Il risultato che otterremo in “F# interactive” (selezionando il codice e premendo la combinazione ALT+INVIO) è il seguente:

      val stringA : string = “Hello” val stringB : string = “world” val stringC : string = “Hello world” val mutable stringD : string = “Ciao”

      Notate come abbiamo assegnato la stringa “Ciao” alla variabile mutabile (cioè con l’operatore <-). Tenete ben presente questo operatore perché ci torneremo sopra…

      Windows Phone 7 e i linguaggi VB.Net e F#

      (Post liberamente tradotto dal post pubblicato alla pagina
      http://justinangel.net/WindowsPhone7VBnetAndFsharp
      da Justin Angel. Utilizzo del post espressamente autorizzato dallo stesso autore)

      Salve gente,

      In questo articolo esamineremo il supporto a Windows Phone 7 per i linguaggi di programmazione Visual Basic .NET e F#. Il nostro obiettivo è quello di dimostrare che Windows Phone 7 invece può supportare le librerie di codice F# e VisualBasic.Net e i controlli utente.

      Potete scaricare il progetto di esempio che abbiamo costruito in questo articolo da qui: http://JustinAngel.net/storage/WP7.Languages.zip.

      Perchè?! Perché Microsoft ci ha abbandonato?!

      clip_image001

      La lettura del supporto online su Windows Phone 7 con VB.Net & F# può essere alquanto fuorviante.

      Sui forum ufficiali MSDN WP7 possiamo trovare il seguente commento:

      “Windows Phone 7 attualmente è supportato solo per C#” Mark Chamberlain

      Durante il webcast di Windows Phone 7 un membro del pubblico ha chiesto il sostegno di VB.Net e fu risposto:

      “Ho paura che Visual Basic non sia supportato per i dev di WP7” – Andy Wigley

      Sul forum ufficiale Silverlight WP7 possiamo trovare molte domande circa il supporto di VB.NET in WP7 con risposte come:

      Q: “Posso sviluppare applicazioni con VB.NET per Windows Phone 7?

      A: “No, non puoi.

      Nel blog tecnico TechRepublic è citato:

      L’unico linguaggio che funzionerà sarà C#; non c’è necessità di adottare VB.NET.”  TechRepublic

      E il “Canadian Heritage”, Ministro di lingue ufficiali, l’onorevole MP James Moore ha detto:

      “Il mio cane indossa un impermeabile di partito conservatore”

      clip_image003

      Tutte le indicazioni di cui sopra, ad eccezione dell’ultima, sono tutte palesemente false. L’ultima dichiarazione è solo semplicemente imbarazzante. Windows Phone 7 infatti supporta Visual Basic .NET e F# e lo fa dal giorno numero 1.

      Le applicazioni Windows Phone 7 sono in C#.

      L’unica dichiarazione che può essere fatta e che è oggettivamente vera è che durante la Beta WP7 l’unica lingua supportata per il progetto di applicazione WP7 stesso è C#. Il che significa assolutamente nulla, poiché un’applicazione WP7 può fare riferimento a una libreria di Silverlight 3 in F# o in VB.NET.

      Utilizzare F# in Windows Phone 7

      Vediamo come installare una semplice applicazione WPF “Ciao mondo” con F#.

      1) Create una nuova Applicazione Windows Phone 7 in C#.

      clip_image005

      2) aggiungete un progetto di libreria F# Silverlight alla soluzione.

      clip_image007

      clip_image009

      clip_image010

      3) Aprite il file module1.fs e scrivi del codice F#.
      Faremo questo esempio di base con un semplice esempio non-UI “Hello world”.

      module WP7FSharpLibrary
         type myClass = class
         new () as this = {}
         member s.myMethod() =
            “OMG! Windows Phone 7 is running F# code!”
      end

      3) Aggiungete un riferimento dall’applicazione WP7 alla nuova libreria F# e compilate la soluzione.

      4) nell’applicazione C# in WP7, inizializzate la classe F# e invocate i membri appropriati.

      // Constructor
      public MainPage()
      {
         InitializeComponent();
         var FSharpClass = new WP7FSharpLibrary.myClass();
         ContentGrid.Children.Add(new TextBlock()    {
             Text = FSharpClass.myMethod()});
      }

      Quando eseguiamo la nostra applicazione possiamo chiaramente vedere che F# si esegue in Windows Phone 7 senza un intoppo.

      clip_image012

      È anche possibile avere F# che inizializza i vari elementi dell’interfaccia utente e che crea l’interfaccia utente per noi. Ma questo non è davvero un compito in cui la programmazione funzionale eccelle, per cui eviterò di dimostrare questa cattiva pratica.

      Utilizzare un UserControl Visual Basic .Net in Windows Phone 7

      1) Create una nuova applicazione C# in Windows Phone 7.

      clip_image013

      2) Aggiungete un progetto di libreria Silverlight in VisualBasic.net alla soluzione.

      clip_image014

      clip_image016

      clip_image017

      3) Aggiungete un nuovo UserControl al progetto VB.Net Silverlight.

      Nel nostro caso aggiungeremo un controllo utente semplice con un <ListBox /> con pochi elementi.    

      Partial Public Class SL3VbNetUserControl
            Inherits UserControl
         Public Sub New
            InitializeComponent()
            Me.DataContext = 
               {“Hello from VB.Net on WP7!”, “World”, “Foo”, “Bar”, “Baz”}
         End Sub
      End Class
      <UserControl x:Class=”WP7.VisualBasicNet.SL3VbNetUserControl”
         xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation&amp;#8221;
         xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml&amp;#8221;
         xmlns:d=”http://schemas.microsoft.com/expression/blend/2008&amp;#8243;
         xmlns:mc=”http://schemas.openxmlformats.org/markup-compatibility/2006&amp;#8243;
         mc:Ignorable=”d”
         d:DesignHeight=”300″ d:DesignWidth=”400″>
         <Grid x:Name=”LayoutRoot”>
            <ListBox ItemsSource=”{Binding}” />
         </Grid>
      </UserControl>

      4) Aggiungete un riferimento dall’applicazione WP7 alla nuova libreria VB.Net e compilate.

      5) Aggiungete il nuovo UserControl in SilverLight (VB.Net) alla MainPage nel progetto WP7.

      <!–ContentPanel – place additional content here–>
      <Grid x:Name=”ContentGrid” Grid.Row=”1″>
         <VisualBasicNet:SL3VbNetUserControl 
      xmlns:VisualBasicNet=”clr-namespace:WP7.VisualBasicNet;
      assembly=WP7.VisualBasicNet” /> </Grid>

      6) Se tentiamo di eseguire il progetto a questo stato, vedremo il seguente avviso di compilazione:

      Warning    1    The primary reference “d:\visual studio 2010\Projects\WP7.Languages\WP7.VisualBasicNet\Bin\Debug\WP7.VisualBasicNet.dll” could not be resolved because it has an indirect dependency on the framework assembly “Microsoft.VisualBasic, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35″ which could not be resolved in the currently targeted framework. “Silverlight,Version=v4.0,Profile=WindowsPhone”. To resolve this problem, either remove the reference “d:\visual studio 2010\Projects\WP7.Languages\WP7.VisualBasicNet\Bin\Debug\WP7.VisualBasicNet.dll” or retarget your application to a framework version which contains “Microsoft.VisualBasic, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35″.    WP7.Languages

      clip_image019

      Assicuratevi di aggiungere un riferimento dall’applicazione WP7 a Microsoft.VisualBasic.dll e che questa sia contrassegnata come “copia locale = false”.

      Nel mio sistema di sviluppo trovo la DLL qui: c:\Program Files (x86)\Microsoft Silverlight\4.0.50524.0\Microsoft.VisualBasic.dll

      clip_image021

      clip_image023

      Con un click destro sul riferimento “Microsoft.VisualBasic”, scegliete “properties” e impostate “Copy Local” a falso (False)”.

      clip_image025

      clip_image027

      Dopo questo cambiamento possiamo eseguire il nostro progetto e lo UserControl Silverlight (Visual Basic .NET) appare nel nostro progetto Windows Phone 7.

      clip_image029

      Ovviamente, dopo aver aggiunto le DLL di Windows Phone 7 al nostro progetto VB.Net saremmo in grado di fare tutto ciò che può fare un possibile progetto C#: posizione GPS, notifiche Push, accelerometro, navigazione, eccetera.

      Fine

      Windows Phone 7 supporta tutti e tre i principali linguaggi di programmazione .NET 4.0: C#, VisualBasic.Net e F#.
      Benché sia supportato solo C# durante la beta WP7 come radice dell’applicazione WP7, questo è un piccolo ostacolo che possiamo facilmente superare.

      A seguito di questo post del blog mi aspetto che sia gli sviluppatori F# sia quelli di VB.Net  producano alcune applicazioni WP7. Sì, sto guardando proprio voi.

      Corso online su “Windows 10: Distribuzione, gestione e sicurezza del nuovo sistema operativo” di Vito Macina (MVP)

      Si avvicina sempre di più la data prevista per la distribuzione di Windows 10, il nuovo rivoluzionario sistema operativo Microsoft.

      Dato che ogni nuova versione porta con sé tante nuove caratteristiche, è sempre molto importante tenersi aggiornati e quindi cosa c’è di meglio che un corso online gratuito?

      Questo che vi presento è stato registrato da Vito Macina (Microsoft MVP) ed è un ottimo corso, pubblicato sulla piattaforma Microsoft Virtual Accademy:

      http://www.microsoftvirtualacademy.com/training-courses/windows-10-distribuzione-gestione-e-sicurezza-del-nuovo-sistema-operativo

      Cosa aspettate? Iniziate la vostra formazione con questo nuovo corso!

      image

      Pillole di F#: come si installa?

      Il modo più semplice di installare il linguaggio F# è quello di farlo da Visual Studio (in figura, l’installazione di Visual Studio 2010):

      clip_image001

      F# è disponibile anche per i sistemi Linux, ma non esamineremo questa possibilità.

      Si può installare anche il solo compilatore, indipendentemente da Visual Studio, ma questo limita molto il suo utilizzo e quindi vi consigliamo comunque di utilizzare una qualsiasi versione di Visual Studio.

      Purtroppo ancora non esiste la possibilità di utilizzare F# con una versione Express (cioè “Visual F# Express” non esiste…). Speriamo che in futuro sia possibile farlo, per permettere di lavorare in F# anche a studenti, docenti e principianti, oltre che ad altre categorie che non possono permettersi di acquistare una versione di Visual Studio (per esempio le associazioni “no profit” e così via).

      Una volta che avrete installato il prodotto in Visual Studio, lo troverete come categoria a sé stante nell’elenco dei modelli di progetto che possono essere creati:

      SNAGHTML3186641

      Noterete sicuramente che esiste anche la possibilità di creare librerie basate su Silverlight, utilizzando F#. Non male, eh?   Sorriso

      Pillole di F#: una sintassi "light"

      Il linguaggio F# non richiede simboli o parole specifici per l’inizio e la fine di blocchi di codice, grazie soprattutto alla direttiva #light che è “on” in modo predefinito.

      In VB.NET, per esempio, dobbiamo utilizzare parole riservate specifiche come Sub … End Sub, Function … End Function, Class … End Class, For … Next e così via. In C# abbiamo invece l’ampio uso di parentesi graffe di apertura e di chiusura.

      In F# tutto questo non serve, perché i blocchi di codice sono identificati semplicemente con il numero di spazi con cui inizia una riga, cioè con la cosiddetta “indentazione“.

      Per esempio, vediamo il seguente codice:

      let words = [| "Red"; "Lorry"; "Yellow"; "Lorry" |]
      for word in words do
         printfn "%s" word

      Nella prima riga definiamo un array di stringhe

      Nella seconda riga definiamo un ciclo for, per leggere i singoli elementi dell’array e nella terza riga stampiamo a video ciascun valore.

      La terza riga fa parte del blocco di codice definito dalla seconda riga, ma non c’è una riga che chiude il ciclo perché non serve. Infatti la terza riga è spostata a destra di due caratteri e questo fa sì che F# sappia che l’istruzione è interna al ciclo for definito nella seconda riga.

      La cosa importante è quella di non utilizzare le tabulazioni per definire questi spazi, è meglio usare i caratteri “spazio” veri e propri, perché le tabulazioni possono essere visualizzate in modo diverso in diverse configurazioni e questo può dare problemi.

      Per evitare problemi di questo tipo e utilizzare ugualmente le tabulazioni, andate nelle opzioni di Visual Studio (menu Strumenti > Opzioni ), aprite la scheda Editor di Testo > F# > Tabulazioni, e impostate Inserisci spazi invece di Mantieni tabulazioni:

      SNAGHTML314e12a

      (Finestra Opzioni di Visual Studio 2012)

      F# in pillole: tipi di dati e inferenza dei tipi

      Nei precedenti post abbiamo visto che possiamo creare una variabile e assegnare a tale variabile un valore. Quando eseguiamo questa operazione, non dobbiamo necessariamente indicare il suo tipo in modo esplicito, perché il compilatore provvederà a determinare il tipo di variabile in modo implicito. F#, come altri linguaggi di programmazione, supporta diversi tipi di valore.

      Possiamo omettere di specificare il tipo di dato di una variabile e lasciare che se ne faccia carico il compilatore, oppure possiamo specificarlo.

      Ne consegue che F# è un linguaggio che permette l’inferenza dei tipi. Questo significa che, nel momento in cui dichiariamo una variabile, non abbiamo la necessità di specificare il suo tipo di dato ma dobbiamo comunque inizializzarla. Il compilatore, quindi, provvederà a “inferire” il tipo di dato, cioè deciderà qual è il tipo appropriato da utilizzare sulla base del valore assegnato.

      Pillole di F#: parole riservate

      In F# sono state definite le seguenti parole riservate che non possono essere utilizzate come nomi di variabili o funzioni:

      abstract, and, as, assert, asr, begin, class, default, delegate, do, done, downcast, downto, else, end, exception, false, finally, for, fun, function, if, in, inherit, inline, interface, land, lor, lsl, lsr, lxor, match, member, od, module, mutable, namespace, new, null, of, open, or, override, rec, sig, static, struct, then, to, true, try, type, val, when, upcast, while, with

      Ci sono poi altre parole che attualmente non sono utilizzate in F#, ma che sono state riservate per usi futuri:

      async, atomic, break, checked, component, const, constraint, constructor, continue, decimal, eager, enum, event, external, fixed, functor, include, method, mixin, namespace, object, process, property, protected, public, pure, readonly, return, sealed, switch, virtual, void, volatile, where

      Queste ultime possono essere utilizzate come nomi di variabili o funzioni, ma in tal caso il compilatore segnalerà un avvertimento (warning). Se volete evitare che in futuro ci siano problemi con il vostro programma, perché qualche parola è diventata parte del linguaggio F#, allora è bene che voi evitiate l’uso anche di queste parole.

      Libro “Professional F# 2.0″ (Wrox)

      Con l’uscita di Visual Studio 2010, tutti gli sviluppatori .NET del mondo hanno conosciuto un nuovo linguaggio: F#. In realtà il linguaggio è già arrivato alla versione 2.0, in quanto è già stato utilizzato per 5 anni all’interno di Microsoft Research e quindi è stato testato bene e migliorato. Ora F# è un linguaggio maturo, pronto anche per le esigenze del mercato.

      F# è un prodotto complesso, in quanto permette una programmazione multi-paradigma: programmazione orientata agli oggetti e programmazione funzionale insieme. Permette di creare librerie che possono poi essere utilizzate da altri linguaggi .NET e che possono essere utilizzate perfino in un Worker-Role di Windows Azure o in applicazioni Windows Phone 7.

      Ho fatto tutta questa premessa per dire che per conoscere bene questo prodotto è necessario anche avere della buona documentazione, possibilmente non frammentaria come quella che si trova spesso su Internet. Per imparare un linguaggio bisogna seguire un percorso ben preciso e ordinato, non si può saltare da un argomento all’altro senza prima aver acquisito le basi della programmazione. La cosa migliore per imparare meglio a utilizzare questo linguaggio, quindi, è acquistare un buon libro.

      Il libro “Professional F# 2.0” (ISBN 978-0-470-52801-3) edito da Wrox e scritto “a 8 mani” da Ted Neward, Aaron C. Erickson, Talbott Crowell e Richard Minerich, è in questo momento il migliore acquisto che potete fare per imparare bene e in modo professionale questo linguaggio.

      clip_image001

      (clicca sull’immagine per visitare la pagina del sito di Wiley.com)

      In circa 400 pagine e a un costo di 36,00 Euro potete trovare i seguenti argomenti (in lingua inglese):

      1. Primer
      2. Lexical Structure
      3. Primitive Types
      4. Control Flow
      5. Composite Types
      6. Pattern Matching
      7. Complex Composite Types
      8. Classes
      9. Inheritance
      10. Generics
      11. Packaging
      12. Custom Attributes
      13. Functions
      14. Immutable Data
      15. Data Types
      16. List Processing
      17. Pipelining and Composition
      18. C#
      19. Databases
      20. XML
      21. ASP.NET MVC
      22. Silverlight
      23. Services

      Il libro è scritto in modo molto chiaro, con numerosi esempi di codice che possono essere scaricati dalla pagina che vi ho fornito qui sopra (cliccate sull’immagine della copertina del libro e poi passate alla scheda Downloads).

      Dei libri di Wrox, poi, mi piace sempre moltissimo l’impaginazione, il font utilizzato e in generale la grafica, caratteristiche che rendono il libro molto leggibile e gradevole.

      Un piccolo esempio di codice per la definizione di un array e per la ricerca di un elemento contenuto nell’array(pagina 72):

      let people = [|
         new Person("Ted", "Neward", 28)
         new Person("Mark", "Richards", 45)
         new Person("Ken", "Sipe", 43)
         new Person("Naomi", "Wilson", 38)
         new Person("Michael", "Neward", 16)
         new Person("Matthew", "Neward", 9)
      |]
      
      let newardsFound =
         Array.find (fun (it : Person) -> it.LastName = "Neward")
            people
      
      System.Console.WriteLine(newardsFound)

      Bene, vi sembra davvero difficile questo linguaggio?

      Grazie a Wiley e in particolare a Dave Allen che mi ha inviato il libro per una valutazione!

      Raccolte di notizie su F# e sul mondo .NET

      Nel mondo ci sono molti blogger che pubblicano raccolte di articoli che possono essere letti liberamente online e che riguardano le più varie tecnologie Microsoft.

      Il primo che vi suggerisco è quello di Sergey Tihon, focalizzato su Visual F#, con tantissime news, link a video e a post di altri blogger:

      https://sergeytihon.wordpress.com/category/f-weekly/

      Il secondo è di Alvin Ashcraft. Qui si può spaziare veramente in tantissimi articoli tecnici sulle più disparate tecnologie, da XAML allo sviluppo web, da SQL Server a Xamarin Studio. Eccolo:

      http://www.alvinashcraft.com/

      Il terzo e ultimo che vi suggerisco è quello di Chris Alcock. Anche qui possiamo spaziare tra Azure e C#, tra TypeScript e ASP.NET. Eccolo:

      http://themorningbrew.net/

      Attenzione che sto parlando di blog con centinaia o migliaia di post pubblicati nell’arco di vari anni, quindi mica “micio-micio-bau-bau”!

      Buona lettura.

      Aggiornamento a Windows 10 gratis!

      Se avete Windows 7 o Windows 8.1, dal 29 luglio 2015, per un periodo limitato, potrete scaricare gratuitamente Windows 10 in aggiornamento da Windows Update!

      Per il momento, se volete, potete prenotarvi per ricevere un avviso che vi arriverà via e-mail quando sarà disponibile l’aggiornamento. Come si fa? Semplice, seguite i consigli contenuti nel seguente post:

      https://pieer11.wordpress.com/2015/06/01/siete-pronti-per-scaricare-windows-10/.

      Quali strumenti si possono utilizzare per programmare in F#? (parte 2)

      Nel mio post del 22 luglio 2013 ho indicato alcune modalità per programmare in F#, ma ho fatto qualche approfondimento e quindi in questo post voglio integrare con qualche informazione più precisa.

      Prima di tutto: con SharpDevelop possiamo creare progetti F# per la Console. L’informazione è corretta, ma se tentate di creare un progetto F# non otterrete altro che l’equivalente di una pernacchia: il compilatore F# deve essere installato a parte. Ora, non è che questo sia un problema: è sufficiente scaricare il pacchetto di installazione di F# dal sito dedicato al progetto open source e installarlo. Tutto bene, se non fosse per il fatto che la versione open source è ferma alla versione 2.0, mentre con Visual Studio 2012 possiamo utilizzare F# 3.0 e con Visual Studio 2013 (attualmente in versione Preview) stiamo andando verso la versione 3.1.

      Un’altra possibilità che si aggiunge a quelle segnalate nel mio post precedente è quella di utilizzare Visual Studio Express 2012 for Web e installarvi sopra il pacchetto “F# Tools for Visual Studio Express 2012 for Web”.

      Per installare il pacchetto bisogna prima di tutto installare la Microsoft Web Platform che permette di installare molte estensioni e applicazioni da utilizzare per i propri progetti web: estensioni, strumenti e perfino applicazioni intere (DotNetNuke, Orchard, Joomla! … per citarne solo alcune).

      Una volta installata la Web Platform potrete procedere all’installazione dei tool F# (compilatore, template ecc.) da utilizzare con Visual Studio Express 2012 for Web.

      image

      Il bello è che questo pacchetto di installazione non aggiunge solo F# a Visual Studio Express 2012 for Web, ma aggiunge anche tutti gli strumenti per sviluppare applicazioni per Windows Azure (il cloud di Microsoft), aggiorna i SQL Server Data Tools e molto altro.

      image

      Inoltre, avrete anche un web server incluso e gratuito che vi permette di non dover installare IIS sulla vostra macchina per poter eseguire le applicazioni web da testare: è sufficiente avviare l’applicazione dall’ambiente di sviluppo e automaticamente partirà l’applicazione nel browser Internet Explorer.

      Per creare i vostri progetti F# potete creare un progetto web o un progetto per Windows Azure, ma questo non dovrebbe essere un problema, dato che l’utilizzo di F# sul web o in progetti per Windows Azure non è molto diverso dall’utilizzo in ambito desktop. In Windows Azure è possibile utilizzare un progetto di tipo WorkerRole, cioè un modulo compilato che rimane attivo e che può effettuare le operazioni definite nel codice, nel momento in cui viene rilevato un cambiamento di stato (per esempio il WorkerRole potrebbe monitorare l’upload di file oppure il cambiamento dei dati in un database e reagire di conseguenza).

      Naturalmente potete anche creare delle librerie da compilare in DLL e da utilizzare in altri ambiti (per esempio in applicazioni Desktop, in Silverlight ecc.).

      In sostanza, con Visual Studio Express 2012 for Web potete avere un ambiente di sviluppo web completo, inclusa la possibilità di creare librerie F#, applicazioni per il cloud Microsoft e strumenti per l’accesso ai database SQL Server o SQL Azure (la versione del DBMS dedicata a Windows Azure).

      Microsoft Solver Foundation

      Tempo fa è stata rilasciata un’estensione al .NET Framework chiamata MSF (Microsoft Solver Foundation) che permette di definire modelli matematici, per ottenere la soluzione di problemi che possono essere risolti in modo più efficace, appunto, con un modello matematico ottimizzato.

      Potete scaricare il pacchetto di installazione della Express Edition dal portale di MSF (versioni a 32 e a 64 bit).

      Somasegar ha pubblicato un post su questo rilascio che trovate a questo indirizzo.

      Tra i numerosi esempi, trovate l’utilizzo di MSF insieme a Microsoft Excel e anche esempi di codice per C# ed F# (come il classico esempio di problema delle “mappe a 4 colori”). Gli esempi si trovano all’interno della cartella di installazione della libreria (C:\Program Files\Microsoft Solver Foundation\3.0.1.10599\Documents).

      Iscriviti

      Ricevi al tuo indirizzo email tutti i nuovi post del sito.

      Unisciti agli altri 844 follower