Ecco una bella notizia che mi ha fatto cominciare l'anno nel migliore dei modi.

Microsoft Corp. ha confermato Giuseppe Dimauro e il sottoscritto come gli unici due Regional Director per l'Italia, per gli anni 2008-09. E' una grande soddisfazione far parte di una elite di soli 140 esperti in tutto il mondo - a differenza di altri gruppi come gli MVP, il numero degl RD è "contingentato", tipicamente 1 o 2 per ciascuna nazione e per ciascuno dei 50 stati degli USA. Negli ultimi tempi il Regional Director Program si è arricchito di un sito tutto nostro, che funge anche da aggregatore dei blog. Data la qualiltà del materiale che si può trovare, è quasi meglio di una rivista tecnica.

In questo periodo sto facendo molta consulenza per aziende italiane alle prese con la migrazione da VB6, usando ovviamente la versione preliminare di VB Migration Partner. Oramai la beta è stabile e si comporta davvero molto bene. In un solo giorno, ad esempio, abbiamo migrato una applicazione di circa 20mila righe che lavora in modo intensivo con ADO in circa mezza giornata, e tutto funziona a meraviglia!

Anche se la migrazione sta andando bene, a volte i programmi migrati sono più lenti del codice VB6 originario. Per esperienza le cause sono principalmente due: (1) l'uso di COM Interop per accedere agli oggetti ADO, (2) un uso massiccio di concatenazione di stringhe. Per il primo problema non c'è molto da fare, purtroppo: occorre migrare il codice di accesso al database da ADO a ADO.NET, un compito più semplice a dirsi che a farsi. Per il secondo problema ci sarebbe invece una soluzione semplice: basterebbe sostituire la variabile stringa con una variabile StringBuilder, e le concatenazioni sarebbero automaticamente più veloci. Peccato che questa sostituzione comporti una revisione completa del codice, perchè richiede di trasformare tutti gli operatori & (concatenazione) con il metodo Append, per non parlare dei casi in cui la variabile stringa viene usata come argomento a funzioni come Trim o Left. Ad esempio, il seguente codice richiede ben 17 secondi sul mio sistema a 3GHz:

Dim s As String = ""
Dim sw As Stopwatch = Stopwatch.StartNew()
For i AsInteger = 1 To 100000
    s = s + "*"
Next
MsgBox(sw.Elapsed.ToString)

Per fortuna la soluzione è davvero semplice: basta creare una classe che utilizzi internamente un oggetto StringBuilder, che ridefinisca gli operatori & e +, e che supporti la conversione implicita da-a stringa. Il codice di questa classe StringBuilder6 si scrive davvero in pochi minuti:

    Private buffer AsNew StringBuilder

    ' return the inner string

    Public Overrides Function ToString() AsString
        Return buffer.ToString()
    EndFunction

    Public Shared Operator +(ByVal op1 As StringBuilder6, ByVal op2 AsString) As StringBuilder6
        op1.buffer.Append(op2)
        Return op1
    EndOperator

    Public Shared Operator &(ByVal op1 As StringBuilder6, ByVal op2 AsString) As StringBuilder6
        op1.buffer.Append(op2)
        Return op1
    EndOperator

    ' convert to string

    Public Shared Widening Operator CType(ByVal op As StringBuilder6) AsString
        Return op.ToString()
    EndOperator

    ' convert from string

    Public Shared Widening Operator CType(ByVal str AsString) As StringBuilder6
        Dim op AsNew StringBuilder6()
        op.buffer.Append(str)
        Return op
    EndOperator

EndClass

A questo punto per velocizzare il codice visto prima è sufficiente modificare UNA SOLA ISTRUZIONE, ovvero la dichiarazione della variabile stringa:

Dim s As StringBuilder6 = ""

L'altro giorno un nostro amico-cliente ci chiama per un problema con un controllo WinForm wordprocessor-like. Nella loro applicazione usano questo controllo anche per la capacità di importare HTML, solo che a un certo punto scoprono che il controllo va in crash se il test HTML contiene un tag IMG con attributo ALIGN e che punta a una immagine "remota", ovvero il cui URL comincia per http:// , come in questo esempio:

   <IMG SRC="http://www.somesite.com/image.jpg" ALIGN=left WIDTH=100>

Con un po' di tentativi scoprono che il problema è la presenza dell'attributo ALIGN e che il crash si può evitare se si trasforma l'HTML in questo modo:

   <DIV style="float:left"><IMG SRC="http://www.somesite.com/image.jpg" WIDTH=100></DIV>

in altre parole, occorre eliminare l'attributo ALIGN dall'interno del tag IMG e renderlo come style di un blocco DIV che racchiude il tag IMG. Questa sostituzione va fatta un attimo prima di caricare il testo HTML nel controllo, ma solo se il tag IMG contiene un attributo ALIGN e solo se l'URL dell'immagine comincia con i caratteri "http://". Il tutto è complicato dal fatto che il valore dei vari attributi può essere o non essere racchiuso tra virgolette. Insomma, un bel problemino.

Ovviamente, la soluzione sarebbe stata basata su qualche regex, ma era la prima volta che mi imbattevo in un caso di questo tipo. I problemi da risolvere erano principalmente due: come agire solo sui tag IMG contenenti un SRC remoto e come fare per "spostare" solo l'attributo ALIGN, senza toccare tutti gli altri attributi che compaiono nel tag IMG. Il primo problema lo si risolve con le cosiddette positive look-ahed assertion, ovvero il costrutto (?=...), che permette di controllare che esista una certa sottostringa a destra della regex principale, ma senza consumare caratteri per il match. Il secondo problema si risolve facilmente se si pensa a suddividere l'intero contenuto del tag IMG in tre gruppi: il gruppo pre contiene tutti i caratteri prima dell'attributo ALIGN, il gruppo align contiene il valore dell'attributo ALIGN, e il gruppo post contiene tutti i caratteri dopo l'attributo align. Ecco la soluzione in VB e C#:

   Dim search As String = "<img(?=.*src=\""?http://.*?>)(?=.*\balign=.*?>)(?<pre>[^>]*)\balign=\""?(?<align>[^ \""]+)\""?(?<post>[^>]*>)"
   Dim replace As String = "<div style=""float:${align}""><img ${pre} ${post}</div>"
   Dim result As String = Regex.Replace(htmlText, search, replace, RegexOptions.IgnoreCase Or RegexOptions.Multiline)

La cosa notevole non è tanto che questo problema è risolvibile con le regex - lo davo per scontato, in effetti - ma che possa essere risolto senza implementare un loop o un metodo di callback per il replace.

VB Migration Partner - il progetto a cui ho lavorato praticamente a tempo pieno negli ultimi 22 mesi è finalmente in beta!

Cosa faccia questo tool lo dice il suo nome: è un convertitore di applicazioni da VB6 a VB.NET. Immagino bene che a questo punto molti di voi scrolleranno le spalle e penseranno "Ancora VB6?" oppure "Ecco un altro che ci tenta!", ma la verità è che VB6 continua a imperversare tra le software house, anche e soprattutto perchè non ci sono strumenti decenti per convertire centinaia di migliaia di righe di codice VB6 in VB.NET, in modo veloce e (almeno relativamente) indolore. Davanti alla prospettiva di sprecare diversi anni uomo di lavoro sulla migrazione di un gestionale VB6 complesso, e di dover fare tutto a mano, beh... sono in molti a farsi indietro. Ora però ci si sta rendendo conto che la decisione non può più essere rimandata: è risaputo che i programmi VB6 non funzionano bene sotto Vista (in particolare, non funzionano molti controlli ActiveX) e soprattutto Microsoft ha dichiarato che il supporto esteso per VB6 termina a Marzo del 2008

Il problema dei convertitori automatici di codice è che quasi mai mantengono le promesse, si tratti di conversione da VB6, Java, Delphi, o qualsiasi altro linguaggio. Nel migliore dei casi, riescono a convertire circa il 95% delle istruzioni, ma con una applicazione VB6 da 100mila righe (quindi neanche estremamente complesse), il 5% di istruzioni errate significa dover mettere mano a cinque mila righe! Quel che è peggio è che quasi sempre non si tratta di piccole modifiche che prendono qualche minuto. Ad es. VB6 e VB.NET espongono due modelli completamente differenti per le istruzioni grafiche, il printing, e il drag-and-drop, quindi in realtà anche se il compilatore VB.NET segnala relativamente pochi errori, in effetti per implementare grafica, printing, e D&D in VB.NET occorrerà rifare intere porzioni di programma. Per non parlare di tutti i controlli ActiveX non supportati, il databinding, e tanto altro.

Nei test che abbiamo eseguito su centinaia di applicazioni VB6 (circa un milione di righe di codice in totale), VB Migration Partner offre la notevole media di un errore di compilazione ogni 1,100 righe di codice, ovvero una percentuale di precisione superiore al 99.9%. Scusate se è poco! Del resto, per avere una idea della precisione di questo strumento, basta un piccolo elenco delle feature di VB6 che sono pienamente supportate (eccetto dove indicato) e che sono quasi tutti fuori dalla portata di qualsiasi altro strumento sul mercato, incluso ovviamente l’Upgrade Wizard incluso in Visual Studio:

• array con indice LBound diverso da zero
• Gosub, On...Goto, e On ...Gosub
• variabili auto-instancing (Dim x As New Person) che mantengono il comportamento anche in VB.NET
• Declare con parametri As Any e indirizzi di callback (es. EnumWindows)
• proprietà di default risolte correttamente anche in modalità late-bound
• finalizzazione deterministica per le variabili di tipo Connection, Recordset, ecc., ad es. per ottenere che la connessione sia chiusa quando la variabile è messa a Nothing o esce dallo scope
• supporto (limitato) per Variant e propagazione dei valori Null
• tutti i 60+ controlli di VB6 (uniche eccezioni: OLE e Repeater)
• control array, anche di controlli ActiveX di terze parti
• menu popup
• metodo Controls.Add e oggetti VBControlExtender per creare dinamicamente form di data entry
• metodi grafici (Line, Circle, PSet, PaintPicture, ecc.) con supporto per ScaleMode custom
• oggetto Printer e collection Printers
• OLE drag-and-drop
• UserControl, con supporto di feature avanzate e oggetti Ambient e Extender
• data-binding con controlli Data ADO, RDO, ADO, con recordset ADO, con DataEnvironment
• classi DataEnvironment non gerarchici
• classi e user control ADO data source e simple data consumer
• classi MultiUse, PublicNotCreatable, GlobalMultiUse
• classi persistable, classi MTS/COM+

In realtà, è più semplice elencare cosa il nostro tool non supporta: gli UserDocument, le PropertyPage, le WebClass, gli DHTML Page designer, istruzioni non documentate (VarPtr, ObjPtr, StrPtr), il drag-and-drop “classico” (non OLE D&D), e poco altro.

VB Migration Partner è in grado di convertire un intero gruppo di progetti VB6 in una sola operazione, e riesce a generare codice di migliore qualità proprio perchè riesce a vedere “dentro” una DLL che fa parte del project group. Il tool dispone anche di un code analyzer molto sofisticato, in grado ad esempio di segnalare classi, metodi, e variabili non utilizzate: se si considera che in un progetto di grandi dimensioni che si è evoluto negli anni molto spesso il 5-10% di codice è “dead code”, si vede che questa feature da sola è in grado di far risparmiare parecchio tempo prezioso.

Uno dei segreti dell’alto tasso di conversione senza errori è il supporto per i migration pragmas. Un pragma di migrazione non è che uno speciale commento inserito nel codice VB6 che indica a VB Migration Partner come convertire certi costrutti che permettono approcci differenti. Per esempio, il seguente pragma ArrayBounds indica che l’indice di tutti gli array nel progetto corrente deve essere forzato a zero:

          '##project:ArrayBounds ForceZero

I pragma possono avere scope di progetto, di classe, di metodo o di singolo elemento; un pragma ha sempre la precedenza su tutti i pragma dello stesso tipo con scope più ampio. Per esempio, io posso fare l’override del precedente pragma dentro un metodo, e specificare un ulteriore pragma relativo ad uno specifico array:

          Sub Test()
             '## ArrayBounds Shift
             '##arr.ForceZero
             Dim names(1 To 10) As String
             Dim values(1 To 10) As Long
             Dim arr(1 To 10) As Integer
          End Sub

L’opzione Shift indica a VB Migration Partner che i valori di LBound e UBound dell’array devono essere “shiftati” verso lo zero, in modo da preservare il numero di elementi dell’array originario in VB6:

          Sub Test()
             Dim names(9) As String
             Dim values(9) As Integer
             Dim arr(0 To 10) As Short
          End Sub

VB Migration Partner supporta una cinquantina di pragma per gli scope più differenti. Ad esempio, SetName modifica il nome di un elemento, SetType il suo tipo, AutoNew implementa il comportamento auto-instancing delle variabili As New, AutoDispose fa sì che le variabili siano “disposed” correttamente prima di essere impostate a Nothing, ecc.

Uno dei difetti principali di un tool di conversione “tradizionale” è il fatto che – dopo la prima conversione – il progetto originario VB6 e il nuovo progetto VB.NET vivono due vite completamente separate. Se la migrazione dura settimane o mesi – com’è plausibile per i gestionali di grandi dimensioni – quando finalmente il programma VB.NET compila ed esegue senza errori il codice sarà già “vecchio”, ovvero non allineato alle modifiche e ai bugfix che nel frattempo sono state apportate al programma VB6.

Per evitare questo problema, VB Migration Partner offre il supporto al cosiddetto ciclo convert-test-fix. In pratica, si tratta della possibilità di migrare in modo iterativo un determinato progetto VB6 raggiungendo lo stadio “zero compilation error” e poi “zero runtime error” semplicemente arricchendo il sorgente VB6 con degli opportuni pragma, ma senza modificarlo in altro modo. Grazie al ciclo convert-test-fix è possibile affrontare migrazioni complesse – che possono durare anche settimane o mesi – mantenendo sempre sincronizzati le versioni VB6 e VB.NET della applicazione.

Io sono particolarmente contento delle feature del refactoring engine, che dopo la prima conversione “grezza” applica al codice VB.NET numerose tecniche di ottimizzazione. Ad esempio, è in grado di accorpare la dichiarazione e l’inizializzazione di variabili, di generare istruzioni Return, di sfruttare gli operatori composti di assegnazione (tipo += e *=), e di altro ancora:

Function GetValue() As Long     =>     Function GetValue() As Integer
   Dim x As Long                          Dim x As Integer = 123
   x = 123                                ...
   ...                                    If x > 0 Then
   If x > 0 Then                             Return x
      GetValue = x                        ElseIf x = 0 Then
	  Exit Function                          Return -1
   ElseIf x = 0 Then                      End If
      GetValue = -1                       ...
	  Exit Function                       x += 1
   End If                                 ...
   ...                                 End Function
   x = x + 1
End Function

Ci sono altri tipi di refactoring che si possono ottenere mediante opportuni pragma. Ad esempio, è possibile inserire la dichiarazione di una variabile dentro un ciclo For o For Each, come in questo esempio:

Dim i As Integer                =>     For i As Integer = 1 To 100
For i = 1 To 100                          ...
   ...                                 Next
Next

Ciliegina sulla torta: nonostante tutte queste feature VB Migration Partner è circa 8 volte più veloce dell’Upgrade Wizard incluso in Visual Studio. Devo dire che mi sono tolto una bella soddisfazione!

Siamo alla fine di questo lungo post, ma ne seguiranno altri. Potete scoprire tutto (ma veramente tutto!) su VB Migration Partner sul nuovo sito www.vbmigration.com, dove troverete anche molto materiale sulla migrazione tout court nonchè il mio nuovo blog in inglese, tutto dedicato alle problematiche di migrazione da VB6.

Silverlight in primis, ma anche le anteprime di Visual Studio 2008 e Windows server 2008, sono solo alcune delle novità che promettono un inverno più caldo di questa torrida estate italiana.

Un aspetto trascurato, ma che non può lasciarci indifferenti, è che molte di queste novità hanno avuto un contributo da rappresentanti del Bel Paese. Sviluppatori, program manager, tester, evangelisti, ognuno di questi ruoli è rappresentato anche da italiani illustri come Vittorio Bertocci, Marco Ottaviani, il caro Aldo Donetti e molti altri. Vi segnalo una iniziativa da non perdere legata al nuovo tag center di Channel9: Italia9. Vittorio Bertocci, si prodigherà in una serie di interviste, rigorosamente in italiano, in giro per il campus di Redmond parlandoci direttamente nella nostra lingua. Grande !!! Altre interviste saranno disponibili nei prossimi mesi; in linea è già disponibile la prima, fatta a Marco Ottaviani, devlead per le Performance nel Connected Framework team (Windows Communication Foundation, Windows Workflow), nella quale Marco ci mostra qualche errore tipico in cui si può incorrere quando si cerca di misurare le performance di WCF e ci svela quali strumenti utilizza nel suo mestiere.

Che dire, un plauso a Vittorio e a tutti quelli che stanno sostenendo questa straordinaria inziativa oltre ad un in bocca al lupo per il prosieguo del lavoro a tutti i nostri connazionali oltreoceano dei quali essere orgogliosi.

Oggi gironzolavo per la rete e ho trovato un forum dove qualcuno poneva la seguente domanda: "data la stringa ABCD è possibile scrivere una regular expression che fa il match con un qualsiasi anagramma di tale stringa - ad es. DBAC o CDBA ma non ABDE oppure AABC?". Ovviamente la domanda era intrigante per uno che come me smanetta molto con le regex, e stranamente non l'avevo mai vista in giro. Qualcuno obiettava che le regex non erano abbastanza potenti, e che serviva scrivere un piccolo programmino per testare le varie combinazioni, quindi mi sono sentito in obbligo di pensarci un po' su e postare la mia soluzione.

Se state semplicemente controllando che una stringa fornita dall'utente sia una permutazione di ABCD la soluzione è in effetti molto semplice:

^(?=.*a)(?=.*b)(?=.*c)(?=.*d)[abcd]{4}$

dove il costrutto (?=.*a) si chiama positive lookahead ed esegue il match con l'espressione nella parentesi ma senza consumare caratteri, quindi in altre parole significa che la stringa deve contenere il carattere A da qualche parte, ovvero preceduto da zero o più caratteri. Con le successive espressioni positive lookahead si controlla che nella stringa ci siano anche i caratteri B,C e D. Quando questa fase è completata, la regex [abcd]{4} assicura che la stringa contenga solo questi quattro caratteri e non altri.

Se invece stiamo cercando tutti i possibili anagrammi di ABCD all'interno di un testo di lunghezza qualsiasi, allora la regex è solo leggermente più complicata:

\b(?=.{0,3}a)(?=.{0,3}b)(?=.{0,3}c)(?=.{0,3}d)[abcd]{4}\b

In questo caso oltre a imporre che i caratteri A,B,C,D siano tutti presenti ci accertiamo anche che non distino più di 3 caratteri dall'inizio della parola, e usiamo i delimitatori \b per imporre che la parola stessa contenga esattamente quattro caratteri. Ovviamente dovete specificare se il case dei caratteri è significativo o meno, perchè il match avvenga indipendentemente dal fatto che le parole siano in maiuscolo o minuscolo.

Sembra siano state scattate nella Silicon Valley e stanno diventando la barzelletta tra molti anti-Microsoft-tiani. Le potete trovare a questo indirizzo.

Ovviamente, il problema non è nella tecnologia ma in quanto bene (o male, in questo caso) la si usa. Quanto costava controllare meglio gli errori o redirezionarli su una pagina più "carina"? Sicuramente meno della brutta figura che la ditta di mobili svedese (e non Microsoft) sta facendo.

Ecco un post che ha poco a che fare con la tecnologia e molto a che fare con il lavoro.

Il nostro amico Eugenio Lamesa, il migliore esperto che abbiamo in Italia di Mail Marketing nonchè la mente dietro il programma/sito SalesWare (a cui sono orgoglioso di aver contribuito come consulente) ha da poco inaugurato il sito TuaPensione.it, dedicato a chi entro il 30 giugno deve decidere cosa fare del proprio TFR.

Tra le tante iniziative Eugenio ha preparato una whitepaper che spiega in modo chiaro e sintetico i dettagli della nuova leggere e come prendere la decisione più giusta e conveniente. Non solo le informazioni sono più chiare e dirette di quelle che ho potuto leggere su alcuni giornali, ma sono anche depurate dai possibili "conflitto di interessi" che abbondano anche in questo settore. Da qualche giorno su sito c'è anche un interessante calcolatore online, che permette di confrontare le varie opzioni. TuaPensione.it è assolutamente no-profit (non ci sono neanche i banner di Google!), come lo è MenoStato.it, l'altro sito a cui Eugenio lavora con passione da qualche anno.