Archivi categoria: Novità

Recensione del libro “SQL Server 2012 Bible”

Autori: Adam Jorgensen, Jorge Segarra, Patrick LeBlanc, Jose Chinchilla, Aaron Nelson

ISBN: 978-1-118-10687-7

1416 pages – August 2012

Pagina web: http://eu.wiley.com/WileyCDA/WileyTitle/productCd-1118106873.html

9781118106877_cover.indd

Ho scritto molte recensioni sui libri della serie “Bible” e ancora una volta non posso evitare di sottolineare l’ottima qualità di questi libri, sia dal punto di vista “fisico” (qualità della carta e della rilegatura, impaginazione, uso dei font e delle immagini ecc.), sia dal punto di vista dei contenuti.

In questo caso il libro si focalizza su Microsoft SQL Server 2012, un DBMS di livello professionale e distribuito con vari tipi di licenze. L’edizione SQL Server 2012 Express è addirittura distribuita gratuitamente, con il solo limite di 10 Gb per database, per permetterne l’utilizzo anche per applicazioni più limitate (studio, produttività personale, piccole realtà commerciali e così via).

Il libro è molto ben strutturato: parte dalle nozioni fondamentali, per poi passare alla programmazione con T-SQL e le stored procedure, fino ad arrivare alle informazioni necessarie per l’uso in una azienda, tra le quali anche la sua piattaforma di Business Intelligence.

Nella parte relativa alla progettazione dello schema del database è presente una parte teorica che spiega un po’ di teoria delle basi di dati (chiavi, relazioni, forme normali), assolutamente essenziali per chi non ha pratica con i database, ma anche per chi ha bisogno solo di una semplice “rinfrescata” della memoria.

Infine, se andate nella pagina web (indicata all’inizio di questo articolo), potete trovare tutti gli esempi e i frammenti di codice TSQL.

In conclusione, un libro notevole e fondamentale per chiunque voglia cimentarsi con SQL Server 2012.

Ecco l’elenco dei 59 capitoli del libro:

Part I: Laying the Foundations 1

Chapter 1: The World of SQL Server

Chapter 2: Data Architecture

Chapter 3: Installing SQL Server

Chapter 4: Client Connectivity

Chapter 5: SQL Server Management and Development Tools

Part II: Building Databases and Working with Data

Chapter 6: Introducing Basic Query Flow

Chapter 7: Relational Database Design and Creating the Physical Database Schema

Chapter 8: Data Types, Expressions, and Scalar Functions

Chapter 9: Merging Data with Joins, Subqueries, and CTEs

Chapter 10: Aggregating, Windowing, and Ranking Data

Chapter 11: Projecting Data Through Views

Chapter 12: Modifying Data In SQL Server

Part III: Advanced T-SQL Data Types and Querying Techniques

Chapter 13: Working with Hierarchies

Chapter 14: Using XML Data

Chapter 15: Executing Distributed Queries

Part IV: Programming with T-SQL

Chapter 16: Programming with T-SQL

Chapter 17: Developing Stored Procedures

Chapter 18: Building User-Defi ned Functions

Part V: Enterprise Data Management

Chapter 19: Confi guring SQL Server

Chapter 20: Policy Based Management

Chapter 21: Backup and Recovery Planning

Chapter 22: Maintaining the Database

Chapter 23: Transferring Databases

Chapter 24: Database Snapshots

Chapter 25: Asynchronous Messaging with Service Broker

Chapter 26: Log Shipping

Chapter 27: Database Mirroring

Chapter 28: Replicating Data

Chapter 29: Clustering

Chapter 30: Confi guring and Managing SQL Server with PowerShell

Chapter 31: Managing Data in Windows Azure SQL Database

Part VI: Securing Your SQL Server

Chapter 32: Authentication Types in SQL Server

Chapter 33: Authorizing Securables

Chapter 34: Data Encryption

Chapter 35: Row-Level Security

Part VII: Monitoring and Auditing

Chapter 36: Creating Triggers

Chapter 37: Performance Monitor and PAL

Chapter 38: Using Profi ler and SQL Trace

Chapter 39: Wait States

Chapter 40: Extended Events

Chapter 41: Data Change Tracking and Capture

Chapter 42: SQL Audit

Chapter 43: Management Data Warehouse

Part VIII: Performance Tuning and Optimization

Chapter 44: Interpreting Query Execution Plans

Chapter 45: Indexing Strategies

Chapter 46: Maximizing Query Plan Reuse

Chapter 47: Managing Transactions, Locking, and Blocking

Chapter 48: Data Compression

Chapter 49: Partitioning

Chapter 50: Resource Governor

Part IX: Business Intelligence

Chapter 51: Business Intelligence Database Design

Chapter 52: Building, Deploying, and Managing ETL Workflows in Integration Services

Chapter 53: Building Multidimensional Cubes in Analysis Services with MDX

Chapter 54: Confi guring and Administering Analysis Services

Chapter 55: Authoring Reports in Reporting Services

Chapter 56: Configuring and Administering Reporting Services

Chapter 57: Data Mining with Analysis Services

Chapter 58: Creating and Deploying BI Semantic Models

Chapter 59: Creating and Deploying Power View Reports

Recensione del libro “Access 2013 Bible”, Wiley.com

http://eu.wiley.com/WileyCDA/WileyTitle/productCd-1118490355.html
Michael Alexander, Dick Kusleika
ISBN: 978-1-118-49035-8
1296 pages
May 2013

clip_image001

I libri della collana “Bible” sono il migliore acquisto che si possa fare nell’ambito del software, perché contengono tutte, ma proprio tutte, le informazioni utili al neofita come all’esperto.

Nel caso di “Access 2013 Bible”, nelle quasi 1300 pagine di cui è composto troviamo argomenti che approfondiscono la conoscenza dei vari oggetti e delle numerose funzionalità di Access 2013, per permetterci di utilizzare questo prodotto nel migliore dei modi.

Il neofita vi troverà molte informazioni utili per iniziare a utilizzarlo, mentre l’esperto vi troverà sicuramente molti trucchi e suggerimenti per strutturare meglio e per arricchire di funzionalità le proprie applicazioni di database Access.

Naturalmente molti capitoli sono dedicati alla programmazione, utilizzando le Macro di Access ma anche il linguaggio VBA. L’accesso ai dati di Access e di SQL Server è realizzato con le librerie ADO e DAO, in modo da soddisfare qualsiasi esigenza. Le informazioni fornite permettono di realizzare delle vere e proprie applicazioni eseguibili per mezzo di Access stesso o del runtime gratuito (scaricabile gratuitamente dal seguente indirizzo: http://www.microsoft.com/it-it/download/details.aspx?id=39358).

Non manca una parte dedicata all’interazione di Access con i servizi di SharePoint, per chi ha la necessità di creare applicazioni aziendali di alto livello.

Nella pagina web (http://www.wiley.com/go/access2013bible) sono presenti:

– la correzione al capitolo 14 pagine 411-414
– gli esempi del libro
– n. 3 database di esempio

In conclusione, questo è un libro che, senza dubbio, non può mancare nella “cassetta degli attrezzi” dell’utilizzatore e dello sviluppatore di database Access.

Ecco quindi l’elenco dei 36 capitoli del libro (più 4 appendici):

Part I: Access Building Blocks  1

Chapter 1: An Introduction to Database Development  3

Chapter 2: Getting Started with Access  19

Part II: Understanding Access Tables 31

Chapter 3: Creating Access Tables  33

Chapter 4: Understanding Table Relationships  89

Chapter 5: Working with Access Tables 129

Chapter 6: Importing and Exporting Data 167

Chapter 7: Linking to External Data 201

Part III: Working with Access Queries 227

Chapter 8: Selecting Data with Queries 229

Chapter 9: Using Operators and Expressions in Access 261

Chapter 10: Going Beyond Select Queries 301

Part IV: Analyzing Data in Access  337

Chapter 11: Transforming Data in Access 339

Chapter 12: Working with Calculations and Dates 363

Chapter 13: Performing Conditional Analyses 389

Chapter 14: Fundamentals of Using Access SQL 407

Chapter 15: Subqueries and Domain Aggregate Functions 427

Chapter 16: Running Descriptive Statistics in Access 451

Part V: Working with Access Forms and Reports 469

Chapter 17: Creating Basic Access Forms 471

Chapter 18: Working with Data on Access Forms 509

Chapter 19: Working with Form Controls 541

Chapter 20: Presenting Data with Access Reports 575

Chapter 21: Advanced Access Report Techniques 631

Part VI: Access Programming Fundamentals  675

Chapter 22: Using Access Macros 677

Chapter 23: Getting Started with Access VBA 715

Chapter 24: Mastering VBA Data Types and Procedures 757

Chapter 25: Understanding the Access Event Model 799

Chapter 26: Debugging Your Access Applications 821

Part VII: Advanced Access Programming Techniques 853

Chapter 27: Accessing Data with VBA Code 855

Chapter 28: Advanced Data Access with VBA 897

Chapter 29: Integrating Access and SQL Server 915

Chapter 30: Customizing the Ribbon 957

Chapter 31: Preparing Your Access Application for Distribution 993

Part VIII: Access and Windows SharePoint Services   1037

Chapter 32: Understanding Windows SharePoint Services 1039

Chapter 33: Integrating Access with SharePoint 1045

Chapter 34: Understanding Access Services 1059

Chapter 35: Deploying Access Applications to SharePoint 1067

Chapter 36: Using Access Data Macros 1089

Part IX: Appendixes 1109

Appendix A: Access 2013 Specifications 1111

Appendix B: Optimizing Access Applications 1117

Appendix C: Understanding Query Performance and Database Corruption 1139

Appendix D: Function Reference for Data Analysts 1147

Visual Basic 2015: commenti e istruzioni su più righe

Ecco un’altra novità molto interessante!

Fino alla versione 2013, in Visual Basic non si potevano inserire commenti in linea, all’interno di istruzioni suddivise in più righe con la “Implicit Line Continuation”. Facciamo un esempio, questo è il codice che elenca tutti i processi attivi, li ordina e li mostra in una finestra messaggio:

Dim elenco = From processo In Process.GetProcesses
Select processo.ProcessName
Order By ProcessName
Dim stringa As String = “”
For Each proc In elenco
stringa &= proc & vbCrLf
Next
MsgBox(stringa)

Ora possiamo aggiungere commenti in linea così:

Dim elenco = From processo In Process.GetProcesses
Select processo.ProcessName ‘ seleziona il nome del processo
             Order By ProcessName ‘ ordina i nomi
Dim stringa As String = “”
For Each proc In elenco
stringa &= proc & vbCrLf
Next
MsgBox(stringa)

Il risultato che otterremo sarà invariato, ma avremo maggiore chiarezza nel codice.

Introduzione a F#

Nel numero di febbraio 2011 della rivista ioProgrammo avevo pubblicato un articolo nel quale spiegavo come è possibile utilizzare una DLL, scritta e compilata in F#, all’interno di una soluzione Visual Basic. In quella occasione ho utilizzato una DLL open source (“Excel Financial functions for .NET”: http://bit.ly/hRBhCy), in alternativa all’utilizzo dei metodi disponibili nel namespace Microsoft.VisualBasic.Financial, per calcolare il tasso di interesse e l’importo totale da pagare per un prestito.

Purtroppo, l’attuale crisi economica ha reso quanto mai attuale l’idea di creare programmi di questo tipo, anche se ottenere un prestito è sempre più arduo.

Lasciamo comunque da parte questi pensieri tristi e dedichiamoci a qualcosa di più interessante e utile: magari potreste trovare il modo di “sbarcare il lunario” vendendo librerie di funzioni scritte in F#.

In questo articolo vedremo alcuni aspetti di F# in modo più approfondito, rispetto all’articolo che vi ho citato.

NOTA: potete scaricare i progetti presentati in questo articolo da questo indirizzo.

Un po’ di storia

La programmazione funzionale non è una novità di questi giorni: è un paradigma di programmazione che esiste almeno da 30 anni. Purtroppo non è stato adeguatamente supportato dai canali commerciali per vari motivi. Il mancato supporto deriva dalla convinzione che la programmazione funzionale sia adatta principalmente a problemi di carattere matematico, scientifico o finanziario. Questa concezione ha fatto sì che la programmazione funzionale fosse finora relegata ad àmbiti di tipo accademico, in laboratori di ricerca o in grandi istituti di statistica e di finanza (banche ecc.).

La situazione è cambiata da qualche anno, cioè da quando Microsoft ha deciso di investire sul linguaggio F# nei suoi laboratori di ricerca (Microsoft Research). Don Syme, l’inventore di F#, ha definito i costrutti del linguaggio partendo dalla sintassi dei precedenti linguaggi funzionali (OCaml, ML…) e aggiungendo le strutture che permettono di utilizzare istruzioni della programmazione imperativa e istruzioni della programmazione orientata agli oggetti, in perfetta integrazione con il .NET Framework.

Queste aggiunte hanno permesso a F# di uscire dai laboratori di ricerca per diventare un linguaggio multi-paradigma, utilizzabile anche in applicazioni commerciali.

Cosa fa F# che non fanno Visual Basic e C#?

F# non utilizza il non-valore Null e quindi il codice F# puro non può incorrere in eccezioni NullReferenceException.

In realtà è ancora possibile ottenere un NullReferenceException, ma solo in casi rari e particolari: utilizzando librerie VB/C#, tipi definiti in VB/C#, il valore null letterale e pochi altri casi.

Tuttavia il codice F# abbatte drasticamente i null utilizzati, rispetto ad analoghe applicazioni scritte in VB/C#, e di conseguenza la probabilità di ottenere un NullReferenceException è estremamente rara.

Un altro aspetto che rende F# uno dei linguaggi più robusti mai esistiti: è un linguaggio fortemente tipizzato ed è un linguaggio statico (non dinamico). Il compilatore, quindi, conosce in anticipo la maggior parte delle situazioni che possono portare a un’eccezione ed emette gli opportuni errori o avvertimenti.

L’ultimo aspetto su cui voglio soffermarmi è la straordinaria concisione di questo linguaggio, senza che però venga persa la chiarezza delle istruzioni e del flusso di esecuzione.

F# utilizza l’inferenza dei tipi per non dover dichiarare esplicitamente il tipo di dato di una “variabile” (o per meglio dire: di un “identificatore”, dato che le variabili utilizzate in F# sono immutabili, salvo che non venga indicato diversamente e in modo esplicito con la parola riservata mutable).

I blocchi di codice e i cicli non richiedono una apertura e una chiusura: è sufficiente aggiungere uno o più spazi di indentazione dove è opportuno. Niente parentesi graffe, niente punti e virgola, niente parole chiave di chiusura blocco (End …), niente di niente: solo ritorni a capo e spaziatura differente all’inizio di ogni riga di codice.

Tutto questo riduce enormemente il codice da scrivere, con la conseguenza di ridurne la complessità visiva, il tempo di digitazione e il tasso di errore (meno cose ci sono dentro, meno cose si rompono). Quello che aumenta è la semplicità, la produttività, la robustezza e la sicurezza.

F# linguaggio del futuro

Un’aspetto interessante di F# che sta diventando evidente è il fatto che questo linguaggio sia stato un precursore di alcune funzionalità che sono state poi implementate in Visual Basic e in C#.

LINQ, per esempio, nasce come un’estensione del .NET Framework con una natura prettamente funzionale.

In F# sono state sviluppate tecniche che sono state implementate successivamente anche in VB e in C#: per esempio la programmazione parallela, le funzioni asincrone, l’inferenza dei tipi.

Insomma, pare che il panorama della programmazione si stia gradualmente orientando verso il paradigma della programmazione funzionale, proprio per i vantaggi che questo può portare nella produttività e nella robustezza delle nostre applicazioni.

Conoscere F#, quindi, permette di precorrere i tempi ed essere sempre un passo avanti agli altri.

Cui prodest? A chi giova?

Dopo aver esposto “vita, morte e miracoli” di F#, sicuramente qualcuno si chiederà: “ma alla fine, dove posso utilizzare F#, per quali tipi di applicazioni?”.

Per quanto riguarda le piattaforme, F# è stato rilasciato anche con licenza open source e quindi può essere utilizzato in applicazioni Windows, ma anche in Linux (con Mono). Non disdegna il web, dato che può essere utilizzato in applicazioni ASP.NET e su applicazioni Windows Azure, né le applicazioni mobili, potendo essere utilizzato in applicazioni per Windows Phone.

Possiamo utilizzare all’interno di una finestra di Visual Studio (F# Interactive), direttamente da una “finestra DOS” (con gli eseguibili fsi e fsc), possiamo utilizzarlo come linguaggio di scripting, in applicazioni in puro F# o possiamo creare librerie F# da compilare in DLL e utilizzare in tutti gli altri ambiti (in applicazioni Visual Basic e C#, in ASP.NET, in Windows Azure, in Windows Phone ecc.). Insomma, la versatilità di questo linguaggio è enorme.

Ci sono alcuni ambiti in cui F# non è molto forte: se volete creare controlli visuali o interfacce utente, è meglio se vi orientate verso VB o C#. In ogni caso l’integrazione tra tutti i linguaggi .NET rende semplice creare applicazioni in linguaggio misto, dove F# fa la parte del leone nell’ottimizzare librerie di funzioni e VB/C# la fanno nella gestione di interfacce e controlli visuali.

La cassetta degli attrezzi

Purtroppo non è mai stata rilasciata una edizione Express di Visual F#, quindi dobbiamo scegliere tra una rosa di possibilità più limitata.

F# è naturalmente uno dei linguaggi che può essere installato durante l’installazione di Visual Studio 2012/2013 in versione completa (Professional o Ultimate).

Un’alternativa è quella di utilizzare un’IDE open source e gratuito come SharpDevelop: tra i modelli di progetti che possono essere creati ci sono anche le applicazioni Console in F#. Tuttavia, se proverete a creare un progetto di questo tipo otterrete un errore, perché dovete installare F#. Quest’ultimo potete trovarlo in licenza open source, quindi scaricarlo e installarlo, ma con un piccolo handicap: nel momento in cui sto scrivendo questo articolo la versione disponibile in open source è la 2.0, mentre con Visual Studio 2013 la versione disponibile è la 3.1 (in Visual Studio 2012 è presente la versione 3.0).

Ecco quindi una possibilità che possiamo sfruttare per poter lavorare in F# senza comprare Visual Studio:

1. installate “Visual Studio Express 2012 for Web” (http://bit.ly/1bgM3m7);

2. poi installate “F# Tools for Visual Studio Express 2012 for Web” (http://bit.ly/17Bf3Rx).

L’installazione di quest’ultimo software viene preceduta, in modo automatico e con un minimo intervento da parte dello sviluppatore, dall’installazione di “Microsoft Web Platform Installer”.

Microsoft Web Platform Installer è un software che ci permette di installare e aggiornare vari software e strumenti di sviluppo: per esempio fornisce i tool di supporto per Windows Azure, i tool di supporto per SQL Server (per esempio la Compact Edition), applicazioni CMS (come DotNetNuke, Orchard ecc.), blog, wiki e molto altro.

Dopo che avrete completato l’installazione di “F# Tools for Visual Studio Express 2012 for Web” potrete creare librerie F# e applicazioni web (ASP.NET e Windows Azure), sfruttando anche le grandi possibilità fornite dal linguaggio F#.

Bando alle ciance!

In questo articolo introduttivo su F# ho dovuto inquadrare un po’ qual è la sua storia, a cosa serve e come possiamo utilizzarlo. Dopo questa lunga trattazione su F#, sperando di non avervi annoiati, passo a qualche semplice esempio pratico.

In questo articolo affronteremo le seguenti tematiche, ciascuna con un suo esempio pratico:

  • F# Interactive in una finestra Prompt dei comandi;

  • F# Interactive in Visual Studio;

  • Applicazione interamente in F#;

  • Esecuzione di parti del programma;

  • Librerie in F#;

  • Windows Form con F#;

  • Applicazione VB/F# e C#/F# (con WPF);

  • Applicazione ASP.NET con F#

F# Interactive in una finestra Prompt dei comandi

Possiamo utilizzare F# in molti modi diversi. Uno di questi modi è quello di aprire una finestra del Prompt dei comandi (se avete Visual Studio potete aprire la versione specifica “per gli sviluppatori per Visual Studio 2012/2013”) e digitare fsi.

Una volta aperta la finestra del prompt dei comandi, possiamo digitare ed eseguire le istruzioni F# in modo interattivo (fsi = “FSharp Interactive”).

Per esempio possiamo scrivere l’istruzione

#help;;

per ottenere una breve guida su alcuni comandi che possono essere utilizzati, possiamo fare delle assegnazioni ed eseguire delle somme con la funzione let o “stampare” a video delle stringhe con le istruzioni printfn o printf.

L’istruzione printfn va a capo dopo aver visualizzato la stringa, mentre printf mantiene il cursore alla fine della stringa, così che un’eventuale altra stringa che viene stampata, viene posizionata concatenandola a quella precedente. Questo comportamento è perfettamente corrispondente all’utilizzo dei metodi Console.Write() e Console.WriteLine().

Nella Figura 1 potete vedere alcune istruzioni eseguite nella finestra del prompt dei comandi.

clip_image002

Noterete sicuramente che per eseguire le istruzioni è necessario aggiungere, alla fine della riga, un doppio carattere di punto e virgola (;;). Questo simbolo è necessario per far capire a FSharp che l’istruzione è terminata. Senza questo simbolo speciale possiamo continuare la scrittura dell’istruzione sulla riga successiva, almeno finché non abbiamo inserito il simbolo di fine istruzione. Notate però che l’utilizzo del simbolo “;;” di fine istruzione è necessario solamente nella modalità interattiva, mentre nei programmi compilati questa necessità non c’è, perché il compilatore è in grado di capire quando un’istruzione è terminata e quando inizia l’istruzione successiva. Come vi abbiamo già fatto notare, questa “intelligenza” del compilatore deriva dalla spaziatura delle istruzioni (indentazione) e dalla conoscenza di tutto il codice già inserito nel progetto.

L’istruzione let permette di assegnare un valore letterale o un risultato di una funzione o di un’espressione.

Notate anche che fsi definisce il tipo di dato restituito: in due casi abbiamo due int (Integer), mentre nell’ultimo caso abbiamo uno unit = (), perché la funzione printfn non restituisce alcun valore. Lo unit viene assegnato automaticamente a una variabile di nome it: questo è il nome predefinito che viene utilizzato quando non viene definita espressamente una variabile.

Degno di nota è anche il fatto che l’identificatore somma mantiene il valore assegnato nella prima istruzione, permettendo di utilizzarne il valore anche nella seconda istruzione. Questo significa che lo stato delle assegnazioni viene mantenuto durante tutta la sessione di F# Interactive, permettendo di scrivere ed eseguire un programma in modalità effettivamente interattiva.

Cosa succede se sbagliamo a digitare un’istruzione? Lo potete vedere nella Figura 2.

clip_image004

F# Interactive in Visual Studio

Una modalità di esecuzione di F# Interactive molto più comoda è quella che possiamo ottenere lavorando all’interno di Visual Studio.

Per lavorare con la finestra di F# Interactive non è necessario creare un progetto F# né altri tipi di progetto: è sufficiente selezionare la voce di menu Visualizza > Altre Finestre > F# Interactive, oppure basta premere molto più semplicemente la combinazione di tasti CTRL+ALT+F.

Come potete vedere nella Figura 3, possiamo eseguire le stesse istruzioni che abbiamo eseguito nel esempio precedente, esattamente con la stessa modalità (un’istruzione alla volta) e sostanzialmente con la stessa “esperienza utente”.

clip_image005

La finestra F# Interactive di Visual Studio e l’utilizzo di fsi.exe in Console sono indubbiamente utili per sperimentare singole istruzioni o semplici sequenze di istruzioni, specialmente quando avete appena iniziato a prendere confidenza con il linguaggio F#.

Ad un certo punto, però, sarà necessario andare un po’ oltre per poter sfruttare ulteriori vantaggi dall’ambiente di Visual Studio, come la possibilità di scrivere programmi più complessi e utilizzare le funzionalità di debug e di compilazione di programmi o di librerie di funzioni.

Il passo successivo, quindi, sarà costituito dalla creazione di programmi di tipo Applicazione F#.

Applicazione F#

Un’applicazione F# si crea semplicemente come tutti gli altri tipi di applicazione in Visual Studio: nel pannello sinistro della Start page selezionate Nuovo progetto oppure dal menu principiale selezionate File > Nuovo > Progetto. All’apparizione della finestra Nuovo progetto, selezionate il nodo Modelli > Visual F#, poi selezionate la voce Applicazione F# e compilate le informazioni nella parte inferiore della finestra: nome dell’applicazione, percorso, nome della soluzione, eventuale inclusione al controllo del codice sorgente (per esempio Team Foundation Server, Team Foundation Service sul web o anche all’analogo servizio CodePlex per progetti open source) e l’eventuale creazione di una sottodirectory per il progetto.

Nel file Program.fs troveremo il seguente codice di esempio:

#light

// Ulteriori informazioni su F# all'indirizzo http://fsharp.net
// Per ulteriori informazioni, vedere il progetto 'Esercitazione su F#'.

[<EntryPoint>]
let main argv =
printfn "%A" argv
0 // restituisci un intero come codice di uscita

Possiamo cancellare l’intero codice e scrivere quanto segue:

// esempio: mdgIntroFSharp01

open System

let mutable somma = 3 + 2

somma <- somma + 4

printfn("la somma di (3+2)+4 è uguale a 9")

let fine = Console.ReadLine()

Notate che abbiamo tolto la direttiva #light: lo possiamo fare perché l’impostazione di default è #light on. Tuttavia se volete maggiore chiarezza, potete lasciare tranquillamente tale direttiva nel codice (male non fa).

L’istruzione open System equivale all’istruzione import di Visual Basic: serve per utilizzare le classi e i metodi del relativo namespace senza dover necessariamente utilizzare utilizzare l’intera gerarchia di nomi: nel nostro esempio, cioè, possiamo utilizzare Console.ReadLine invece di System.Console.ReadLine.

La seconda istruzione (let mutable somma = 3 + 2) è simile all’esempio precedente, ma con l’aggiunta della parola riservata “mutable”. Questa parola permette di rendere l’identificatore somma una variabile modificabile. Per una questione intrinseca di F#, infatti, gli identificatori non sono variabili, nel senso che non permettono normalmente di modificare il loro contenuto, una volta che sono state definite e che gli è stato assegnato un valore. La mancanza della parola mutable nella seconda istruzione comporterebbe un errore nella terza istruzione, dato che il compilatore di F# segnalerebbe il duplicato della definizione dell’identificatore somma.

Nella terza istruzione, a questo punto non possiamo più utilizzare la funzione let, né possiamo utilizzare il simbolo di assegnazione (=). F# permette di assegnare a una variabile il valore di un’espressione, utilizzando un operatore di assegnazione inedito per gli sviluppatori Visual Basic e C#: il simbolo “freccia a sinistra” realizzato con due caratteri, cioè il simbolo “minore di” e il trattino (<-). Se ci ragioniamo un attimo, il significato è evidente: calcoliamo il valore dell’espressione “somma + 4” e lo assegniamo alla variabile posta alla sinistra dell’istruzione, cioè “somma”, utilizzando una freccia.

La quarta istruzione è identica a quella che abbiamo scritto nell’esempio F# Interactive.

Qui però troviamo una quinta istruzione che non avevamo utilizzato prima e che potrebbe risultare incomprensibile (let fine = Console.ReadLine()).

Il metodo Console.ReadLine() è utilizzato per evitare che la finestra della Console sparisca subito, dopo aver eseguito le istruzioni precedenti, rendendo difficile, se non impossibile, la lettura del contenuto della finestra. Con la quinta istruzione, quindi, il programma attende che l’utente prema il pulsante Invio prima di chiudere la finestra.

Questa è una tecnica che è utilizzata anche nei programmi Visual Basic e C#, quando sono progettati per essere eseguiti nella Console. La situazione, qui, è un po’ diversa perché il metodo ReadLine restituisce un valore che deve essere comunque assegnato a qualche variabile, anche se in questo caso non ci interessa leggere cosa ha inserito l’utente. Nelle applicazioni VB e C#, invece, possiamo invocare il metodo Console.ReadLine() senza assegnare il risultato a una variabile. Abbiamo quindi definito un identificatore “fine”, destinato a contenere la risposta dell’utente, sia essa una semplice pressione del tasto Invio oppure una stringa inserita prima della pressione di tale tasto.

Qui effettivamente l’assegnazione a un’identificatore non ha molto senso e rende l’istruzione un po’ strana. Possiamo quindi modificare l’istruzione per far sì che la risposta dell’utente venga ignorata, scrivendola in questo modo:

Console.ReadLine() |> ignore

In questo caso eseguiamo il metodo Console.ReadLine() ottenendo una risposta che viene “inviata”, con l’operatore di “pipe” (composto dalla barra verticale e da un simbolo “maggiore di”), verso la parola riservata ignore che indica che il valore restituito sarà ignorato.

Bisogna entrare nella mentalità di F# e dei linguaggi funzionali in generale: tutte le istruzioni devono essere delle funzioni che restituiscono un valore e tutti i valori restituiti devono essere in qualche modo utilizzati dal programma, oppure lo sviluppatore deve indicare espressamente al compilatore che un determinato valore non deve essere utilizzato, ovvero che deve essere ignorato.

Esecuzione di parti del programma

Un aspetto interessante dell’ambiente di sviluppo di Visual Studio è dato dalla possibilità di eseguire una unica istruzione oppure un blocco di istruzioni di un programma, senza dover necessariamente avviare l’esecuzione dell’intero programma.

È molto semplice: è sufficiente selezionare una o più istruzioni e premere la combinazione di tasti ALT+INVIO. Per esempio selezionate l’istruzione seguente:


let mutable somma = 3 + 2
somma <- somma + 4

e poi premete la combinazione di tasti che vi abbiamo indicato.

Vedrete che si aprirà automaticamente la finestra F# Interactive e sarà eseguito il blocco di istruzioni che avevate selezionato. Ecco il risultato per il nostro esempio:


val mutable somma : int = 9
val it : unit = ()

Questa modalità di esecuzione parziale è molto utile per testare piccole parti del programma, quando non vogliamo creare un progetto semplificato per fare degli esperimenti separati dallo sviluppo della nostra applicazione.

Libreria F#

Per sperimentare la creazione di una libreria F#, come primo esempio vediamo un’applicazione F# (soluzione mdgIntroFsharp02 e progetto con lo stesso nome) che utilizza un progetto di tipo Libreria F#. I passi da seguire sono i seguenti:

1. create una nuova soluzione con un progetto di tipo Applicazione F#, così come avevamo fatto nel primo esempio di applicazione di questo articolo;

2. cliccate con il tasto destro del mouse sul nome della soluzione (mdgIntroFsharp02) e selezionate la voce Aggiungi > Nuovo progetto;

3. nella scheda Visual F# selezionate il template Libreria F#, verificate che il percorso sia corretto (deve trovarsi preferibilmente nella sottocartella della soluzione, come il progetto principale) e indicate un nome di progetto (nel nostro caso abbiamo lasciato il nome predefinito Library1) e confermate premendo il tasto OK.

Vedrete che automaticamente verrà aggiunto il seguente codice:

namespace Library1

type Class1() =
   member this.X = "F#"

Il codice definisce un namespace di nome Library1, una classe di nome Class1 e una proprietà di nome X e contenente la stringa “F#”. Proviamo a modificare la libreria, sostituendo il codice con qualcosa di relativamente più utile:


// esempio: mdgIntroFsharp02
namespace Library1

type Stampa(x: string) =
static member testo(x) =
"Testo: " + x

Il codice è abbastanza banale: permette di restituire una stringa passata come parametro, concatenandola con il prefisso “Testo: ” (con uno spazio dopo i due punti, per una questione di esposizione visiva del testo). La sua banalità, però, ci permette di utilizzare questo semplice codice per vedere come può essere utilizzata la libreria in modo estremamente facile.

Alcune precisazioni: la prima riga contiene la dichiarazione del namespace Library1 a cui appartiene la libreria. Poi abbiamo dichiarato un tipo (cioè una classe) di nome Stampa. A seguire abbiamo dichiarato un metodo statico di nome testo che restituisce la stringa modificata.

Dopo aver scritto il codice, compilate il progetto Library1, cliccando con il tasto destro del mouse sul suo nome e selezionando Compila. Questo ci servirà per poter utilizzare la libreria compilata dal progetto principale.

Cliccate ora, sempre con il tasto destro del mouse, sul nodo Riferimenti del progetto mdgIntroFsharp02 e selezionate Aggiungi riferimento. Apparirà una finestra per la selezione dei riferimenti: cliccate sulla sezione Soluzione e selezionate la voce Library1, poi confermate premendo OK.

clip_image002[5]

Aprite il file Program.fs del progetto mdgIntroFsharp02 e modificate il codice presente nell’editor con il seguente codice:

// esempio: mdgIntroFsharp02
open System
open Library1

let testo = Stampa.testo("Ciao mondo!")
printfn "%s" testo |> ignore
Console.ReadLine() |> ignore
()

Anche qui è bene specificare alcune cose, per comprendere bene il codice.

Le prime due istruzioni aprono o, per meglio dire, “includono” le librerie dei namespace System (del .NET Framework) e Library1 (cioè quella creata da noi).

L’istruzione let invoca il metodo Stampa.testo, passando come parametro una stringa da modificare.

La successiva istruzione stampa la stringa nella Console, segnalando che non ci interessa restituire un valore (vi ricordiamo che la “pipe” |> ignore è necessaria nella programmazione funzionale, quando non vogliamo utilizzare un valore di ritorno).

Poi abbiamo inserito un’istruzione in grado di leggere una stringa di input, con il solo scopo di “fermare” la chiusura della finestra della Console. Anche qui non ci interessa restituire un valore, né ci interessa cosa viene inserito dall’utente, bastando anche un semplice invio.

L’ultima riga può suscitare qualche curiosità: una coppia di parentesi tonde (). Questo è uno unit, cioè il valore/non-valore di cui abbiamo già parlato e che serve a indicare che il programma non restituisce valori significativi al chiamante o all’utente. Possiamo considerarlo un simbolo di chiusura del programma, anche se in alcuni casi potrebbe essere utile indicare un vero valore, per esempio un codice numerico per indicare una condizione di errore che si è verificata oppure un valore che rappresenta un risultato.

Dopo aver compilato l’intera soluzione, provate ad eseguire il programma: dovrebbe apparire ancora una volta la finestra del prompt dei comandi con il testo “Ciao mondo!”. La finestra resterà in attesa della vostra pressione di un tasto qualsiasi, dopodiché il programma terminerà chiudendo anche tale finestra.

Windows Form con F#

Un aspetto che emerge nella programmazione F#, all’interno dell’ambiente di sviluppo Visual Studio, è la scarsa, per non dire nulla, propensione di F# alla progettazione visuale.

Sebbene spesso si legga “Visual F#” nella documentazione disponibile, di “Visual” c’è ben poco, perché F# non è progettato per fornire supporto al trascinamento di elementi nell’interfaccia utente.

Questo non significa, però, che non si possa sviluppare un’applicazione F# in grado di visualizzare delle finestre con alcuni componenti visuali: semplicemente dobbiamo farlo da codice.

Nel prossimo esempio vedremo come si può creare un’applicazione Windows Form con F#, scrivendo del codice che, tutto sommato, non è molto complesso.

L’obiettivo che ci proponiamo di ottenere è quello di definire una finestra Windows Form, di posizionarvi un pulsante e di definire un evento Click, associato al pulsante stesso, per far apparire un messaggio.

// esempio: mdgIntroFsharp03
open System
open System.Drawing
open System.Windows.Forms
open System.Runtime.InteropServices // necessario per le API di Windows
 
// definizione delle API di Windows:
[<DllImport("kernel32.dll")>] extern System.IntPtr GetConsoleWindow()
[<DllImport("user32.dll")>] extern bool ShowWindow(System.IntPtr, int)

// riferimento all'handle della finestra “Prompt dei comandi”:
let h = GetConsoleWindow()

// la finestra “Prompt dei comandi” viene nascosta (0=hide):
ShowWindow(h, 0) |> ignore

// definizione della finestra Windows Form:
let form = new Form(Text="FsharpForm", Visible=true, Width=300, Height=300)

// definizione di un pulsante:
let btn1 = new Button()
btn1.Text <- "ClickME"
btn1.Location <- new Point(20, 20)

// aggiunta del pulsante all'insieme dei controlli del form:
form.Controls.Add(btn1)

// definizione del metodo da eseguire con l'evento Click del pulsante:
let btnClick _ =
MessageBox.Show("Click!") |> ignore

// aggiunta dell'evento Click:
let _ = btn1.Click.Add(btnClick)

// punto di ingresso dell'applicazione, con definizione del
// modello di threading COM come apartment a thread singolo:
[<STAThread>]
Application.Run(form)

Il codice è sufficientemente commentato, per cui non dovrebbero esserci problemi di comprensione sul suo funzionamento.

Vogliamo solamente attirare la vostra attenzione sulle istruzioni iniziali che servono a nascondere la finestra “Prompt dei comandi”. Infatti, se vogliamo utilizzare Windows Form come interfaccia utente, la vecchia “finestra DOS” è inutile e antiestetica, quindi vale la pena di aggiungere qualche istruzione per nasconderla.

Dopo aver avviato l’applicazione e cliccato sul pulsante, otterrete un risultato simile a quello che potete vedere nella Figura 5.

clip_image009

Applicazione VB/F# e C#/F#

Se non volete perdere tempo a definire l’interfaccia utente con F#, potete optare per la combinazione VB/F# oppure per quella C#/F#.

In questo caso, il progetto principale fornisce la struttura base dell’applicazione, sia dal punto di vista visuale, sia da quello del “comportamento” (eventi, interazione con l’utente ecc.), mentre tutta la logica e gli algoritmi più importanti vengono delegati a una libreria F#.

Questo fatto permette di utilizzare tecnologie visuali più recenti per la progettazione dell’interfaccia utente, come WPF o Silverlight.

Dato che in questo articolo abbiamo già visto come si scrive una libreria F#, in questo contesto non ci resta che definire l’interazione tra il codice VB e il codice F#.

Per prima cosa creiamo un progetto Visual Basic, utilizzando un template WPF, e lo chiamiamo mdgIntroFsharp04. Poi aggiungiamo un altro progetto, questa volta di tipo Libreria F#, denominato Library1.

Nella libreria F# inseriamo ancora una volta il codice seguente:

namespace Library1

type Stampa(x: string) =
static member testo(x) =
"Testo: " + x

Dopo aver compilato singolarmente il progetto della libreria F#, aggiungiamo il riferimento a Library1 nel progetto Visual Basic, così come abbiamo già visto negli esempi precedenti.

Quello che ci interessa di più, in questo momento, è la parte relativa al progetto Visual Basic.

Nella finestra del progetto principale aggiungiamo due caselle di testo e un pulsante.

La prima casella servirà per permettere all’utente di inserire una stringa di testo, mentre la seconda casella di testo mostrerà il risultato della funzione Stampa della libreria F#. Il pulsante, naturalmente, permetterà di chiamare la funzione e di mostrare il risultato.

Prima di tutto definiamo l’interfaccia utente con il seguente codice XAML:

<Window x:Class="MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="MainWindow" Height="316" Width="525">
<Grid>
<TextBox x:Name="txtTestoInserito"
HorizontalAlignment="Left"
Height="56"
Margin="10,23,0,0"
TextWrapping="Wrap"
VerticalAlignment="Top"
Width="497"
FontSize="36"/>
<TextBox x:Name="txtRisultato"
HorizontalAlignment="Left"
Height="54"
Margin="10,211,0,0"
TextWrapping="Wrap"
VerticalAlignment="Top"
Width="497"
FontSize="36"/>
<Button
x:Name="btnCallStampa"
Content="Chiama funzione F#"
HorizontalAlignment="Left"
VerticalAlignment="Top"
Width="361"
Margin="89,111,0,0"
Height="62"
FontSize="36"/>
</Grid>
</Window>

Il codice Visual Basic relativo al gestore dell’evento Click del pulsante è invece il seguente:

// esempio: mdgIntroFsharp04
Class MainWindow
Private Sub btnCallStampa_Click(
sender As Object, e As RoutedEventArgs) _
Handles btnCallStampa.Click
txtRisultato.Text =
Library1.Stampa.testo(txtTestoInserito.Text)
End Sub
End Class

Potete vedere l’applicazione funzionante nella Figura 6.

clip_image011

L’applicazione C# è sostanzialmente identica: cambia solamente il codice del gestore dell’evento Click che troviamo nel seguente frammento:

// esempio: mdgIntroFsharp05
using System;
using System.Text;
using System.Windows;
using System.Windows.Controls;

namespace mdgIntroFsharp05
{
/// <summary>
/// Logica di interazione per MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
}

private void btnCallStampa_Click(
object sender, RoutedEventArgs e)
{
txtRisultato.Text =
Library1.Stampa.testo(txtTestoInserito.Text);
}
}
}

Applicazione ASP.NET/F#

Anche nell’ambito delle applicazioni web, l’interazione tra l’applicazione ASP.NET e la libreria F# non potrebbe essere più facile di così. Vediamo un breve esempio.

Prima di tutto creiamo un sito ASP.NET. Dopo aver selezionato la voce di menu File > Nuovo > Sito web, apparirà una finestra di selezione del tipo di applicazione (Figura 7).

clip_image013

Per semplificare, selezioniamo il template Sito web ASP.NET vuoto, scegliamo un percorso nel quale salvare i file dell’applicazione e confermiamo.

Una volta creata l’applicazione base, aggiungiamo un progetto di Libreria F#: su questo aspetto non ci soffermiamo oltre, perché la modalità di aggiunta della libreria, il codice contenuto nella libreria, la compilazione e l’aggiunta del riferimento nell’applicazione ASP.NET sono esattamente identici a quanto abbiamo già visto negli esempi precedenti.

Avendo scelto di creare un’applicazione ASP.NET vuota, tra i file del progetto non abbiamo nemmeno una pagina definita: aggiungiamo quindi una pagina di tipo WebForm (che nel nostro caso si chiama WebForm1.aspx) e modifichiamo il blocco <body> … </body> come segue:

<body>
<form id="form1" runat="server">
<div>
<asp:TextBox ID="txtTestoInserito" runat="server" Font-Size="24pt" Width="420
px"></asp:TextBox>
<br />
<br />
<asp:Button ID="btnCallStampa" runat="server" Font-Size="24pt" Text="Chiama funzione F#" Width="342px" />
<br />
<br />
<asp:TextBox ID="txtRisultato" runat="server" Font-Size="24pt" Width="420px"></asp:TextBox>
</div>
</form>
</body>

Come potete vedere, non abbiamo fatto altro che aggiungere due caselle di testo e un pulsante, esattamente come avevamo fatto negli esempi precedenti.

Ora dobbiamo solo modificare il codice che viene richiamato dalla pressione del pulsante: con un doppio click sul pulsante stesso, entriamo nell’editor del codice (Visual Basic o C#, a seconda del tipo di sito ASP.NET che avete scelto). Scriviamo quindi il seguente codice Visual Basic:

// esempio: mdgIntroFsharp06
txtRisultato.Text =
Library1.Stampa.testo(txtTestoInserito.Text)

oppure il seguente codice C#:

txtRisultato.Text =
Library1.Stampa.testo(txtTestoInserito.Text);

A questo punto potete compilare ed eseguire l’applicazione. Verrà avviato il web server incluso in Visual Studio e verrà aperto Internet Explorer per mostrare l’applicazione che abbiamo appena concluso. Se inserite un testo nella prima casella di testo e premete il pulsante, vedrete un risultato che ricalca quello che avete già visto nella Figura 6.

Alcune risorse per approfondire

In rete è possibile trovare parecchia documentazione su F#, anche se quasi esclusivamente in lingua inglese. In italiano, attualmente esiste quasi solo il blog dell’autore di questo articolo, reperibile all’indirizzo https://fsharpdazero.wordpress.com.

A seguire vi elenchiamo alcune risorse utili e interessanti che uno sviluppatore F# deve assolutamente conoscere.

MSDN Library

Si trova all’indirizzo http://bit.ly/15FalRk, ma è possibile scaricare tutta la documentazione anche in locale, utilizzando l’Help Viewer di Visual Studio 2012 (menu ? > Aggiungi e rimuovi contenuto della guida).

tryF#

All’indirizzo http://preview.tryfsharp.org/ è possibile trovare della documentazione e molti esempi pratici, ma il vantaggio principale è quello di poter eseguire il codice di esempio o il nostro codice F# direttamente online, senza utilizzare Visual Studio.

Visual F# Resources

All’indirizzo http://bit.ly/14llVa8 si trovano molte risorse per F#: riferimenti a documentazione, news, librerie, video, tutorial, esempi e così via.

Il blog di Don Syme

Nella vostra cassetta degli attrezzi non può mancare l’indirizzo al blog di Don Syme, cioè dello sviluppatore che ha creato Visual F#: http://blogs.msdn.com/b/dsyme/. Qui troverete articoli e annunci di novità che riguardano il linguaggio.

Rich Minerich’s Development Wonderland

Un altro blog che dovete assolutamente segnarvi è quello di Rich Minerich, sviluppatore F# e autore di vari libri su questo linguaggio: http://bit.ly/1akHpGO.

In questo blog trovate anche periodicamente un post con un immenso elenco di riferimenti a risorse su F#: news, articoli, librerie, video e molto altro.

Progetti su CodePlex

All’indirizzo http://bit.ly/150jzMo trovate un elenco di progetti open source (ben 69 progetti!) che potete scaricare, provare e utilizzare a vostro piacimento.

Channel 9

Per chi preferisce veder fare le cose in pratica e non ha particolare difficoltà a capire l’inglese parlato, non c’è niente di meglio che una serie di video. Li trovate su Channel 9 all’indirizzo http://bit.ly/18ubUVj.

FPish

Un altro riferimento importante è FPish, all’indirizzo http://cs.hubfs.net/. Si tratta di una community di sviluppatori F# e quindi vi potete trovare una grande varietà di contenuti, da vari blog a risposte su quesiti dei visitatori, fino a veri e propri corsi (questi però sono a pagamento).

Guida per la sopravvivenza

All’indirizzo http://bit.ly/15wxYMG potete trovare “The F# Survival Guide”, praticamente un libro-guida gratuito online. Dato il grande numero di esempi di codice è fortemente consigliato.

F# Snippet

Fortemente consigliato è anche il sito che si trova all’indirizzo http://fssnip.net/. A fronte di un’organizzazione del materiale forse un po’ caotica, potete trovare gli esempi per le varie categorie rappresentate da una “nuvola” di parole chiave presente all’inizio della pagina. Le parole chiave hanno una dimensione proporzionale al numero di esempi a cui si riferiscono.

La nuova versione 3.1 per Visual Studio 2013

Naturalmente un linguaggio del futuro deve continuamente aggiornarsi e aggiungere nuove caratteristiche. All’indirizzo http://bit.ly/14lnjcZ potete trovare l’annuncio delle novità della nuova versione 3.1 che sarà rilasciata contestualmente a Visual Studio 2013 (nel momento in cui scriviamo non è ancora stata resa pubblica la data di lancio).

Conclusioni

In questo articolo vi ho mostrato una panoramica su cosa è F#, su come è nato e su quale “filosofia” si basa, cioè la programmazione funzionale, unita alla programmazione imperativa e a quella orientata agli oggetti. Un linguaggio, quindi, multi-paradigma che ci consente una flessibilità mai vista prima, ma anche una robustezza senza precedenti.

Dopo aver esplorato alcuni aspetti che differenziano F# dagli altri linguaggi .NET (VB e C#) vi ho spiegato come installare F# anche sull’ambiente di sviluppo Visual Studio Express 2012 for Web. In seguito ho sperimentato l’esecuzione di istruzioni in F# Interactive e la costruzione di una libreria F#, utilizzata a sua volta da un programma F#, analizzandone anche le singole istruzioni.

Per motivi di spazio non ho potuto esplorare altre possibilità di F#: dall’utilizzo della libreria Library1 in VB e C# alla programmazione di interfacce Windows Forms con F#, dall’utilizzo di F# in siti ASP.NET e in applicazioni Windows Azure.

Visual Basic 2015: stringhe multilinea

Come ormai è noto, nella seconda metà di luglio è stato rilasciato Visual Studio 2015, nuova versione dell’ambiente di sviluppo di Microsoft. Questa versione porta molte novità e con questo post iniziamo ad esplorarne alcune.

Colgo l’occasione per avvertirvi che questo blog, inizialmente (e per vari anni) dedicato a Visual Basic e poi passato a F#, diventa “multi-linguaggio”, nel senso che qui mi occuperò di Visual Basic, di C# e di F#, ma anche di sviluppo web, di sviluppo di database, di Azure, di Windows Phone, di … tante altre cose legate allo sviluppo .NET.  Sorriso  … Ok, iniziamo.

Una delle funzionalità più richieste dagli sviluppatori era la possibilità di andare a capo senza dover inserire caratteri di punteggiatura o altri caratteri speciali. Nelle precedenti versioni di Visual Basic abbiamo avuto questa possibilità con il codice, ma ora è possibile farlo anche con le stringhe. Per esempio:

 

    MsgBox(“Prima non si poteva andare
a capo semplicemente premendo il tasto di Invio,
ma bisognava inserire un doppio apice, un ‘underscore’
e poi un doppio apice nella riga seguente.
Ora basta fare…
così!”)

 

Nel momento in cui eseguiamo questo codice, vediamo che il testo va a capo esattamente come nella stringa:

image

 

Ma cosa succede se scriviamo un codice come questo?

 

    Dim stringa As String = “

    MsgBox(stringa.Length.ToString)

 

Il risultato che otterremo nella finestra del messaggio è: 2, corrispondente ai codici di controllo CR+LF, ovvero la sequenza “normale” di Windows per andare a capo.

Questa sequenza significa: CR = carriage return, cioè ritorno carrello (in ricordo del “ritorno carrello” delle vecchie macchine da scrivere) + LF = line feed, ovvero lo scorrimento alla riga successiva (alcuni sistemi utilizzano solo il codice LF = line feed).

 

 

 

 

 

 

 

 

Un articolo su F# di Julie Lerman – MSDN Magazine di Febbraio 2013

Nel numero di Febbraio 2013 di MSDN Magazine c’è un interessante articolo di Julie Lerman intitolato “Data, Meet My New Friend, F#”, pagine 24-26.

Non appena il numero della rivista sarà pubblicato online, dovreste trovarlo a questo indirizzo: http://msdn.microsoft.com/it-it/magazine/dn519915.aspx.

L’articolo è molto interessante perché suggerisce alcuni cambiamenti nella architettura delle nostre applicazioni, dal fatto di spostare parte o tutta la logica dal database all’applicazione client, al fatto di creare librerie in F#, molto più veloci (sfruttando la programmazione parallela) ed efficaci. Tali librerie possono poi essere utilizzate da qualsiasi altro linguaggio (VB, C#, ma anche in ASP.NET), così da avere il massimo risultato possibile in termini di performance.

Assolutamente da leggere!

Nuovi modelli di applicazioni per F#

Qualche tempo fa è stato rilasciato il pacchetto “Visual F# Out of Band Release 3.1.1” che potete trovare a questo indirizzo:

http://www.microsoft.com/en-us/download/details.aspx?id=41654

Potete approfondire il contenuto di questo aggiornamento leggendo il blog del Team di sviluppo F# a questo indirizzo:

http://blogs.msdn.com/b/fsharpteam/archive/2014/01/22/announcing-visual-f-3-1-1-and-support-for-desktop-express.aspx

In sostanza, le novità principali di questo aggiornamento sono:

  • un limitato numero di correzioni di bug, in base alla versione rilasciata per Visual Studio 2013 RTM

  • il supporto dell’integrazione di F# nell’IDE delle versioni Express (Desktop, Web e ovviamente nelle versioni da Professional in su)

  • supporto per distribuzione del compilatore/runtime/”interactive” indipendenti su macchine che non hanno installato Visual Studio

  • un nuovo meccanismo di aggiornamento di Visual F#: gli aggiornamenti e le correzioni di bug possono essere ora distribuiti facilmente e con la stessa cadenza dei rilasci di Visual Studio (i famosi “Update N”).

Inutile dire che sono molto contento di queste novità, in particolare quella che più mi piace è la possibilità di utilizzare F# nelle edizioni Express. Infatti il problema che più impattava negativamente nella diffusione di F# tra gli studenti e gli appassionati di programmazione era il fatto di non poter utilizzare il compilatore e F# Interactive nelle edizioni Express di Visual Studio (si poteva in altri ambiti, come SharpDeveloper, ma con limitazioni). Ora che questo passo è stato fatto, tutti possono utilizzare gratuitamente F# per scrivere i propri programmi, anche didattici!

Buona programmazione con F#!

Nuovi modelli di applicazioni per F#

Il “mondo di F#” è sempre in movimento.

Come potete vedere da questo articolo di Kevin Ransom e di Don Syme, sono stati introdotti vari nuovi modelli di applicazione F# realizzati da vari autori delle community tecniche.

Inoltre è stato creato un “repository” centrale di modelli di applicazioni F# basato su Git per facilitare la condivisione dei template e il loro miglioramento, attraverso l’attività degli autori delle community tecniche.

I link alle pagine che illustrano alcuni template sono questi:

  • A New F# ASP.NET MVC 5 and Web API 2 Project Template

  • Nancy Templates for F#

  • MSTest Project Template for F#

  • FSharpTest Template for F#

  • New F# Web App Item Templates

  • Adding New Items to a Pure F# ASP.NET MVC/Web API Project

  • A Few Changes to the F#/C# MVC 4 Project Template

  • Windows 10 sulla piattaforma Azure

    Per gli sviluppatori c’è un’altra novità interessante: sulla piattaforma Azure è ora possibile creare delle macchine virtuali con Windows 10 Enterprise o Enterprise N (a 64 bit), eventualmente anche con Visual Studio 2015 (Community, Professional o Enterprise) e con i tool per creare le Universal Apps.

    Nella seguente immagine potete vedere tutte le opzioni presenti nella raccolta di Azure che comprendono Windows 10.

    image

    Se non volete perdere tempo potete scegliere una macchina virtuale con Visual Studio già installato, oppure potete scegliere solo il sistema operativo e poi installare una copia personalizzata di Visual Studio e degli strumenti che volete.

    Con questa base e con la possibilità di modulare le risorse di sistema da un minimo di un core condiviso e 768 MB di RAM (opzione A0), fino a 32 core e 448 MB di RAM (opzione G5), vi fornisce una potenza di calcolo e una flessibilità enorme. Per esempio, a parte i costi correlati all’opzione G5, potreste creare un’applicazione di calcolo parallelo che fa funzionare tutti i 32 core, riducendo i tempi di calcolo a una frazione di quello che potreste fare su un solo PC desktop. Notevole, no?

    Il mio “giornale quotidiano”

    Ormai da diverso tempo ho iniziato a sperimentare la pubblicazione di un mio “giornale quotidiano” con notizie sul mondo .NET, con un occhio particolarmente attento a quelle riguardanti il linguaggio F# (Fsharp) ma anche su altre tecnologie e linguaggi legati a .NET.

    Il giornale si trova qui: http://galaxydotnet.bell1.net.

    image

     

    Se vi interessa rimanere aggiornati sulla pubblicazione del giornale, vi consiglio di cliccare sul pulsante “SUBSCRIBE”.

    Windows 10: Microsoft Print to PDF

    Permettetemi una digressione su una funzionalità di Windows 10 che mi è piaciuta molto: la stampa diretta a un file PDF con la stampante virtuale “Microsoft Print to PDF“.

    Le funzionalità sono ridotte al minimo, tanto che le proprietà della stampante non sono modificabili e non è possibile nemmeno definire in che posizione sarà salvato il PDF e con quale nome (la cartella predefinita è la cartella Documenti dell’utente).

    Tuttavia per creare file PDF di un documento (per esempio una pagina di un sito Internet) è molto utile ed è velocissima.

    Non sostituisce del tutto PDFcreator che permette di definire meglio le caratteristiche del file, il suo nome, la sua posizione, la modalità a colori o bianco/nero ecc., ma va benissimo per stampe “al volo”.

    Una curiosità: la porta utilizzata dalla stampante virtuale è PORTPROMPT:, ovvero la stessa della stampante virtuale Microsoft XPS Document Writer. Ma c’è davvero qualcuno che stampa in formato XPS?

    Testimonianze di utilizzo “sul campo” di F#

    Per capire quanto è potente un linguaggio non c’è niente di meglio che leggere le testimonianze di sviluppatori che hanno utilizzato quel linguaggio per realizzare un prodotto o per riscrivere un prodotto pre-esistente.

    image

    All’indirizzo http://fsharp.org/testimonials/#handelsbanken-1 potete trovare alcune testimonianze e citazioni di sviluppatori che hanno trovato nel linguaggio F# un prodotto veramente utile e produttivo. Uno l’ha perfino definito una sorta di “salva-vita” (life-saver)!

    In effetti non si può che essere d’accordo: un linguaggio che riduce il numero di linee di codice, che è intuitivo (naturalmente se lo si conosce bene), che riduce il numero di bug e che ha prestazioni stupefacenti, non può che essere considerato il “salvatore” del nostro tempo libero o quanto meno della nostra serenità e tranquillità!

    Recensione libro “Professional Visual Studio 2012”

    image

    booksite:
    http://eu.wiley.com/WileyCDA/WileyTitle/productCd-1118337700.html
    Autore: Bruce Johnson
    ISBN: 978-1-118-33770-7
    Fogliazione: 1104 pages
    Edizione: November 2012

    Vi può sembrare strano un libro sull’ambiente di sviluppo Visual Studio 2012, perché spesso ci focalizziamo su un libro di programmazione, quindi su un linguaggio specifico (per esempio Visual Basic o C#).

    Questo libro, quindi, esce un po’ dalla normalità, perché fornisce informazioni sull’ambiente di sviluppo e su tutte le sue funzionalità. Questo non significa che all’interno non ci siano esempi di codice: se date un’occhiata al “booksite” di cui ho indicato l’indirizzo all’inizio di questa recensione, potete trovare molti esempi di codice scaricabili (VB e C#).

    Tuttavia, gli esempi di codice riportati nel libro sono soprattutto funzionali alla spiegazione di particolari tecniche e di specifiche funzionalità di Visual Studio 2012.

    Il libro può essere utile, quindi, sia agli sviluppatori meno esperti che possono così apprendere tutte le cose che si possono fare con Visual Studio 2012, sia agli sviluppatori più esperti che possono trovare un riferimento estremamente preciso a tutte le funzionalità, comprese quelle più avanzate.

    Il libro include argomenti che ho apprezzato molto, come i riferimenti a Windows Azure, alle applicazioni Windows Store (Windows 8), allo Unit Testing e perfino sei pagine sulla programmazione in F# (come sicuramente avrete notato, da un po’ di tempo ho iniziato a interessarmi e a impegnarmi nello studio di questo linguaggio…).

    Tutto questo unito all’estrema chiarezza nell’impaginazione grafica di Wrox che non delude mai.

    Ecco quindi l’elenco dei 57 capitoli del libro:

    PART I: INTEGRATED DEVELOPMENT ENVIRONMENT

    CHAPTER 1: A QUICK TOUR
    CHAPTER 2: THE SOLUTION EXPLORER, TOOLBOX, AND PROPERTIES
    CHAPTER 3: OPTIONS AND CUSTOMIZATIONS
    CHAPTER 4: THE VISUAL STUDIO WORKSPACE
    CHAPTER 5: FIND AND REPLACE AND HELP

    PART II: GETTING STARTED

    CHAPTER 6: SOLUTIONS, PROJECTS, AND ITEMS
    CHAPTER 7: INTELLISENSE AND BOOKMARKS
    CHAPTER 8: CODE SNIPPETS AND REFACTORING
    CHAPTER 9: SERVER EXPLORER
    CHAPTER 10: MODELING WITH THE CLASS DESIGNER

    PART III: DIGGING DEEPER

    CHAPTER 11: UNIT TESTING
    CHAPTER 12: DOCUMENTATION WITH XML COMMENTS
    CHAPTER 13: CODE CONSISTENCY TOOLS
    CHAPTER 14: CODE GENERATION WITH T4
    CHAPTER 15: PROJECT AND ITEM TEMPLATES
    CHAPTER 16: LANGUAGE-SPECIFIC FEATURES

    PART IV: RICH CLIENT APPLICATIONS

    CHAPTER 17: WINDOWS FORMS APPLICATIONS
    CHAPTER 18: WINDOWS PRESENTATION FOUNDATION (WPF)
    CHAPTER 19: OFFICE BUSINESS APPLICATIONS
    CHAPTER 20: WINDOWS STORE APPLICATIONS

    PART V: WEB APPLICATIONS

    CHAPTER 21: ASP.NET WEB FORMS
    CHAPTER 22: ASP.NET MVC
    CHAPTER 23: SILVERLIGHT
    CHAPTER 24: DYNAMIC DATA
    CHAPTER 25: SHAREPOINT
    CHAPTER 26: WINDOWS AZURE

    PART VI: DATA

    CHAPTER 27: VISUAL DATABASE TOOLS
    CHAPTER 28: DATASETS AND DATABINDING
    CHAPTER 29: LANGUAGE INTEGRATED QUERIES (LINQ)
    CHAPTER 30: THE ADO.NET ENTITY FRAMEWORK
    CHAPTER 31: REPORTING

    PART VII: APPLICATION SERVICES

    CHAPTER 32: WINDOWS COMMUNICATION FOUNDATION (WCF)
    CHAPTER 33: WINDOWS WORKFLOW FOUNDATION (WF)
    CHAPTER 34: CLIENT APPLICATION SERVICES
    CHAPTER 35: SYNCHRONIZATION SERVICES
    CHAPTER 36: WCF RIA SERVICES

    PART VIII: CONFIGURATION AND RESOURCES

    CHAPTER 37: CONFIGURATION FILES
    CHAPTER 38: CONNECTION STRINGS
    CHAPTER 39: RESOURCE FILES

    PART IX: DEBUGGING

    CHAPTER 40: USING THE DEBUGGING WINDOWS
    CHAPTER 41: DEBUGGING WITH BREAKPOINTS
    CHAPTER 42: DATATIPS, DEBUG PROXIES, AND VISUALIZERS
    CHAPTER 43: DEBUGGING WEB APPLICATIONS
    CHAPTER 44: ADVANCED DEBUGGING TECHNIQUES

    PART X: BUILD AND DEPLOYMENT

    CHAPTER 45: UPGRADING WITH VISUAL STUDIO 2012
    CHAPTER 46: BUILD CUSTOMIZATION
    CHAPTER 47: ASSEMBLY VERSIONING AND SIGNING
    CHAPTER 48: OBFUSCATION, APPLICATION MONITORING, AND MANAGEMENT
    CHAPTER 49: PACKAGING AND DEPLOYMENT
    CHAPTER 50: WEB APPLICATION DEPLOYMENT

    PART XI: CUSTOMIZING AND EXTENDING VISUAL STUDIO

    CHAPTER 51: THE AUTOMATION MODEL
    CHAPTER 52: ADD-INS
    CHAPTER 53: MANAGED EXTENSIBILITY FRAMEWORK (MEF)

    PART XII: VISUAL STUDIO ULTIMATE

    CHAPTER 54: VISUAL STUDIO ULTIMATE FOR ARCHITECTS
    CHAPTER 55: VISUAL STUDIO ULTIMATE FOR DEVELOPERS
    CHAPTER 56: VISUAL STUDIO ULTIMATE FOR TESTERS
    CHAPTER 57: TEAM FOUNDATION SERVER

    Come ignorare il risultato di una funzione (ignore)

    In un precedente post abbiamo già visto che in F# tutto è una funzione e quindi restituisce un valore. Ci sono però dei casi in cui non ci interessa leggere il valore restituito, per esempio perché volevamo solo scrivere una stringa nella Console (e quindi non c’è un valore utile di ritorno). Ecco un esempio di ciò che avevamo visto:

    Console.ReadLine() |> ignore

    Notate l’operatore di “pipe” rappresentato da una barra verticale e da un simbolo di “maggiore di”:   |>

    In F# c’è un altro modo di ignorare il risultato ed è quello di utilizzare la funzione ignore():

    ignore(Console.ReadLine())

    A voi la scelta!

    Recensione libro “Essential Algorithms”

    image

    Booksite:
    http://eu.wiley.com/WileyCDA/WileyTitle/productCd-1118612108.html
    Autore: Rod Stephens
    ISBN: 978-1-118-61210-1
    Fogliazione: 624 pagine
    Edizione: Settembre 2013

    Lo studio degli algoritmi mi ha sempre appassionato, anche da prima di iniziare a frequentare l’Università.

    Nei miei studi universitari ho avuto a che fare con la codifica di questi algoritmi, utilizzando il linguaggio di programmazione JAVA.

    Prima di questo bellissimo libro di Rod Stephens non avevo trovato un libro che fosse orientato agli algoritmi in sé, non espressamente codificati in un linguaggio di programmazione specifico (per esempio in JAVA o in C++). Il libro, infatti, utilizza uno pseudo-codice che può essere facilmente adattato a qualsiasi linguaggio di programmazione.

    Questo libro, quindi, copre un vuoto di moltissimi anni, durante il quale i programmatori dovevano riuscire ad adattare il codice JAVA o C++ in un altro linguaggio di programmazione. Questo compito era tutt’altro che facile!

    Nel libro potete trovare gli argomenti più disparati, perfino quelli notoriamente considerati più “difficili” che di solito si studiano in corsi di ricerca operativa: per esempio l’algoritmo dello zaino (knapsack) o l’algoritmo dei filosofi.

    L’approccio non è teorico e matematico, ma bensì molto più pratico, cercando di stimolare l’interesse del lettore e del programmatore a capire i meccanismi che stanno alla base degli algoritmi.

    Mi sembra inutile dire quanto mi ha appassionato questo libro: voto massimo a Rod Stephens e naturalmente anche a Wiley che punta sempre su autori di massimo spessore.

    Ecco quindi l’elenco dei 19 capitoli del libro e dei relativi paragrafi:

    Chapter 1 Algorithm Basics

    Approach
    Algorithms and Data Structures
    Pseudocode
    Algorithm Features
    Big O Notation
    Common Runtime Functions
    Visualizing Functions
    Practical Considerations
    Summary
    Exercises

    Chapter 2 Numerical Algorithms

    Randomizing Data
    Generating Random Values
    Randomizing Arrays
    Generating Nonuniform Distributions
    Finding Greatest Common Divisors
    Performing Exponentiation
    Working with Prime Numbers
    Finding Prime Factors
    Finding Primes
    Testing for Primality
    Performing Numerical Integration
    The Rectangle Rule
    The Trapezoid Rule
    Adaptive Quadrature
    Monte Carlo Integration
    Finding Zeros
    Summary
    Exercises

    Chapter 3 Linked Lists

    Basic Concepts
    Singly Linked Lists
    Iterating Over the List
    Finding Cells
    Using Sentinels
    Adding Cells at the Beginning
    Adding Cells at the End
    Inserting Cells After Other Cells
    Deleting Cells
    Doubly Linked Lists
    Sorted Linked Lists
    Linked-List Algorithms
    Copying Lists
    Sorting with Insertionsort
    Linked List Selectionsort
    Multithreaded Linked Lists
    Linked Lists with Loops
    Marking Cells
    Using Hash Tables
    List Retracing
    List Reversal
    Tortoise and Hare
    Loops in Doubly Linked Lists
    Summary
    Exercises

    Chapter 4 Arrays

    Basic Concepts
    One-dimensional Arrays
    Finding Items
    Finding Minimum, Maximum, and Average
    Inserting Items
    Removing Items
    Nonzero Lower Bounds
    Two Dimensions
    Higher Dimensions
    Triangular Arrays
    Sparse Arrays
    Find a Row or Column
    Get a Value
    Set a Value
    Delete a Value
    Matrices
    Summary
    Exercises

    Chapter 5 Stacks and Queues

    Stacks
    Linked-List Stacks
    Array Stacks
    Double Stacks
    Stack Algorithms
    Queues
    Linked-List Queues
    Array Queues
    Specialized Queues
    Summary
    Exercises

    Chapter 6 Sorting

    O(N2) Algorithms
    Insertionsort in Arrays
    Selectionsort in Arrays
    Bubblesort
    O(N log N) Algorithms
    Heapsort
    Quicksort
    Mergesort
    Sub O(N log N) Algorithms
    Countingsort
    Bucketsort
    Summary
    Exercises

    Chapter 7 Searching

    Linear Search
    Binary Search
    Interpolation Search
    Summary
    Exercises

    Chapter 8 Hash Tables

    Hash Table Fundamentals
    Chaining
    Open Addressing
    Removing Items
    Liner Probing
    Quadratic Probing
    Pseudorandom Probing
    Double Hashing
    Ordered Hashing
    Summary
    Exercises

    Chapter 9 Recursion

    Basic Algorithms
    Factorial
    Fibonacci Numbers
    Tower of Hanoi
    Graphical Algorithms
    Koch Curves
    Hilbert Curve
    Sierpin´ ski Curve
    Gaskets
    Backtracking Algorithms
    Eight Queens Problem
    Knight’s Tour
    Selections and Permutations
    Selections with Loops
    Selections with Duplicates
    Selections Without Duplicates
    Permutations with Duplicates
    Permutations Without Duplicates
    Recursion Removal
    Tail Recursion Removal
    Storing Intermediate Values
    General Recursion Removal
    Summary
    Exercises

    Chapter 10 Trees

    Tree Terminology
    Binary Tree Properties
    Tree Representations
    Building Trees in General
    Building Complete Trees
    Tree Traversal
    Preorder Traversal
    Inorder Traversal
    Postorder Traversal
    Depth-first Traversal
    Traversal Run Times
    Sorted Trees
    Adding Nodes
    Finding Nodes
    Deleting Nodes
    Threaded Trees
    Building Threaded Trees
    Using Threaded Trees
    Specialized Tree Algorithms
    The Animal Game
    Expression Evaluation
    Quadtrees
    Tries
    Summary
    Exercises

    Chapter 11 Balanced Trees

    AVL Trees
    Adding Values
    Deleting Values
    2-3 Trees
    Adding Values
    Deleting Values
    B-Trees
    Adding Values
    Deleting Values
    Balanced Tree Variations
    Top-down B-trees
    B+trees
    Summary
    Exercises

    Chapter 12 Decision Trees

    Searching Game Trees
    Minimax
    Initial Moves and Responses
    Game Tree Heuristics
    Searching General Decision Trees
    Optimization Problems
    Exhaustive Search
    Branch and Bound
    Decision Tree Heuristics
    Other Decision Tree Problems
    Summary
    Exercises

    Chapter 13 Basic Network Algorithms

    Network Terminology
    Network Representations
    Traversals
    Depth-first Traversal
    Breadth-first Traversal
    Connectivity Testing
    Spanning Trees
    Minimal Spanning Trees
    Finding Paths
    Finding Any Path
    Label-Setting Shortest Paths
    Label-Correcting Shortest Paths
    All-Pairs Shortest Paths
    Summary
    Exercises

    Chapter 14 More Network Algorithms

    Topological Sorting
    Cycle Detection
    Map Coloring
    Two-coloring
    Three-coloring
    Four-coloring
    Five-coloring
    Other Map-coloring Algorithms
    Maximal Flow
    Work Assignment
    Minimal Flow Cut
    Summary
    Exercises

    Chapter 15 String Algorithms

    Matching Parentheses
    Evaluating Arithmetic Expressions
    Building Parse Trees
    Pattern Matching
    DFAs
    Building DFAs for Regular Expressions
    NFAs
    String Searching
    Calculating Edit Distance
    Summary
    Exercises

    Chapter 16 Cryptography

    Terminology
    Transposition Ciphers
    Row/column Transposition
    Column Transposition
    Route Ciphers
    Substitution Ciphers
    Caesar Substitution
    Vigenère Cipher
    Simple Substitution
    One-Time Pads
    Block Ciphers
    Substitution-Permutation Networks
    Feistel Ciphers
    Public-Key Encryption and RSA
    Euler’s Totient Function
    Multiplicative Inverses
    An RSA Example
    Practical Considerations
    Other Uses for Cryptography
    Summary
    Exercises

    Chapter 17 Complexity Theory

    Notation
    Complexity Classes
    Reductions
    3SAT
    Bipartite Matching
    NP-Hardness
    Detection, Reporting, and Optimization Problems
    Detection ≤p Reporting
    Reporting ≤p Optimization
    Reporting ≤p Detection
    Optimizatio
    Reporting
    NP-Complete Problems
    Summary
    Exercises

    Chapter 18 Distributed Algorithms

    Types of Parallelism
    Systolic Arrays
    Distributed Computing
    Multi-CPU Processing
    Race Conditions
    Deadlock
    Quantum Computing
    Distributed Algorithms
    Debugging Distributed Algorithms
    Embarrassingly Parallel Algorithms
    Mergesort
    Dining Philosophers
    The Two Generals Problem
    Byzantine Generals
    Consensus
    Leader Election
    Snapshot
    Clock Synchronization
    Summary
    Exercises

    Chapter 19 Interview Puzzles

    Asking Interview Puzzle Questions
    Answering Interview Puzzle Questions
    Summary
    Exercises

    Appendix A Summary of Algorithmic Concepts
    Appendix B Solutions to Exercises

    Ancora sui cicli For

    In un post precedente abbiamo visto l’uso dei cicli For in modo funzionale, cioè restituendo il risultato dell’intero ciclo a un identificatore.

    Possiamo utilizzare i cicli For anche in modo imperativo, semplicemente aggiungendo la parola riservata “do” dopo la definizione del ciclo, in questo modo:

    for i = min to max do
    Console.WriteLine(i.ToString())

    Un aspetto che non avevamo visto è la possibilità di eseguire il ciclo al contrario, scambiando il valore massimo e il valore minimo del ciclo e sostituendo la parola “to” con la parola “downto”:

    for i = max downto min do
    Console.WriteLine(i.ToString())

    Ecco un esempio completo:

    open System



    let min, max = (0, 10)
    for i = min to max do
    Console.WriteLine(i.ToString())
    Console.ReadLine() |> ignore



    for i = max downto min do
    Console.WriteLine(i.ToString())
    Console.ReadLine() |> ignore

    Assegnazione multipla di valori agli identificatori

    Torno brevemente sull’assegnazione di valori agli identificatori per sottolineare la possibilità di effettuare un’assegnazione multipla di più identificatori.

    Normalmente siamo orientati a scrivere una cosa di questo tipo:

    let a = 1
    let b = 2

    In F# possiamo utilizzare anche un’istruzione unica:

    let a, b = (1, 2)

    La sintassi è molto più compatta e non perde di chiarezza.

    Namespace o Modulo?

    Per chi proviene da C# o da VB, l’utilizzo dei namespace e dei moduli in F# può sembrare un po’ anomalo, ma si tratta semplicemente di abituarsi a una diversa convenzione.

    Bisogna tenere presente un concetto fondamentale:

    • i namespace possono contenere solo dichiarazioni di tipi e NON possono contenere valori;
    • i moduli possono contenere dichiarazioni di tipi e ANCHE valori.

    Ecco un breve esempio:

    namespace X
    type Tipo = { i : int; s : string }

    namespace Esempio1

    module Y =
    type Tipo = { i : int; s : string }
    let Tipo = (10,"prova")

    Per prima cosa abbiamo creato il namespace X e, al suo interno, abbiamo definito un nuovo tipo di nome “Tipo” e formato da due identificatori: l’intero “i” e la stringa “s”.

    Successivamente abbiamo definito il namespace “Esempio1” senza alcuna definizione al suo interno.

    Infine abbiamo creato il modulo “Y”, definendo gli stessi tipi che avevamo definito nel namespace “X”, ma con in più anche l’assegnazione dei valori agli identificatori (ultima riga).

    Notate che nel caso del modulo, abbiamo dovuto utilizzare l’operatore di assegnazione (=), posto subito dopo al nome del modulo.

    Don Syme “ritwitta” l’indirizzo di questo blog!

    Ieri ho pubblicato su Twitter l’indirizzo di questo blog italiano su F# e poco dopo ho ricevuto la notifica sul “ritwit” da parte di Don Syme (ved. il suo blog su MSDN http://blogs.msdn.com/b/dsyme/, ma anche il suo blog su FPish.NET http://fpish.net/blog/don.syme/).

    Fsharp_RetwitDonSyme

    Chi è Don Syme? La risposta la trovate al seguente indirizzo:
    http://research.microsoft.com/en-us/people/dsyme/

    Per vostra comodità trascrivo qui le sue stesse parole:

    Don Syme

    I am a Principal Researcher at Microsoft Research, Cambridge. I help Microsoft make better programming languages, and, through that, make people more productive and happier.

    My main current responsibility is the design and implementation of F# (blog), though I’ve also worked on C# (being co-responsible for C# and .NET generics) and, indirectly, Visual Basic and other .NET languages.

    As a researcher, my area is programming language design and implementation, with emphasis on making functional languages that are simpler to use, interoperate well with other languages and which incorporate aspects of object-oriented, asynchronous and parallel programming. I am interested in programming language perspectives on type inference, concurrency, reactivity, pattern matching and language-oriented programming. I also work extensively with teams in the Microsoft Developer Division on other programming-related technologies.

    I am the primary author of Expert F#, published in 2007, and we are now working on a second edition of this book. In the past I have worked in formal specification, interactive proof, automated verification and proof description languages. I have a PhD from the University of Cambridge and am a member of the WG2.8 working group on functional programming.

    Don’s Blog

    F# Type Provider for MATLAB – Feedback requested, contributions welcome
    Wed, 17 Jul 2013 21:59:08 GMT

    F# Deep Dives – Chapter 4 – Financial Programming
    Wed, 17 Jul 2013 21:27:00 GMT

    F# Deep Dives – Early Access Program
    Wed, 17 Jul 2013 21:18:00 GMT

    F#/C# jobs in Machine Learning + Data Tools, Microsoft Research, Redmond
    Thu, 11 Jul 2013 10:37:47 GMT

    Tonight at F#unctional Londoners: More Machine Learning Hands-on with F#
    Thu, 11 Jul 2013 10:31:16 GMT

    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!

        Iscriviti

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

        Unisciti agli altri 955 follower