F# Italia - Blog sulla programmazione in F#

SQL Server Express RC0 LocalDB

Mario De Ghetto — Sun, 15 Jan 2012 06:49:31 +0000

La nuova versione di SQL Server 2012 (attualmente ancora in RC0 = Release Candidate 0), porta una novità interessante: l’edizione LocalDB, una versione ridotta orientata agli sviluppatori di applicazioni.

Questa edizione non richiede l’installazione di particolari servizi, né opzioni complicate e pertanto si candida ad essere l’edizione preferita dagli sviluppatori, anche perché rende più semplice l’installazione del motore di database sulle macchine di destinazione dell’applicazione (i client) e perché, diversamente dall’edizione Express tradizionale, permette di includere anche del codice da eseguire per mezzo di script T-SQL.

Per scaricare il pacchetto di installazione, potete fare riferimento alla pagina http://bit.ly/uzoWwf e scegliere il pacchetto che più è opportuno per il vostro sistema operativo:

ENU\x86\SqlLocalDB.MSI, per sistemi operativi a 32 bit
ENU\x64\SqlLocalDB.MSI, per sistemi operativi a 64 bit

Ecco quindi la sequenza di installazione, per immagini:

Come è possibile vedere, l’installazione è estremamente semplice e si riduce praticamente a una serie di pressioni del pulsante Next, facilitando l’installazione anche per un utente non esperto.

Auguri di Buon Natale!

Mario De Ghetto — Sat, 24 Dec 2011 14:57:22 +0000

VS2010: ripristinare le impostazioni iniziali

Mario De Ghetto — Fri, 09 Dec 2011 05:36:15 +0000

Al primo avvio di Visual Studio 2010 vi apparirà una finestra come questa:

Se per esempio pensate di utilizzare solo Visual Basic potete selezionare la prima voce e confermare. Se utilizzate più di un tipo di progetto e/o linguaggio, l’impostazione migliore potrebbe essere “Impostazioni generali per lo sviluppo”.

Nel primo caso, quando create un nuovo progetto, avrete i template dei progetti Visual Basic come prima scelta, mentre tutti gli altri template sono raggruppati in un unico contenitore, nel quale dovrete eventualmente entrare per selezionarli; nel secondo caso tutti i tipi di progetto e tutti i linguaggi sono sullo stesso piano.

Se pensate di aver fatto la scelta sbagliata e volete modificarla, nessun problema: è sufficiente cliccare sul menu Strumenti > Importa/Esporta Impostazioni, poi nella finestra seguente scegliete “Reimposta tutte le impostazioni”:

Dopo questa operazione, riaprendo Visual Studio 2010 vi verrà riproposta la scelta della prima immagine.

Se avete qualche dubbio su cosa potrà succedere, prima di selezionare la voce “Reimposta tutte le impostazioni” potete selezionare “Esporta le impostazioni di ambiente selezionate” e salvarle per un eventuale recupero con la voce “Importa le impostazioni di ambiente selezionate”.

Il mio primo ebook!

Mario De Ghetto — Tue, 08 Nov 2011 05:36:56 +0000

Il mio libro “Office 2010 – Informatica da zero” è diventato un e-book a basso costo (2,99 Euro). Sul sito è possibile comunque ordinare anche una copia cartacea a un prezzo bassissimo (4,99 Euro). La pagina dedicata al libro è qui:

http://www.ebookvanilla.it/office-2010–informatica-da-zero.html

Un piccolo sacrificio per le popolazioni alluvionate

Mario De Ghetto — Fri, 04 Nov 2011 19:02:07 +0000

F# in pillole [9]: Stringhe

Mario De Ghetto — Thu, 13 Oct 2011 04:00:13 +0000

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

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

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

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

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

printfn "%s" message;

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

let message:string =  "Benvenuti nel meraviglioso mondo della programmazione funzionale!"

printfn "%s" message;

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

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

let nome = "Mario De Ghetto"let community = "DotNetWork.it"printfn "Benvenuti nel mondo della programmazione F#!"printfn "Nome:    %s" nomeprintfn "Community: %s" community

Questo codice produce il seguente risultato:

> Benvenuti nel mondo della programmazione F#!Nome:    Mario De GhettoCommunity: DotNetWork.it

val nome : string = "Mario De Ghetto"val community : string = "DotNetWork.it"

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

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

Non c’è due senza tre e il quarto vien da sé …

Mario De Ghetto — Sat, 01 Oct 2011 14:10:15 +0000

Crozza direbbe “… è con viva e vibbrrrante soddisfazione…”

Ancora una volta posso provare l’ebbrezza di essere nominato “Microsoft MVP” per la categoria Visual Basic! Dal 1° Ottobre 2008 è la quarta nomina annuale consecutiva, una nomina che continua a onorarmi e che soprattutto mi rende felice per il grande valore di questo riconoscimento.

Quest’anno, per me, è stato caratterizzato da qualche differenza, rispetto agli anni precedenti.

Innanzi tutto, c’è stato il lungo impegno per terminare il mio nuovo libro “Visual Basic 2010 spiegato a mia nonna”, un libro di circa 900 pagine che mi ha impegnato per un anno intero.

Inoltre è stato l’anno in cui ho pubblicato molti articoli (soprattutto su Visual Basic) sulla rivista “ioProgrammo” di Edizioni Master e in cui ho avuto la possibilità di fare lo speaker in alcuni eventi di Community, tra cui un evento voluto e organizzato da me stesso, insieme alla Community DNW (DotNetWork.it), proprio “a casa mia”, a Belluno.

E’ stato un anno in cui ho accresciuto la mia rete di contatti, sia di Community, sia professionale, con qualche riscontro economico ma soprattutto in termini di possibilità e di opportunità professionali interessanti.

Purtroppo tutte queste attività mi hanno un po’ limitato nella presenza nei forum e qualche volta nel rispondere tempestivamente alle molte e-mail che continuo a ricevere da molti lettori dei miei libri e dei miei articoli, o dai frequentatori dei forum di DotNetWork.it e, ancora oggi, di Visual Basic Tips & Tricks.

I progetti per il futuro sono ambiziosi: approfondire la conoscenza di Windows Azure, di Windows Phone, di Orchard, di LightSwitch, della futura versione di Visual Studio, della futura versione di Windows, di VS LightSwitch, di F# e di molto altro. Su tutti questi argomenti ho intenzione di proporre dei materiali, da articoli, a libri, a video, a post nei miei blog.

Uno degli obiettivi a breve, già fissato, è la mia partecipazione come speaker alla conferenza “WPC 2011” di Assago, verso fine novembre di questo anno (www.wpc2011.it). Il mio esordio nella più grande conferenza italiana sui prodotti Microsoft! Ringrazio Andrea Benedetti e tutta l’organizzazione del WPC 2011 per la fiducia che mi è stata accordata, spero che sarò all’altezza della situazione.

Ovviamente ringrazio anche Microsoft e in particolare Alessandro Teglia, MVP Lead, per la conferma della nomina a Microsoft MVP.

Ringrazio anche gli amici di DotNetWork.it e di Visual Basic Tips & Tricks, nonché tutti quelli che hanno manifestato interesse verso i miei libri e i miei articoli.

Sperando di riuscire a essere sempre all’altezza della situazione, mi avvio verso un altro anno di sperimentazioni, di sviluppo, di ricerca, di condivisione, di scrittura, di studio e di lavoro.

Stay tuned!

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

Mario De Ghetto — Wed, 14 Sep 2011 04:34:18 +0000

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

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

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

\b – backspace: fa retrocedere il cursore
\t – tabulazione orizzontale: fa avanzare il cursore al prossimo punto di tabulazione
\n – nuova linea: sposta il cursore all’inizio della linea successiva
\r – ritorno carrello: sposta il cursore all’inizio della linea corrente
\” – doppi apici: visualizza un carattere di doppi apici (“)
\’ – apostrofo: visualizza un apostrofo (‘)
\\ – backslash: visualizza un carattere di barra inversa (\)
\o – null: visualizza un carattere Null
\uXXXX oppure \UXXXX - carattere Unicode: è utilizzato per visualizzare il carattere equivalente di un simbolo rappresentato con un valore esadecimale

Ecco un esempio:

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

F# in pillole [7]: tipi di dati – caratteri

Mario De Ghetto — Thu, 08 Sep 2011 03:38:30 +0000

Come tutti sanno, un carattere può essere:

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

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

let gender = 'F';

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

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

Si otterrà così il seguente risultato:

Student Gender: M

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

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

F# in pillole [6]: tipi di dati e inferenza dei tipi

Mario De Ghetto — Tue, 06 Sep 2011 03:37:26 +0000

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

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

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

F# in pillole [5]: i nomi di variabili

Mario De Ghetto — Mon, 05 Sep 2011 08:47:39 +0000

Il nome di una variabile deve seguire determinate regole. Una di queste regole impone di non utilizzare i seguenti nomi che costituiscono parole riservate del linguaggio F#:

abstract, and, as, assert, base, begin, class, default, delegate, do, done, downcast, downto, elif, else, end, exception, extern, false, finally, for, fun, function, global, if, in, inherit, inline, interface, internal, lazy, let, match, member, module, mutable, namespace, new, not, null, of, open, or, override, private, public, rec, return, static, struct, then, to, true, try, type, upcast, use, val, void, when, while, with, yield.

Inoltre è opportuno evitare l’uso delle seguenti parole per nominare qualsiasi cosa:

asr, atomic, break, checked, component, const, constraint, constructor, continue, eager, event, external, fixed, functor, include, land, lor, lsl, lsr, lxor, method, mixin, mod, object, parallel, process, protected, pure, sealed, sig, tailcall, trait, virtual e volatile.

F# in pillole [4]: introduzione alle variabili

Mario De Ghetto — Sat, 03 Sep 2011 11:37:40 +0000

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

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

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

let variabile = "pippo"

Altro esempio:

let numero = 1234

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

let numero = 1234;

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

let numero =   1234

oppure, ancora:

let numero =   1234;

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

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

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

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

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

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

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

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

F# in pillole [3] – printfn

Mario De Ghetto — Thu, 01 Sep 2011 03:15:00 +0000

Nel precedente post abbiamo visto printf per visualizzare dei risultati, ciascuno dei quali viene posto immediatamente dopo il risultato precedente, senza andare a capo.

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

La sintassi di printfn ha le stesse regole di printf:

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

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

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

F# in pillole [2] – printf

Mario De Ghetto — Wed, 31 Aug 2011 03:12:00 +0000

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

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

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

Selezioniamo le 4 righe sopra indicate, nella finestra dell’editor di codice di un’applicazione F#, in Visual Studio 2010, e premiamo la combinazione ALT+INVIO. Questa operazione aprirà la finestra F# interactive, eseguendo le funzioni di cui sopra e visualizzando il seguente risultato:

Microsoft (R) F# 2.0 Interactive – build 4.0.40219.1
Copyright (c) Microsoft Corporation. Tutti i diritti riservati.

Per informazioni, digitare #help;;

Risultato da visualizzareRisultato da visualizzareRisultato da visualizzareRisultato da visualizzare>

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

Inoltre potete vedere che le parentesi tonde sono facoltative, così come il punto e virgola (;) inserito alla fine della riga da eseguire.

Ecco un altro esempio:

printf ("Benvenuti nel meraviglioso mondo della programmazione funzionale!");

F# in pillole [1]

Mario De Ghetto — Tue, 30 Aug 2011 02:59:00 +0000

Un linguaggio di programmazione funzionale, detto anche “linguaggio funzionale“, è un linguaggio che tratta un’assegnazione come un oggetto. In pratica, una funzione è qualcosa che ha un nome, memorizza un valore e puo eseguire delle azioni.

Una funzione è il punto centrale di un linguaggio funzionale. Può eseguire un’azione, definisce uno scopo e può produrre un valore.

Per assisterci nella programmazione, il linguaggio F# fornisce molte funzioni già pronte, indicate come funzioni predefinite.

Community "OrangeDotNet" – Evento "Build live" – Catania

Mario De Ghetto — Sat, 30 Jul 2011 06:48:15 +0000

Dalla Community “OrangeDotNet” ho ricevuto la segnalazione del loro evento “Build live”, a Paternò (Catania), dalle ore 15.30 alle ore 21.00 di martedì 13 Settembre 2011.

L’agenda è pubblicata sulla pagina dell’evento e contiene argomenti estremamente interessanti, quindi chi è “in zona” si iscriva al più presto!

Esempi di applicazioni F# in open source

Mario De Ghetto — Sun, 24 Jul 2011 05:44:27 +0000

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

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

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

Recensione di due libri interessanti su ALM e su TFS 2010, con Visual Studio 2010

Mario De Ghetto — Thu, 21 Jul 2011 13:06:07 +0000

La gestione del “ciclo di vita delle applicazioni” (da “Application Lifecyle Management“, cioè ALM) è un’attività complessa, sia per lo sviluppatore individuale, sia per interi team di sviluppo.

Visual Studio 2010 fornisce molti strumenti per gestire tutte le fasi di sviluppo e di manutenzione del software, mentre per il controllo delle versioni è consigliabile l’utilizzo di TFS 2010 (Team Foundation Server). Quest’ultimo è utilizzabile sia in “versione ridotta” per il singolo sviluppatore, sia su server per la gestione del codice e per la compilazione automatica per gruppi di sviluppatori.

Trattandosi di attività piuttosto articolate e complesse, data anche l’ampia gamma di strumenti disponibili, è consigliabile leggere o comunque consultare un buon libro. Anzi, visto che parliamo di due distinti software (Visual Studio 2010 e Team Foundation Server 2010) i libri che vi consiglio questa volta sono due!

Il primo è “Professional Application Lifecycle Management with Visual Studio 2010“, edito da Wrox (anno 2010, ISBN 978-0-470-48426-5, circa 700 pagine, prezzo 54,99 dollari) e frutto del lavoro di ben quattro autori: Mickey Gousset, Brian Keller, Ajoy Krishnamoorthy e Martin Woodward.

Il testo è formato dai seguenti capitoli:

PARTE 1 – ARCHITECT

Capitolo 1: Introduction to Software Architecture
Capitolo 2: Top-down Design with Use Case Diagrams, Activity Diagrams, and Sequence Diagrams
Capitolo 3: Top-down Deisgn with Component and Class Diagrams
Capitolo 4: Analyzing Applications Using Architecture Explorer
Capitolo 5: Using Layer Diagrams

PARTE 2 – DEVELOPER

Capitolo 6: Introduction to Software Development
Capitolo 7: Unit Testing with the Unit Test Framework
Capitolo 8: Managed Code Analysis and Code Metrics
Capitolo 9: Profiling and Performance
Capitolo 10: Database Development, Testing, and Deployment
Capitolo 11: Introduction to IntelliTrace

PARTE 3 – TESTER

Capitolo 12: Introduction to Software Testing
Capitolo 13: Web Performance and Load Testing
Capitolo 14: Manual Testing
Capitolo 15: Coded User Interface Testing
Capitolo 16: Lab Management

PARTE 4 – TEAM FOUNDATION SERVER

Capitolo 17: Introduction to Team Foundation Server
Capitolo 18:Team Foundation Architecture
Capitolo 19: Team Foundation Version Control
Capitolo 20: Branching and Merging
Capitolo 21: Team Foundation Build

PARTE 5 – PROJECT/PROCESS MANAGEMENT

Capitolo 22: Introduction to Project Management
Capitolo 23: Process Templates
Capitolo 24: Using Reports, Portals, and Dashboards
Capitolo 25: Agile Planning Using Planning Workbooks
Capitolo 26: Process Template Customizations

Quasi 150 pagine (capitoli 17-21) sono dedicati a TFS, per imparare i concetti basilari di questo importante prodotto. In seguito si potrà affrontare il seguente libro che vi propongo e precisamente “Professional Team Foundation Server 2010“, anche questo edito da Wrox (anno 2011, ISBN 978-0-470-94332-8, circa 720 pagine, prezzo 49,99 dollari) e frutto ancora di quattro autori: oltre a Martin Woodward e Brian Keller (autori anche del primo libro di questa recensione) troviamo Ed Blankenship e Grant Holliday.

Come ci si può aspettare dal titolo, questo libro approfondisce tutti gli ambiti di TFS 2010: dalla installazione, alla configurazione e all’amministrazione.

Il testo è formato dai seguenti capitoli:

PARTE 1 – GETTING STARTED

Capitolo 1: Introducing Team Foundation Server 2010
Capitolo 2: Planning a Deployment
Capitolo 3: Installation and Configuration
Capitolo 4: Connecting to Team Foundation Server

PARTE 2 – GETTING STARTED

Capitolo 5: Overview of Version Control
Capitolo 6: Using Team Foundation Version Control
Capitolo 7: Ensuring Code Quality
Capitolo 8: Migration from Legacy Version Control Systems
Capitolo 9: Branching and Merging
Capitolo 10: Common Version Control Scenarios

PARTE 3 – PROJECT MANAGEMENT

Capitolo 11: Introducing Work Item Tracking
Capitolo 12: Customizing Process Templates
Capitolo 13: Reporting and SharePoint Dashboards

PARTE 4 – TEAM FOUNDATION BUILD

Capitolo 14: Overview of Build Automation
Capitolo 15: Using Team Foundation Build
Capitolo 16: Customizing the Build Process

PARTE 5 – ADMINISTRATION

Capitolo 17: Introduction to Team Foundation Server Administration
Capitolo 18: Scalability and Hig Availability
Capitolo 19: Disaster Recovery
Capitolo 20: Security And Privileges
Capitolo 21: Monitoring Server Health and Performance
Capitolo 22: Testing and Lab Management
Capitolo 23: Upgrading from Earlier Versions
Capitolo 24: Working with Geographically Distributed Teams
Capitolo 25: Extending Team Foundation Server

Potrà sembrare un commento superfluo, perché l’avevo scritto anche in altre recensioni, ma mi piace sottolineare ancora una volta che le pubblicazioni Wrox sono graficamente piacevoli, con una bella impaginazione, un carattere chiaro e leggibile, immagini di buona definizione e comprensione e note ben visibili e graficamente distinguibili per importanza.

Ovviamente i due libri hanno pochissimo codice, perché sono focalizzati più sulla gestione dello sviluppo dei progetto, ma credo che siano entrambi dei libri indispensabili a uno sviluppatore che voglia fare qualcosa di più che scrivere semplicemente codice.

Un sincero “grazie” a Dave Allen di Wiley (www.wiley.com) che mi ha dato l’opportunità di esaminare i due libri presentati in questa recensione!

Il nuovo riferimento per gli sviluppatori: sviluppareperwindows.it

Mario De Ghetto — Sun, 05 Jun 2011 06:33:47 +0000

Microsoft Italia ha lanciato il nuovo portale per gli sviluppatori “Sviluppare per Windows” (http://msdn.microsoft.com/it-it/gg649876).

Vi potete trovare tutte le risorse utili per sviluppare su qualsiasi piattaforma: Windows Desktop, Windows Azure, Windows Phone, Silverlight e molto altro.

Vi consiglio quindi di aggiungere il link sopra indicato tra i vostri preferiti e di consultare periodicamente i contenuti del portale, perché prossimamente saranno aggiunti molti materiali utili per lo sviluppo di qualsiasi tipo di applicazione abbiate in mente!

Windows Azure: calcolatore dei costi

Mario De Ghetto — Wed, 25 May 2011 15:36:59 +0000

Uno dei problemi principali che fa riflettere molti è il problema di calcolare i costi di un’applicazione su Windows Azure: quanto incide il tipo di istanza, quanto la dimensione del database e il numero di query? Per non parlare di altri servizi…

In un post di oggi, in relazione alla recensione del libro “Windows Azure” di Fabio Cozzolino, ho evidenziato come in questo libro sia spiegato in modo preciso come calcolare i costi dell’utilizzo di Windows Azure.

Se volete qualcosa di più, magari di “automatico”, potete fare riferimento a questa pagina:

http://www.microsoft.com/windowsazure/pricing-calculator/

Infatti, come potete vedere dalla seguente figura, è possibile dimensionare ogni aspetto dei servizi che ci servono, per capire esattamente quanto è il costo mensile.

Ma cosa volete più di così?