Archivio dell'autore: Mario De Ghetto

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

Un documento su alcuni casi di utilizzo di F# nelle imprese

Tempo fa, Don Syme mi ha segnalato che è stato pubblicato un documento che riassume alcune caratteristiche interessanti del linguaggio F# e che espone molti casi di successo nell’utilizzo di F# in vari ambiti delle imprese: finanza, statistica, analisi e valutazione di rischi, assicurazioni e sviluppo di applicazioni.

Il documento, denominato “Accelerated Analytical and Parallel .NET Development with F# 2.0si trova a questo indirizzo, oppure nel Microsoft F# Developer Center.

Sia nel documento, sia nel portale di F#, trovate una grande quantità di risorse aggiuntive che possono aiutarvi nella conoscenza di questo linguaggio e nello sviluppo di applicazioni, anche con librerie open source per F#.

Esempi di applicazioni F# open source

Su CodePlex sono presenti tantissimi progetti scritti in F#, per chi volesse iniziare a dare un’occhiata e provare cosa si può fare con questo linguaggio:

http://www.codeplex.com/site/search?TagName=F%23&query=%22F%23%22

Ci sono ovviamente applicazioni matematiche, ma anche custom control per WPF, applicazioni WPF, estensioni all’editor di codice e molto altro.

I commenti nel codice F#

E’ molto importante poter inserire dei commenti nel codice, per esempio per spiegare una certa istruzione o un algoritmo.

I commenti si possono scrivere in due forme diverse: commenti a singola riga o commenti multi-linea. I commenti a singola riga si scrivono iniziando la riga con la coppia “//”.

I commenti multi-linea, invece, si scrivono all’interno di un blocco (* … *). Per esempio:

// questo è un commento

(* anche questo è un commento *)

(*
   un commento si può mettere
   su più righe senza alcun
   problema
*)

(*
un commento si può mettere
su più righe senza alcun
problema, anche senza rientri
*)

Esiste un’alta forma di commento che permette di automatizzare la produzione di documentazione del codice: per questo tipo di commento si utilizza “///”. Per esempio:

/// questo è un esempio di codice autodocumentato

WCF è Open Source

Buongiorno a tutti!

E’ una notizia di ieri, 20 maggio 2015, la libreria WCF (Windows Communication Foundation) è ora stata rilasciata con licenza Open Source e disponibile sul repository GitHub, per uno sviluppo condiviso da parte della community di sviluppatori open source.

Se volete contribuire allo sviluppo, il progetto si trova a questa pagina:
http://www.dotnetfoundation.org/blog/wcf-is-open-source

.NET Foundation

Happy coding!

Try F# 3.0

Da qualche tempo è disponibile il sito “Try F# 3.0” che permette di imparare a utilizzare il linguaggio F#, scrivendo le istruzioni direttamente nella pagina web e verificando i risultati. SPET-TA-CO-LA-RE!

Lo trovate qui: http://www.tryfsharp.org/.

Ecco l’annuncio ufficiale dal blog del team di sviluppo:
http://blogs.msdn.com/b/fsharpteam/archive/2013/01/22/try-f-3-0-launches-today.aspx

Curiosità…

Lo sapevate che la prossima edizione di Visual Studio 2015 è numerata come versione 14, saltando a piè pari la versione 13? La stessa cosa era successa con Office (salto da versione 12 a versione 14).

Ma quanto sono superstiziosi questi sviluppatori?  :)

Le funzioni “printf” e “printfn”

Una delle funzioni predefinite di F# è denominata printf. Molti conosceranno già questa funzione, dato che esiste da molto tempo in altri linguaggi come il C.

Vedremo alcuni esempi dell’uso di questa funzione, utilizzata per “stampare” a video un valore, come una parola o una frase, per mostrarlo a un utente. Può servire, per esempio, a visualizzare il risultato di una funzione o di una elaborazione. Per utilizzare questa funzione, possiamo adottare una delle seguenti forme:

printf "Risultato da visualizzare"
printf ("Risultato da visualizzare")
printf "Risultato da visualizzare";
printf ("Risultato da visualizzare");

Come indicato in un precedente post, selezioniamo le 4 righe sopra indicate in Visual Studio 2012 e premiamo la combinazione ALT+INVIO. Questa operazione aprirà la finestra F# interactive, eseguendo le funzioni di cui sopra e visualizzando il seguente risultato:

Risultato da visualizzareRisultato da visualizzareRi
sultato da visualizzareRisultato da visualizzare>

Come potete vedere, il risultato delle 4 funzioni viene proposto visualizzando le 4 stringhe una accanto all’altra, senza mai andare a capo.

Inoltre potete vedere che le parentesi tonde sono facoltative, così come il punto e virgola (;) inserito alla fine della riga da eseguire: la sintassi più comoda, quindi, è quella senza parentesi tonde e senza punto e virgola (salvo nelle occasioni in cui vogliamo effettivamente far capire come è delimitato il risultato che vogliamo mostrare).

Ecco un altro esempio:

printf ("Benvenuti nel meraviglioso mondo ”)
printf (“della programmazione funzionale”)

Notate che alla fine della prima stringa abbiamo incluso uno spazio, per poter unire le due stringhe nel modo corretto.

Se però vogliamo che la visualizzazione di ciascun risultato venga disposta su righe separate, possiamo utilizzare una variante di questa funzione, anche questa già conosciuta dai programmatori di altri linguaggi: printfn (la “n” sta per “new line“).

La sintassi di printfn ha le stesse regole di printf:

printfn "Risultato da visualizzare"
printfn ("Risultato da visualizzare")
printfn "Risultato da visualizzare";
printfn ("Risultato da visualizzare");

Ecco quindi il risultato finale (nella finestra F# interactive):

Risultato da visualizzare
Risultato da visualizzare
Risultato da visualizzare
Risultato da visualizzare

Visual Studio 2015 RC

Con questo post vi voglio far vedere l’interfaccia grafica del nuovo Visual Studio 2015 RC. La prima immagine riguarda l’edizione Enterprise (con il tema “scuro” o “dark”) e la seconda riguarda l’edizione Community (con il tema “chiaro” o “light”):

 Visual Studio Enterprise 2015 RC su Azure

Visual Studio Community 2015 RC su Azure

 

La cosa ancora più interessante è che queste immagini le ho “scattate” dalle macchine virtuali collegate in remoto e “posizionate” all’interno della piattaforma Azure.

Infatti, ora è possibile creare macchine virtuali con Visual Studio 2015 RC già installato, nelle edizioni Enterprise, Professional e Community. In questo modo, se avete un’abbonamento MSDN, potete sviluppare direttamente su Azure senza installare nulla sulla vostra macchina e con una spesa praticamente azzerata (senza contare il fatto che potete lavorare da qualsiasi postazione, basta avere una buona connessione ADSL).

Cosa c’è di meglio di questo?

Di meglio c’è che su Azure avete anche Visual Studio Online e quindi potete avere anche un ottimo software di controllo sorgente e la possibilità di condivisione con i vostri colleghi e collaboratori!

“F# Italia User Group” su LinkedIn

LinkedIn.com è un social network di tipo professionale: potete avere la vostra pagina gratuita, mettervi in connessione con altri professionisti, offrire o cercare lavoro, pubblicare il vostro “curriculum” LinkedIn, segnalando i lavori che fate o che avete fatto, le vostre competenze, cosa cercate, dove state andando…

Da oggi, su LinkedIn c’è un nuovo gruppo: “F# Italia User Group”:
(
http://www.linkedin.com/groups?home=&gid=6545166&trk=anet_ug_hm)
dove potete iscrivervi, rispondere al primo sondaggio sulle vostre conoscenze sul linguaggio F#, discutere con gli altri programmatori F# e così via.

Tutto questo, rigorosamente in italiano, perché è un gruppo di utenti italiani!

image

(Per rispondere al sondaggio non scrivete la vostra
risposta qui, ma andate su LinkedIn.com!)

Risorse utili su F#

In italiano non c’è quasi nulla, tutti i materiali su F# sono prevalentemente in inglese.

Qui sotto riporto molti link, tra quelli più interessanti che ho trovato nelle mie esplorazioni.

Libri su F# 3.0:

http://shop.oreilly.com/product/0636920024033.do

http://www.apress.com/9781430246503

Il sito “Try F#” di Microsoft Research permette di imparare e di provare il codice direttamente online:

http://www.tryfsharp.org/

Articoli su MSDN Magazine:

http://msdn.microsoft.com/en-us/magazine/ee336127.aspx

http://msdn.microsoft.com/it-it/magazine/cc164244.aspx

http://msdn.microsoft.com/en-us/magazine/gg598923.aspx

Un articolo da MSDN:

http://msdn.microsoft.com/en-us/vstudio//gg634701

Un’altra introduzione con esempi:

http://tomasp.net/articles/fsharp-i-introduction/article.pdf

Esempi di codice:

http://code.msdn.microsoft.com/site/search?f[0].Type=ProgrammingLanguage&f[0].Value=F%23&f[0].Text=F%23&f[1].Type=User&f[1].Value=BrianMcN&f[1].Text=BrianMcN

http://www.codeproject.com/Tips/125781/Reading-Zip-files-in-F

Altro articolo:

http://tomasp.net/blog/functional-overview.aspx

Varie risorse su MSDN:

http://msdn.microsoft.com/en-US/vstudio/hh388569

Articolo su DevX.com:

http://www.devx.com/dotnet/Article/42170

Molte risorse dal blog di Rick Minerich:

http://www.atalasoft.com/cs/blogs/rickm/

Video su F# in Channel9:

http://channel9.msdn.com/search?term=F%23

Risorse sul blog di Tomas Petricek:

http://tomasp.net/

Grafici 3D:

http://vslab.codeplex.com/

http://cvslab.di.unipi.it/vslab/blog/page/Visual-Tutorial.aspx

Quali strumenti si possono utilizzare per programmare in F#?

Per la programmazione in Visual Basic e in C# o per la programmazione sulle piattaforme ASP.NET, Windows 8 e Windows Phone (sempre con i linguaggi VB e C#) abbiamo a disposizione Visual Studio Express 2012 in varie edizioni (for Desktop, for Web, for Windows 8, for Windows Phone).

Purtroppo, per programmare in F# non esiste un’edizione di Visual Studio Express. Uno dei motivi di questa scelta è probabilmente il fatto che F# non è forse (attualmente) la migliore scelta per lavorare sulle UI (interfacce utente), ovvero le schermate visuali con i relativi controlli. F# è invece utilizzabile in modo proficuo nelle modalità “interattiva”, nelle applicazioni Console e per compilare librerie di funzioni (DLL).

Per creare queste tipologie di programmi e librerie, il migliore strumento possibile è Visual Studio 2012. Qualcosa si può fare anche con SharpDevelop, ma solamente in Console (ved. immagine qui sotto). Ovviamente si possono creare programmi anche da NotePad (o simili) e compilando da riga di comando, ma questo modo di lavorare può andare bene solo per piccoli frammenti di codice, non per programmi e librerie più estesi.

image

F#: un linguaggio multi-paradigma

F# utilizza tre paradigmi di programmazione: oltre alla programmazione funzionale, già citata, adotta anche il paradigma della programmazione imperativa e quello della programmazione orientata agli oggetti, permettendo di utilizzarli tutti insieme in modo coerente e ben orchestrato.

Questo approccio multi-paradigma può quindi essere utilizzato con le librerie .NET per eseguire attività di quali l’implementazione di interfacce grafiche (GUI), l’accesso ai dati, la programmazione distribuita e molto altro.

La programmazione funzionale, adottata dal nuovo linguaggio F#, è forse quella che meno è conosciuta da molti programmatori e questo richiede del tempo per impararla e per padroneggiarla, ma rende la programmazione più semplice, per vari motivi: i programmi F# tendono ad essere scritti in modo più formalmente corretto e l’inferenza dei tipi rende i programmi più corti e chiari.

Sebbene sia un linguaggio di derivazione FORTRAN e quindi orientato anche al calcolo scientifico, non è un linguaggio confinato solo nell’ambito scientifico e accademico: può essere utilmente impiegato per migliorare gli algoritmi utilizzati nelle nostre applicazioni e quindi migliorare le prestazioni di queste ultime.

Con F# la programmazione funzionale diventa realmente pratica, facile da imparare e una potente estensione della piattaforma .NET.

Iscriviti

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

Unisciti agli altri 844 follower