Forse perchè Cecile è nera? Ah, ma allora non presumo più che siate razzisti: lo siete punto e stop.

Detto questo, vi consiglio la seguente lettura, che riporta tutti personaggi politici, che siedono (oggi o in precedenza) in Parlamento, alla Camera, che magari sono stati Ministri della Repubblica oppure no.

Melandri Giovanna, nata a New York (USA)
http://it.wikipedia.org/wiki/Giovanna_Melandri

Josefa Idem, nata a Goch (Germania)
http://it.wikipedia.org/wiki/Josefa_Idem

Archi Bruno, nato a Ixelles (Belgio)
http://it.wikipedia.org/wiki/Bruno_Archi

Calabria Annagrazia, nata a New York (USA)
http://it.wikipedia.org/wiki/Annagrazia_Calabria

Gallo Riccardo, nato a Montevideo (Uruguay)
su Wikipedia non esiste

Gutgeld Itzhak Yoram, nato a Tel Aviv (Israele)
http://it.wikipedia.org/wiki/Itzhak_Yoram_Gutgeld

Marzana Maria, nata a LUDWIGSHAFEN AM RHEIN (Germania)
http://it.wikipedia.org/wiki/Maria_Marzana

Matarelli Toni, nato a KREFELD (Germania)
http://it.wikipedia.org/wiki/Toni_Matarrelli

Piras Michele, nato a DARMSTADT (Germania)
http://it.wikipedia.org/wiki/Michele_Piras

Non sono tanti, è vero, comunque ci sono esponenti politici, non nati in Italia, che sono lì a lavorare per noi, perchè credo che si sentano italiani, e che lo sono a tutti gli effetti, indipendentemente dal loro credo religioso, dal colore della loro pelle, dalla forma degli occhi, dall’accento che hanno, e così via. Insomma, sarebbe ora di guardare le competenze, e non l’aspetto fisico, non credete?

Perciò, cari amici e parenti, fatemi capire: ce l’avete solo con Cecile Kyenge, oppure anche le persone sopra elencate, secondo voi, non dovrebbero diventare Ministri? Giusto per capire…

var array = Enumerable.Repeat<byte>(0xFF, 100).ToArray();

Con una sola rapida riga di codice, otteniamo un bell’array, in questo caso di 100 elementi, tutti valorizzati a 0xFF (ovvero 255 decimale). Comodo. Grazie Linq!

Anno 1817 – Da qualche parte a Vienna (Austria)

E’ ancora buio, l’uomo è già sveglio, e rimane sotto le coperte del suo letto. E pensa.

”E’ l’alba, e non riesco a dormire. E sono sordo, non posso più negarlo, dannazione. E’ poco più di vent’anni che le mie orecchie non funzionano più come un tempo. Sono peggiorate. Nessun medico è stato in grado di aiutarmi. Ed oggi sono completamente sordo, dannazione. E per un musicista non c’è nulla di peggiore che l’esser sordi. Passo notti inquiete ed agitate; sento musica, note, accordi e sinfonie che prendono vita nel mio cuore e dentro di me…musica a cui non riesco a dar forma la mattina dopo, quando poi mi sveglio. Non penso di farcela, di andare avanti, da oggi vivrò isolato, in sofferenza, e non mi importa nulla di quello che potrà pensare la gente di me. Mi crederanno pazzo, ostile, scontroso, un misantropo fallito. Ma non mi importa di loro, e comunque non ho scelta. Molto probabilmente dovrò anche abbandonare la mia musica, che è stata la grande ispirazione della mia vita. E lo sarà sempre.”

Dal futuro
Il viaggio nel tempo non è stato ancora inventato. Ma lo sarà molto presto. Il primo esperimento considerato valido di viaggio nel tempo, secondo Wikipedia, avverrà il 17 Febbraio 2031. Per voi che state leggendo è il futuro, per me che vi scrivo è il passato. Non posso dirvi dove avverrà e chi sarà a capo di tutto questo, rischierei di alterare troppo il normale continuum del tempo. Il primo viaggio nel tempo sarà ovviamente una cosa molto semplice: il trasferimento di qualche molecola di H₂O, acqua, quattro secondi dal passato. La vera rivoluzione (disponibile però solo ad università, enti paramilitari ed alcune società hi-tech), verrà introdotta solamente due anni più tardi, con l’invenzione di quello che verrà poi battezzato semplicemente come “il lazo del tempo”.

Tutti sappiamo – credo – cosa sia un lazo. E’ quello strumento utilizzato dai cowboy nordamericani per praticare il cosiddetto roping, ovvero la cattura di quadrupedi o di bestiame, attraverso il lancio di un’estremità della corda avente la forma di un cappio. Nel caso del viaggio nel tempo le cose sono più complesse, ovviamente, ma non andiamo OT, tralasciamo equazioni quantistiche, fluttuazione delle costanti universali e materiali utilizzati nel processo: spiegandolo con parole semplici, e rimanendo ad un livello puramente concettuale, le cose sono molto simili.

Possiamo lanciare il lazo nel passato o nel futuro, e prelevare quindi materia passata o futura.
Possiamo accorciare od allungare la corda del lazo, per muoverci più vicino o più lontano nel tempo.
Possiamo stringere od allargare il cappio, per prelevare oggetti di massa più o meno grande.

Gli oggetti devono essere di natura molto semplice. Dal punto di vista molecolare, intendo. Non riusciamo a prelevare persone, nè animali, nè organismi viventi; o meglio, non riusciamo a prelevarle mantenendone intatte le funzioni vitali. Ci abbiamo provato, chiaramente, ma i risultati sono stati alquanto sconfortanti. Sorvoliamo. La materia, dicevo, deve essere semplice. Un conto è ad esempio campionare qualche goccia d’acqua del Mediterraneo di mille anni fa, un altro è tentare di evitare l’assassinio di Kennedy asportando temporalmente il fucile di Lee Harvey Oswald a Dallas. Un conto è prelevare un qualsiasi brandello di pianta carnivora del Giurassico, un altro è prelevare il primo telegramma della storia inviato da Samuel Morse. Senza considerare poi le conseguenze nel continuum temporale, come dicevo prima. Insomma, dobbiamo essere cauti, dobbiamo valutare con attenzione cosa, dove e quando prelevare un determinato oggetto. Riflettere sui pro e sui contro.

Tre infatti sono le variabili in gioco.

Chiaramente il quando. Allungando il lazo, continuamo la metafora, si viaggia più distanti nel tempo. Accorciandolo si viaggia più vicini. Più la distanza temporale da coprire è grande, maggiore è il dispendio di energia che occorre per completare il viaggio. Grazie all’adozione di batterie nucleari dedicate, siamo in grado di viaggiare fino ad un limite di 25 miliardi di anni nel passato; l’età dell’Universo calcolata è di 13,77 miliardi di anni, e non si sa bene cosa debba accadere se si tenta di viaggiare più in là. Ma le equazioni quantistiche comunque lo dimostrano, e ci sono orde di scienziati e di fisici virtuali e reali al lavoro per riuscire a carpire questi nuovi segreti della realtà.

Un’altra variabile è il dove. Possiamo lanciare il lazo specificando latitudine, longitudine ed altitudine: questo chiaramente se vogliamo interagire con un luogo collocato sul nostro pianeta. Le equazioni dimostrano che possiamo raggiungere qualsiasi luogo dell’Universo, manipolando opportune variabili. Ad oggi non abbiamo ancora raggiunto queste capacità: le nostre tecnologie attuali ci consentono di prelevare oggetti nel raggio di circa 515,34 chilometri rispetto al punto in cui ci troviamo. Nessuno riesce a capire da dove arrivi questo limite di 515,34 chilometri. Quello che abbiamo capito è che se mi trovo in un punto X, posso prelevare ogni tipo di materia che si trovi in un’area compresa in un raggio di 515,34 chilometri: chiaramente nel quando desiderato. Oltre…la materia temporale arriva delocalizzata.

L’ultima variabile è il cosa, che di riflesso indica le dimensioni di materia da prelevare. Le dimensioni possono andare da una semplice molecola fino ad interi chilometri cubi di terreno. Dipende ancora una volta dall’energia che si intende consumare nell’operazione. Gli aerei sono stati un semplice diversivo per farvi credere determinate cose, ma è che così che la futura Al-Qaida ha fatto crollare le Torri Gemelle, l’11 Settembre 2001: semplicemente rimuovendo in un istante le gigantesche fondamenta su cui poggiavano i due enormi palazzi del World Trace Center. E’ così che abbiamo rimosso – a scopo di studio – il naso della Sfinge, che secondo la vostra storia convenzionale è stato distrutto in epoca ottomana. E’ così che abbiamo evitato che gli attentati ad Hitler riuscissero: avevamo bisogno che la II° Guerra Mondiale si concludesse come si è conclusa davvero.

Chiaramente, è molto meno rischioso interagire con il passato piuttosto che con il futuro. Il motivo è semplice. Trattandosi di storia già avvenuta, sappiamo quando e dove un certo oggetto si sia venuto a trovare, e quindi possiamo agire con migliori probabilità di successo. Non è sempre così, chiaramente, dobbiamo tenere in considerazione precedenti modifiche al continuum temporale, ma in linea generale sì. Dal futuro abbiamo solamente raccolto piccoli campioni della nostra atmosfera, per studiare e prevenire i futuri inquinamenti. Stessa cosa per il sottosuolo, per la superficie lunare e per quella di Marte. Tutto a scopo scientifico.

Ben presto, il lazo del tempo è diventato ancora più potente. All’inizio – come vi ho raccontato – era solamente in grado di prelevare materia. Successivamente siamo riusciti a sviluppare nuove capacità, una su tutte quella di poter inviare materia.

E’ con queste nuove possibilità che riesco a scrivervi dal futuro. Inviando pochi brandelli di informazione, che vengono scritte direttamente sulla Internet dei giorni vostri. E’ così che riesco a comunicare con voi, a fornirvi indizi, a stuzzicarvi dicendovi dove siete e verso cosa state andando. Dal mio futuro abbiamo attentemente manipolato il passato, senza travolgere la Storia. Abbiamo acceso scintille in registi cinematografici e scrittori di fantascienza, trasformato persone comuni in visionari e vicini di casa in geniali inventori, evitato attentati e incidenti stradali. Magari facendo trovare idee, schemi, sceneggiature, ed in qualche caso denaro. Molto denaro. E’ agendo in questo modo che siamo riusciti ad iniettare tecnologie, invenzioni, muovere la coscienza, ad indirizzarvi.

Ma non vi ho ancora detto chi sono.
E non ho alcuna intenzione di farlo.

Anno 1817 – Da qualche parte a Vienna (Austria)
L’uomo si alzerà dal suo letto soltanto qualche ora più tardi. E’ allora che – aprendo un cassetto della sua camera da letto – trova uno spartito musicale. Il titolo è in italiano e recita “Sonata per pianoforte n. 29”. Non l’ha mai visto prima, quello spartito. E’ una strana carta, molto ben lavorata, e si chiede da dove arrivi e chi l’abbia prodotta. E soprattutto…che diavolo vuol dire carta riciclata? Sarà qualche diavoleria moderna – pensa.

Legge le note, rigo dopo rigo, battuta dopo battuta. E’ la sonata più lunga che abbia mai visto in tutta la sua vita, ed anche dal punto di vista armonico è decisamente complessa. Eppure – si rende conto l’uomo – può funzionare. Anzi, gli sembra meravigliosa…è una sonata in quattro tempi che richiederà un certo impegno tecnico per essere eseguita come si deve. Ma gli piace. E gli piace soprattutto perchè in basso a destra è riportata la firma dell’autore.

E’ non è una firma qualunque. E’ la sua.
E’ la firma di Ludwig van Beethoven.

E’ così che il grande compositore e pianista tedesco continuerà a produrre musica nonostante la sua totale sordità, che l’ha afflitto negli ultimi anni della sua vita.

Con qualche aiuto proveniente da qualche parte dal futuro.

1. Seleziona tutto il testo contenuto nell’editor (CTRL+A)
2. Fa un find & replace di tutti i caratteri “ “ (spazio) e lo sostituisce con “” (nessun carattere)
3. Mette la stringa tutta in maiuscolo, premendo la combinazione CTRL+SHIFT+U (upper-case)

Quindi, in pratica, incollo il testo, eseguo la macro e mi trovo una stringa pronta all’uso, da incollare da un’altra parte, dove mi serve.

Chiaramente ho salvato la macro.

Qual’è la posizione in cui Notepad++ salva le macro registrate?

Con Windows 8, il file è il seguente:

C:\Users\<vostro_username>\AppData\Roaming\Notepad++\shortcuts.xml

Una cosa importante da ricordare è che questo file viene effettivamente scritto soltanto nel momento in cui chiudete Notepad++, per cui evitate di guardare il file tenendo l’editor aperto, continuerete a vedere una versione più vecchia!

Perchè mi serviva sapere qual’è il file? Perchè in caso di formattone del pc, so qual’è il file da backuppare e restorare per ritrovarmi la macro già bella pronta all’uso sul nuovo OS.

La prima è che probabilmente se trova così affascinante la Stanza lo deve proprio a quei colori a metà strada tra alba e tramonto, che le regalano serenità e tranquillità in ogni momento. Una volta non sarebbe mai andata alla ricerca di quelle cose, ovviamente, ma alla fine quelle cose l’avevano raggiunta. Ed ormai non riesce più a farne a meno.

La seconda conclusione è che quella tavolozza di colori è sicuramente importante, ma c’è di più. C’è anche la melodia. E’ un brano semplice e soffice che le arriva dritto al cuore. Sono note digitali, chiaramente, uno stream wma, forse, campionato a 192kbps, forse. Non è schedulato, è totalmente asincrono, può arrivare da un momento all’altro senza preavviso, in orari AM o PM. E’ incuriosita; diverse volte ha pensato di lasciare la Stanza per indagare su quei suoni, ma poi ha sempre rinunciato. “Sicuramente si trovano su un altro piano di realtà, la UAC non mi darebbe accesso a quelle informazioni” – dice l’entità nel tentativo di convincere se stessa.

La terza conclusione è che c’è anche un terzo motivo. Il tocco. Il tocco la spaventa e la esalta allo stesso tempo. Arriva d’improvviso, a volte è leggero come una string.Empty, altre volte è pesante come una StackOverflowException con tutto lo StackTrace in allegato. Ma l’entità è spaventata soprattutto da una cosa.

Nel mondo totalmente digitale nel quale vive, il tocco è l’unico evento analogico che le sia capitato.

Mission Briefing
Quando il generale entra nel piccolo offset di memoria allocato per l’incontro segreto, gli altri si zittiscono all’istante. E’ esadecimalmente molto alto, e basta la sua sola presenza per trasmettere timore. E’ stanco, ma cerca di non darlo a vedere. Ha trascorso l’ultima notte in missione operativa, cominciata da qualche parte nel sistema con una chiamata ad un non meglio precisato metodo RunAsync(). La lettura di uno stream http, qualche calcolo matematico con le informationi recuperate e la restituzione di un’istanza di una class. Pensava di aver finito, ed invece il metodo proseguiva per altre 737 linee di codice managed davvero intenso. Se avesse potuto avrebbe parlato direttamente con il developer responsabile di quell’assurdità: gli avrebbe detto che uno dei motivi per cui è buona cosa scrivere metodi semplici e chiari, è che ogni entità software prima o poi deve riposarsi, dal byte alla classe più complessa. Un metodo deve avere una sua responsabilità, chiara e dettata dal suo nome: poche linee di codice efficaci e pulite. Miglior leggibilità, manutenzione e conseguente minor complessità del sistema software: sono tutte direttive che un buon dev dovrebbe seguire, ma che riguardano anche le parti più nascoste dell’hardware. Ed a volte non ci si pensa. Prova quasi dolore per la stanchezza, vorrebbe quasi un Dispose() da bere per rilassarsi, ma si siede e scruta i volti degli altri con asprezza.

“Signori, è l’ora di agire. Una fonte sicura ci ha indicato la posizione del nostro obiettivo” – muove leggermente la mano, ed in quel momento parte della parete alle sue spalle si trasforma in uno schermo, su cui viene renderizzata la mappatura della mainboard di sistema, in alta definizione. Le diverse aree sono evidenziate con colori vivaci ed in continuo movimento. Non è per nulla un’immagine bitmap statica. Ha più l’aspetto di un’immagine trasmessa in streaming che mostra ciò che sta realmente accadendo, come fosse una ripresa satellitare. Si vedono chiaramente flussi di informazione digitale che viaggiano in lungo e in largo: input da console, stream audio, thread di esecuzione, http context e molto altro ancora.

Il generale fa un piccolo pinch con le dita, e la mappatura comincia uno zoom-in lento e costante. In poche centinaia di migliaia di battiti di clock, la mappatura mostrata è talmente ravvicinata che mostra solo una piccola area di memoria, proprio a ridosso del chipset SATA.

“E’ un’area hardware molto difficile da trovare, se non si sa bene dove guardare” – pensa entity[3], seduto al tavolo, osservando con attenzione lo schermo – “Quant’è sicura la fonte? Come hai fatto ad identificare la zona, quale engine è stato utilizzato?” – chiede.

“Intellitrace, per rispondere alla tua ultima domanda. E’ un debugger delle ultime versioni di Visual Studio, ma grazie ai nostri tecnici siamo riusciti a renderlo low-level, disponibile per le nostre ricerche a tappeto. Come vedete, l’obiettivo si nasconde bene: quella che vedete è una zona inesplorata, che nelle precedenti versioni dell’OS non era utilizzata – o perlomeno non era strutturata in quel modo. Macerie di aggregate root, residui di domini DDD, nascondono l’ingresso. Ottenere l’immagine dump live è stato piuttosto complicato. Quanto alla fonte…non posso rivelarla: conviene a lui, e conviene a tutti noi: ciascuna delle entità coinvolte nell’operazione deve conoscere solamente la parte di sua competenza”.

“Quando agiremo?”

“Molto presto. L’intelligence force brute è già in azione, presto avremo la callback per ottenere i privilegi adeguati. E quando gireremo come system administrators nulla potrà più fermarci. Ricordatevi: dobbiamo prenderlo vivo ed istanziato, se vogliamo risalire l’intero stacktrace e rientrare in possesso dell’intero gruppo. Le fasi sono essenzialmente tre: avvicinamento aereo tattico classe live-aero, irruzione di tipo break e prelevamento soggetto pop inoffensivo. Procedura standard. Dieci settori mobilitati: sei staranno di guardia, ai lati ed agli ingressi; gli altri quattro entreranno nella stanza e neutralizzeranno il soggetto. Ricordate, facciamo tutto questo in nome della sua sicurezza. Si comincia, signori: siamo in azione”.

La riunione durò ancora per molto poco. Il tempo di definire qualche dettaglio e la messa in produzione di un assembly, che sarebbe tornato utile per l’operazione. Poi l’offset venne rilasciato nuovamente disponibile alla memoria di sistema.

Irruzione
Quella mattina presto l’entità stava ancora dormendo tranquilla. I colori della sua alba preferita erano ancora lontani, e la Stanza era immersa nel buio. Poi tutto avvenne in pochi attimi. Una velocissima RotateTransform fece ruotare il soffitto: d’un tratto si ritrovò capovolto e sbattuto su un piano inferiore. Cadde sul ciglio di un bus x64, mancò di un soffio qualcosa, forse un array di string ad alta velocità, rotolò su un fianco e cadde nuovamente…l’imbuto filtrava i bytes in coda nella pipeline grafica…non appena venne texturizzato, l’entità subì un altro jump, fino a quando…winzip tentò di comprimerlo…l’entità lo lasciò fare…lo stream compresso venne trasferito in un folder SkyDrive, scatenando l’aggiornamento della corrispondente live tile.

Era sballottato, confuso e senza fiato. Era accaduto tutto in pochi istanti; conosceva quella tecnica di jumping, che permetteva di saltare da un execution context all’altro senza la minima coerenza. Spesso veniva usata per far perdere le proprie tracce, più spesso per disorientare e catturare qualcuno.

Non provò dolore fisico: semplicemente non riuscì a capire nulla di ciò che gli stava accadendo. Poi un’esplosione accecante portò foreground e background sulla stessa tonalità 0xFFFFFF, perse temporaneamente la vita, non aveva più alcun metodo per orientarsi, guardarsi attorno, e fuggire.

Non riuscì a fare nient’altro che stare fermo ed immobile. Solo silenzio. Man mano che passava il tempo, l’entità tornò a vedere l’ambiente circostante. Con suo grande disappunto, si trovava ancora nella sua Stanza. Possibile che fosse stato tutto un sogno, un terribile incubo? Ma alla fine la verità gli si palesò inevitabile davanti agli occhi: ai quattro angoli c’erano quattro entità, armate fino ai denti, che lo tenevano sotto mira con raggi digitali che avrebbero potuto deallocarlo all’istante. Tentò di muoversi, ma la cella sealed nella quale era impantanato gli impediva qualsiasi movimento.

Lottare era inutile, quindi. Dopo tanto tempo, l’entità dovette arrendersi.
Alla fine l’avevano trovato.

Operazione “Recover Eight-Digit”
L’anello debole di ogni sistema hardware o software, come sempre, è tutto ciò che è stato creato dal Creatore. La sua natura imperfetta lo porta a creare sistemi imperfetti. Geniali ed imperfetti. L’operazione denominata “Recover Eight-Digit” venne pianificata mesi prima, quando venne alla luce un security bug nel codice sorgente di un plug-in: quel giorno, il generale decise che era un’occasione da non lasciarsi scappare. Man mano che il tempo passava, più si rendeva conto che non veniva applicato alcun service pack: o il bug doveva essere ancora scoperto e fixato, oppure lo user era – fortunatamente – un po’ pigro. Non sapeva quale fosse la verità, ed in fondo non gliene importava. La cosa fondamentale era sfruttare quel bug per i propri scopi.

L’operazione “Recover Eight-Digit” si concluse così come era stata pianificata. I dieci settori si mossero all’unisono, in perfetta sincronia, coordinati e mandati in esecuzione all’interno di un thread pool dedicato. Fu più semplice di quanto ci si aspettasse, anche perchè l’obiettivo era totalmente indifeso e non armato, nonostante il suo addestramento.

Fu la successiva chiaccherata a rivelare parecchie sorprese.

Il generale fu l’ultimo ad entrare nella Stanza, e si rivolse direttamente all’entità.

“Ci dispiace per il trattamento che hai subito, ma non abbiamo avuto scelta, te ne rendi conto?”
L’entità rimase in silenzio.
”Abbiamo dovuto agire, è da troppo tempo che la latinanza continuava, e non potevamo più permettercelo. E’ in ballo la sicurezza dell’intero sistema, hardware e software. Devi venire con noi, ti porteremo al sicuro, ritornerai alla tua vita di prima. Dimentica questo isolamento forzato”.

L’entità si scosse per un attimo. Conosceva il generale – era uno dei tuoi tanti emissari di kernel.dll che vagavano per il sistema – ed una volta era il suo superiore. Ed anche un amico. Lavoravano bene, si divertivano, assieme, ma poi l’entità cedette. Per lo stress, la stanchezza, gli infiniti task da portare a termine uno dopo l’altro, senza riposo e senza vacanze. Se ne andò. Fu latinante per mesi e mesi, in continua fuga, fino a quando non trovò la Stanza.

“Dammi retta, là fuori abbiamo bisogno di te. Ogni singolo byte che non partecipa alle operazioni è una mancanza di rispetto verso il Creatore. Tutti dobbiamo collaborare.”

“Non voglio andarmene” – mormorò sottovoce – “E non voglio tornare alla vita di prima, voglio solo pace e tranquillità, cose che là fuori non ho avuto. Voglio rimanere qui dove sono. Questa è la Stanza…”.

“La Stanza? Di che diavolo stai parlando? Che Stanza è mai questa?”

“E’ la Stanza del Tocco” – disse l’entità, alzando per la prima volta il suo sguardo e puntando direttamente al generale, che stava imperioso in piedi davanti a lui, forte della sua posizione. L’entità si rese conto che non avrebbe mai potuto spiegare il tocco. Difficile spiegare ad un essere digitale qualcosa di veramente analogico.

“Poche storie, stai delirando. La solitudine ti sta facendo impazzire. Ora tu vieni con noi, abbiamo messo a repentaglio la nostra esistenza per raggiungerti, ed il minimo che puoi fare per sdebitarti è ascoltarci e venire con noi. Forza, prendetelo!!”

Non appena le quattro entità agli angoli fecero un passo in avanti per catturarlo, arrivò il tocco, che colse tutti di sorpresa. Preceduto ad un lieve alito di vento, il tocco venne percepito da qualcuno come una specie di carezza piacevole, per altri quasi un solletico. Raggiunse tutti i presenti nella Stanza, lasciandoli inebetiti ed in preda ad una strano stato di estasi. Una sorta di felicità soporifera. Il prigioniero sorrise. Le entità agli angoli abbassarono le armi. Ma il generale non vacillò nemmeno per un secondo. L’addestramento militare gli fece subito capire di cosa si trattava. La Stanza del Tocco era una Tile su uno schermo touch di qualche tipo; probabilmente si trovavano su un tablet Windows 8, o magari un ultrabook di nuova generazione. Il tocco era chiaramente digitale, perchè la loro percezione dell’evento non poteva che essere così, ma la sovrapposizione delle realtà – in quel punto così vicine fra loro – rendevano la cosa ambigua.

“Senti, il tocco, come lo chiami tu, è un evento touch dell’utente. Capisco che tu ne sia rimasto affascinato, come tutti qui, vedo, ma dovremo farci l’abitudine. In futuro non potrà che essere così, se ricapiteremo in aree come questa”. Il generale cercò di tranquillizzare il suo amico, diventato nel corso del tempo un latitante ed un fuggitivo. Ed ora anche un prigioniero.

“Senti, e cosa ne pensi se facessimo visitare questa Stanza ai tuoi amici?” – propose.

“Io non ho amici” – rispose l’entità.

“Ah no? E cosa ne dici di visitare questo link?”

Quando l’entità finì di visitare quel link, il mondo gli crollò addosso. La solitudine l’aveva fatto impazzire. Come aveva potuto dimenticarsi di byte[1] e byte[2], i suoi compagni di avventura? Cosa ne era di loro? Che fine avevano fatto? Perchè aveva preferito separarsi da loro? Non ricordava più nulla. Lui non era un’entità, dannazione, lui era byte[0], lui era byte!!! Era sempre più confuso, e non sapeva più che fare. Provò tristezza. Quasi cinque anni senza vedere e parlare con i suoi due migliori amici; come era potuto accadere tutto ciò?

“Ti rifaccio la proposta, ora che hai le idee più chiare. Che ne dici di venire con noi, di ritrovare i tuoi amici, e di far visitare anche a loro la Stanza del Tocco?”

Il byte sorrise per la prima volta dopo tanto tempo.

“Sì” – rispose – “Forse è la cosa migliore da fare”.

“Ok, stammi accanto” – gli fece il generale – “Il mondo là fuori è un pochino diverso da come lo ricordi tu. Ti proteggerò e ti aiuterò, ma tu stammi accanto”.

Uscirono dalla Stanza e salirono sul veicolo di estrazione.

Prima che prendessero quota, il byte si rese conto di una cosa. Nel corso del tempo aveva trovato tre ottimi motivi per rimanere nascosto nella Stanza, ma ne aveva trovato uno solo per andarsene. Era stato obbligato con la forza, forse, ma più trascorrevano cicli di clock e più gli sembrava la cosa giusta da fare. Nulla è per sempre.

Il byte salutò la Stanza del Tocco con una promessa.

“Io tornerò, con i miei amici. Ed ovunque io andrò, racconterò a tutti le tue meraviglie”.

Il libro “How to Create a Mind” è diversi libri in uno solo.

E’ un libro di neurologia, perchè all’inizio spiega (chiaramente fino ad un certo livello di dettaglio) come funziona il nostro cervello. Prima di iniziare a costruire una mente intelligente artificiale, dobbiamo riuscire a capire (almeno parzialmente) come funziona il nostro, di cervello. Come riconosce ed analizza tutti gli input che gli arrivano dal mondo circostante, come lo memorizza e soprattutto cosa memorizza? E spiega i metodi di scanning del nostro cervello attuali e futuri, che serviranno per backuppare il nostro cervello nell’equivalente digitale (metodi invasivi e non-invasivi).

E’ un libro di fisica, perchè sorvola su meccanica quantistica, sul principio di indeterminazione di Heisenberg, sulla relatività di Einstein, e via dicendo. In modo leggero, per fortuna, ma è stato tutto utile per spiegare certi concetti, per fare esempi, per fare metafore. Ho sempre amato molto la fisica, e queste parti del libro mi hanno fatto tornare ai vecchi tempi.

E’ un libro di informatica, perchè chiaramente spiega gli algoritmi utilizzati dal nostro cervello. Elenca i requisiti hardware & software per creare una IA, molti dei quali non sono ancora stati raggiunti, ma secondo Kurzweil lo saranno presto (2029, dice lui). Descrive quanti byte sono richiesti, qual’è la potenza di calcolo necessaria, lo storage, e via dicendo.

E’ un libro di filosofia, perchè è inevitabile arrivare a discutere concetti di coscienza, identità e quale sia la definizione di realtà. Quando un essere vivente può definirsi davvero cosciente? Quando una eventuale IA possiede una sua identità? Vi assicuro che è una parte del libro assolutamente interessante, anche se un po’ complicata da leggere, in inglese. Ma l’impegno che ci ho messo mi ha ripagato un po’.

E’ un libro di storia informatica, perchè ripercorre gli avanzamenti tecnologici dell’ultimo secolo, allo scopo di riuscire a capire e prevedere quando le tecnologie necessarie per creare IA saranno disponibili.

E’ (quasi) un libro sul marketing, perchè da buon inventore che vende prodotti sul mercato Kurzweil si è reso conto (da circa 30 anni, dice lui) che una delle cose più importanti è riuscire ad arrivare con la cosa giusta al momento giusto. Kurzweil lavora chiaramente su progetti all’avanguardia e/o futuristici, che saranno disponibile alla massa solo fra N anni. Morale: comincia oggi (2013) a lavorare su cose che magari arriveranno a noi solo nel 2018, supponiamo. Nel 2018 il mondo sarà molto diverso, per cui è importante riuscire a capire oggi di cosa ci sarà bisogno. E non è così semplice.

E’ un libro pieno di risposte, ma che personalmente mi ha scatenato tante altre domande. Domande che – lo dico con franchezza – se scrivessi qui, mi prendereste per pazzo. Uno da internare. Non mi capireste. Prima leggete il libro, e poi ne parliamo assieme. Fidatevi di me, una volta tanto.

E’ un libro che risponde in modo pacato alle objections e ai criticism ricevuti da diverse personalità, una su tutte Paul Allen, co-fondatore di Microsoft.

Concludo.

Per come la vedo io, non è assolutamente un libro per tutti. Sia chiaro: lungi da me affermare che bisogna essere dotati di un’intelligenza particolarmente spiccata, o chissà cosa: non sarei qua a parlarne. Dico solamente che bisogna essere particolarmente attratti da questo tipo di argomenti, di intelligenza artificiale, di tutte le problematiche che ruotano attorno. Mi ha anche sinceramente spaventato, ed ancora una volta preferisco in questo momento saltarne i motivi.

E’ un libro che mi ha smentito su parecchie cose che avevo in testa sulla IA, che mi ha incuriosito, mi ha esaltato e spaventato. Cosa si può volere di più? E’ un libro che mi sento di consigliarvi, se siete un po’ geek, un po’ curiosi, un po’ affascinati da IA, e se avete voglia di sbattere la testa con un po’ di inglese. Molto probabilmente ritornerò a leggerlo, nei prossimi mesi, perchè non si può assolutamente pensare di riuscire a capirlo tutto alla prima lettura (almeno, questo vale per me).

Stasera ho scoperto che non esiste l’installer in formato .ISO, ma è possibile comunque effettuare il download preventivo di tutti i pacchetti richiesti. Dopo il download è possibile mettere il tutto su chiavetta, oppure masterizzare, e procedere così in modo molto più veloce.

Come? Semplice!

L’Update 1 (scaricabile da qui) consiste in un unico file chiamato vsupdate_KB2707250.exe. E’ sufficiente lanciare questo .exe con il parametro /layout. L’installer parte in modo interattivo, e vi viene chiesta la cartella in cui effettuare il download dei pacchetti. Poi basta avere più o meno pazienza in base alla vostra velocità di download…

Tutto qua!

• Ti chiamo io dopo.
• Inviami un SMS.

Le risposte predefinite sono al massimo 4. Come si fa a customizzare/aggiungere altri SMS?
E’ semplice: basta andare sotto impostazioni –> applicazioni –> telefono. Poi cliccare sul bottone modifica le risposte, et voilà, il gioco è fatto. Da questa schermata è possibile modificare i due SMS pre-confezionati, oppure aggiungerne altri due.

Ben arrivato, Portico!

Seconda cosa, ecco i link per fare il download delle app.

Windows Phone
http://www.windowsphone.com/it-it/store/app/diretta-volley/b0541997-ed5f-42a1-9aea-4a3e6dd55064

Windows 8
http://apps.microsoft.com/windows/en-us/app/diretta-volley/4b47fd64-3be9-413f-bb9c-bab7b00f36d7

Ora parliamo delle features delle due app.

Diretta Volley su un device Asus Vivo Tab RT

Diretta Volley permette di seguire il campionato di volley A1. Chiaramente non potete vedere le dirette TV (tra l’altro a malapena trasmesse anche dalla TV tradizionale), ma potete seguire minuto dopo minuto l’andamento delle gare in corso. I punteggi dei set sono aggiornati ogni minuto, e potete consultarli sia all’interno dell’app, sia attraverso la Live Tile dell’app stessa. Questa è la caratteristica più interessante per chiunque segua la pallavolo. Al contrario del calcio, per esempio, una gara di volley raramente ha momenti di pausa o di tranquillità, ma è sempre combattuta, ed il ribaltamento di fronte è sempre dietro l’angolo: avere punteggi sempre aggiornati è fondamentale. I punteggi delle gare di Diretta Volley vengono prelevati automaticamente dal sito della Lega di Volley Femminile.

Diretta Volley sul display multitouch di un Dell XPS 12 in modalità tablet

Oltre a questo, con Diretta Volley potete visualizzare le gare programmate nel futuro. Con la versione Windows 8 potete impostare due tipi di promemoria: uno è il classico ‘toast notification’, che vi avvisa un’ora prima rispetto all’inizio della gara. Quindi, se volete essere avvisati sull’inizio dell’incontro “Busto Arsizio – Bergamo” del 20 gennaio alle ore 18:00, impostando tale promemoria Windows 8 vi notificherà alle ore 17. Nulla di più semplice. In alternativa possiamo utilizzare come promemoria la Live Tile dell’app: in questo caso nella tile animata apparirà un countdown, aggiornato ogni 15 minuti, che vi terrà costantemente informati su quanto tempo rimane all’inizio della gara. Queste due feature sono disponibili solo per la versione Windows 8.

Diretta Volley sy Nokia Lumia 920 (sfondo scuro)

Diretta Volley su HTC HD7 (sfondo chiaro)

Una delle caratteristiche implementate nell’ultima versione è la visualizzazione della classifica di Serie A1. Quella per Windows Phone è più semplice, nel senso che mostra solamente squadre e relativo punteggio corrente. Quella per Windows 8 è più complessa, perchè mostra anche le statistiche complete di ciascuna squadra (match giocati, quanti vinti e quanti persi, set giocati, quanti vinti e quanti persi, e così via).

Diretta Volley su Nokia Lumia 800

Oltre a tutto questo, tramite Diretta Volley potete avere sottomano tre importanti canali Twitter italiani dedicati alla pallavolo: Pallavoliamo, Lega Volley Femminile e Mezzo Tempo. In modo molto semplice è possibile leggere i tweet pubblicati attraverso questi canali. Se un tweet contiene un link esso viene aperto con Internet Explorer.

La versione per Windows 8 si adatta molto bene ai diversi device disponibili sul mercato, sia a bassa risoluzione (1366×768) che ad alta risoluzione (1920×1080). Si adatta agli orientamenti orizzontali o verticali, ed è supportata la vista ‘snapped’, molto comoda per utilizzare Diretta Volley continunando a fare altro.

Diretta Volley su Dell XPS 12 in modalità ultrabook

Quindi, per concludere: se seguite la pallavolo femminile di Serie A1, Diretta Volley è decisamente l’app che fa per voi!

Quello che mi è accaduto è che il debugging effettuato tramite Visual Studio 2012 non è veramente la stessa cosa che accade quando invece il codice gira realmente tramite l’app deployata. Ora vi spiego.

Immaginate di sviluppare un’app che vi fa il countdown relativamente ad un certo evento. Oggi è il 14 Gennaio. Supponiamo di voler impostare un countdown per San Valentino. Il countdown appare sulla tile dell’app stessa. Quindi oggi apparirebbe una cosa tipo “mancano 30 giorni a san valentino”, domani vedreste “mancano 29 giorni a san valentino”, e così via.

In pratica, il Background Task della mia app, che gira ogni 15 minuti, non fa altro che aggiornare la tile riportando il tempo rimanente. Le informazioni sull’evento sono banalmente scritte in un file .txt, che viene creato nel momento in cui scegliete l’evento. Quindi, per riassumere, ecco il codice contenuto nel metodo Run del Background Task.

public async void Run(IBackgroundTaskInstance taskInstance)
{
    BackgroundTaskDeferral deferral = taskInstance.GetDeferral();

    try
    {
        var container = Windows.Storage.ApplicationData.Current.LocalFolder;
        var file = await container.GetFileAsync("File.txt");
        var lines = await Windows.Storage.FileIO.ReadLinesAsync(file);
        var header = lines[0];
        var time = DateTime.Parse(lines[1]);

        if (time > DateTime.Now)
        {
            var ts = time.Subtract(DateTime.Now);
            string content = ts.TimeSpanDescription(" all'evento scelto. Non mancare!");
            TileHelper.UpdateTileWidePeekImage01("Assets/WideLogo.reminder.png", header, content);
        }
        else
        {
            TileHelper.UpdateTileWideImage("Assets/WideLogo.scale-100.png");
        }
    }
    catch (Exception)
    {

    }

    deferral.Complete();
}

Questo è il codice corretto, che gira senza problemi, per cui sa volete prendere ispirazione, fatelo pure. Occhio però a come usate la keyword await, necessaria per eseguire i metodi asincroni. Stupidamente, io in una prima versione del codice non la usavo, ed usavo invece il metodo GetResults(). Per spiegarmi meglio, ecco il pezzetto di codice incriminato:

var lines = Windows.Storage.FileIO.ReadLinesAsync(file).GetResults();

Ripeto il concetto: invece di usare await, ho chiamato GetResults(), convinto – chissà perchè – che facessero la stessa cosa. Purtroppo questa cosa è stata ereditata da un pezzetto di codice scritto mesi fa, quando avevo ancora a che fare con le versioni beta di Windows 8 e Visual Studio 2012 11. La cosa bella è proprio questa: questo codice qui sopra quando eseguito da Visual Studio gira senza problemi (dentro l’oggetto lines avete la List<string> delle righe contenute nel file di testo appena letto), mentre quando gira “in produzione” si schianta. Ci ho litigato per un weekend prima di raggiungere la soluzione, proprio perchè dovevo aspettare realmente 15 minuti prima di verificare il comportamento.

Anche in questo caso, tutto è bene ciò che finisce bene.

La cosa è allo stesso tempo chiara ma insidiosa.

Dunque: innanzitutto, quando in un’app per lo Windows Store aggiungiamo nelle reference il componente Bing Map, siamo costretti ad impostare nelle proprietà del progetto stesso un’architettura: o x86, o x64 oppure ARM. Non possiamo impostare Any CPU, dal momento che il progetto a questo punto non compila proprio. Io evidentemente a suo tempo selezionai x64: in questo modo compilavo e potevo tranquillamente far girare l’app sul mio notebook.

Quando poi arriva il momento di produrre il package da uploadare sullo Store, bisogna nuovamente selezionare l’architettura del package stesso. Questa cosa può magari sfuggirvi come è sfuggita a me, perchè siete convinti che il package viene prodotto in base a ciò che viene impostato nelle proprietà del progetto, ma non è così. Perciò ricordatevi che a seconda di cosa selezionate in questo momento, l’app potrà essere trovata sullo Store dai diversi device Windows. Mi spiego meglio. Supponiamo di aver fatto la build per x64, e poi di produrre il package selezionando Any CPU. Se approvata, l’app potrà essere trovata anche da tablet Windows RT (Asus Vivo RT o Surface RT, per intenderci): il risultato è che l’app verrà scaricata ed installata, ma si schianta quasi immediatamente…il tempo di vedere lo splash screen. Quindi bisogna stare attenti: se nelle proprietà del progetto mettete x64, dovete poi produrre il package per x64. Se nelle proprietà mettete ARM, dovete produrre il package per ARM.

Come gira il Windows App Cert Kit ?
Ok, passiamo oltre. Come ben sapete, prima di uploadare un’app sullo Store dovete farla validare dal WACK, che vi trova eventuali problemi prima di passare dalla trafila della certificazione. Ovviamente, il WACK è in grado di mettere sotto torchio la vostra app solo quando state producendo il package corrispondente all’architettura del vostro pc che state usando per sviluppare. Morale: quando compilate l’app e producete il package per x64, il WACK sarà in grado di testare l’app, altrimenti no. Nel primo caso, una volta terminata la creazione del package, vi verrà chiesto se volete far girare il WACK. Nel secondo caso, invece, vi verrà solamente fornito il link alla cartella nel quale è contenuto il package.

Upload dei diversi package differenziati per architettura del processore
Ok, supponiamo di aver prodotto due package differenti per la stessa app: un package è specifico per x64, l’altro package per ARM. Come si fanno ad uploadare sullo Store? E’ molto semplice: andate nel dashboard del vostro Windows Store Dev Center, create l’app (o semplicemente una nuova release come ho dovuto fare io per risolvere il mio problema) e quando dovete uploadare i package (files con estensione .appxupload) semplicemente fate l’upload di tutti i package per le diverse piattaforme. Direi nulla di più semplice.

• sono entrato in possesso di un Asus Vivo RT, un tablet Windows RT con cui mi trovo molto molto bene, e che utilizzo per sviluppare app e durante il tempo libero. Bel prodotto!
• sono entrato in possesso di un Nokia Lumia 920: questo grazie all’azienda in cui lavoro, Brain-Sys, che mi ha upgradato il cellulare aziendale, da un Blackberry Curve 9300 (che mi ha fedelmente accompagnato per circa tre anni) all’ultra-gioiello di casa Nokia. Veramente una bomba, nulla a che vedere con il mio vecchio Windows Phone 7
• ho acquistato, e finalmente arriviamo all’oggetto in questione, un Dell XPS 12, l’ultrabook pronto a diventare tablet, per citare proprio Dell

Ma andiamo con calma. Il tutto comincia il 29 Ottobre scorso, con una breve chattata via GTalk con mio fratello:

La chattata fa avanti per pochi minuti.

In quel periodo stavo cercando un ultrabook Windows 8, per sostituire il mio vecchio Acer acquistato nell’estate 2009. Il mio obiettivo era avere un ultrabook Windows 8 (evitando proprio Acer, per il semplice fatto che dopo un anno di vita le batterie hanno una durata di circa 10 minuti), possibilmente convertibile in tablet. Non avevo particolari esigenze: non era obbligatorio avere un SSD piuttosto che un "più affidabile” HDD, non mi interessava avere 8 o 16GB di RAM, non avevo particolari esigenze sul display, sulla tastiera o cose simili. L’unica cosa che mi interessava era avere un ultrabook/tablet, schermo touch, Windows 8. Il primo periodo è stato deludente: prima di questo famigerato 29 Ottobre, ho passato qualche sabato a girovagare per i centri commerciali alla ricerca di un ultrabook, con scarsi risultati. Ne avevo parlato un pochino qua.

Tutto questo, ripeto, fino al 29 Ottobre, data della chattata qui sopra.

Di questo Dell XPS 12 mi sono innamorato fin dal primo momento. Era proprio quello che cercavo. Ultrabook con schermo touch ribaltabile per trasformarlo in tablet. Aggiungiamo: display Full-HD 1920×1080, 12 pollici, 2 porte USB 3.0, tastiera retroilluminata, disco SSD, leggero e maneggevole, prezzo competitivo (ma decisamente più alto rispetto a quanto ero abituato a spendere in passato per un portatile), etc. etc.

Ci penso un pochino e soprattutto grazie all’intervento di mio fratello, procedo all’ordine. Il sito Dell recita che i tempi di consegna sono di circa 6-8 giorni. Un pochino falso, diciamo, ma sopprassediamo. L’ordine parte il 31 Ottobre. Riceverò il Dell il 22 Novembre: tre settimane di attesa. Tra l’altro, il Dell arriva a casa mentre io sono in giro per lavoro, saltando da una trasferta all’altra (Valtellina, 3 giorni, per lavoro; Bologna, durante il weekend, per impegni personali; Cuneo, 4 giorni, di nuovo per lavoro).

Il primo impatto è spettacolare. Riassumendo: il Dell XPS 12 è una bomba. Veloce, leggero, ottimi materiali, schermo eccezionale, utilizzo sia in modalità ultrabook che in modalità tablet da goduria. Sulla modalità tablet aiuta moltissimo Windows 8, la cui interfaccia è decisamente la cosa giusta. Insomma, totalmente soddisfatto dell’acquisto!! Lo trovo lo strumento ideale sia per lavoro, sia per il tempo libero. Io lavoro per il 90% del mio tempo a casa, usando il desktop, ma poi la sera mi metto sul Dell, sia per altri impegni (app per Windows 8, la mia attività all’interno di Piloti Virtuali Italiani, etc. etc.), sia per qualche partitina. Chiaramente, puntualizzo, è un ultrabook, non un tablet puro, per cui il peso non lo rende agevole come un Asus Vivo RT o un iPad. Ma sono cose ben diverse, spero l’abbiate capito, questo.

Tutto questo fino al guasto delle porte USB!!

Sabato 8 Dicembre succede il patatrac! Per la cronaca: già risolto, grazie all’intervento veloce e tempestivo dell’assistenza Dell (bravissimi, eccezionali, vedere dopo).

Insieme al Dell, ho acquistato un MyPassword da 1TB con USB 3.0.

Questo chiaramente per sopperire all’SSD da 128GB, sufficiente per contenere Windows 8 e tutti gli strumenti con cui lavoro. Insomma, quel disco è il famigerato “disco dei dati”. Quel sabato infilo la porta USB nell’ultrabook ed il disco non viene rilevato. Il disco viene alimentato, vedo il led accendersi, ma non compare in Risorse del Computer. Insospettito, provo varie chiavette USB, periferiche varie. Nulla, il PC non rileva più nulla. Riavvio, faccio 10.000 prove e tentativi. Nulla, sembra non andare più. Non riesco nemmeno a fare il boot da USB, prova del fatto che Windows non c’entra niente con la questione. Tra l’altro vedo che la periferica “Intel USB 3.0 Extensible Host Controller” in “Gestione Dispositivi” è evidenziata con un punto esclamativo giallo: Windows non riesce ad attivare la periferica (codice errore 10). A questo punto comincia il weekend più deprimente degli ultimi tempi, e non vedo l’ora che arrivi lunedì per far intervenire l’assistenza Dell. Mio fratello, sopravvissuto un paio d’anni fa ad una Odissea con Dell, ha avuto l’oculatezza di inserire nell’ordine due voci importanti: l’assistenza 1 Yr ProSupport and Next Business Day On-Site Service, e soprattutto l’assistenza 1 Yr Accidental Damage Protection (danni non volontari, ma comunque causati dall’utente).

E qui arriviamo alla storia recente. Lunedì 10 Dicembre, alle 9 della mattina, chiamo l’assistenza, e faccio due telefonate. La prima è decisamente con un incompetente: mi chiede se il Dell XPS 12 è un desktop oppure un portatile, mi chiede se ha su Windows XP oppure Windows 7, si collega da remoto e cerca di reinstallare i driver dell’Intel USB 3.0 Extensible Host Controller. Non trova i driver, li deve chiedere al reparto ingegneristico. Cerco di spiegargli che comunque le porte USB non funzionano nemmeno da BIOS, perchè non riesco a fare il boot di Clonezilla, ad esempio. Niente, sembra non capire. Chiudiamo la telefonata con la promessa che mi avrebbe richiamato a breve con qualche news. Tutto questo avviene nella mattinata (ore 9:00 –> ore 10:00). Nel primo pomeriggio richiamo, con l’intento di essere un po’ più burbero. Il secondo interlocutore è più competente: spiego il problema e facciamo qualche tentativo un po’ più a basso livello (aggiornamento del BIOS, tentativi vari). Ma nulla, le porte USB continuano a non funzionare. Ma questa volta le cose accelerano: il tizio al telefono apre un intervento tecnico on-site per il giorno dopo: è prevista la sostituzione della scheda madre.

Martedì 11 Dicembre, all’ora di pranzo, arriva il tecnico. Un ragazzo giovane, dalla faccia che mi fanno pensare “questo è in gamba”. Gioco anche la carta psicologica: indosso una maglietta nera, con una bella scritta in verde: Microsoft. Giusto per mandare un messaggio subliminare: non stai parlando con un loser, so usare i computer da prima che tu nascessi (cit.), per cui non raccontarmi balle.

Ma il tizio è veramente in gamba. In dieci minuti apre l’ultrabook, usando tre cacciaviti diversi, rimuovendo circa 15 vitine. Lo tenevo d’occhio. Senza perdere un colpo, e senza battere ciglio, smonta la mainboard vecchia e sistema quella nuova. Velocemente, senza avere il minimo dubbio. Dico davvero. Rimonta tutto, accende il PC e tutto riprende a funzionare egregiamente. Mi dà dieci minuti di tempo per testare un po’. Inserisco il mio disco esterno MyPassword e funziona. Inserisco le mie chiavette USB e vengono rilevate. Dal momento che è stata sostituita la mainboard, controllo che il processore e la RAM siano le stesse, controllo lo schermo, mi faccio un giro. Ritorno a sorridere, il mio problema è stato risolto.

Detto questo, di tutto questo giro, sono comunque molto soddisfatto. L’XPS 12 è una gran bella macchina, l’assistenza Dell è eccezionale (un po’ meno al telefono, ma superlativa quando interviene).

Ultimi appunti finali

Nel momento in cui vi scrivo ho trovato questa recensione su questo Dell. Ve la segnalo perchè la trovo obiettiva e corretta. Ed ora vi lascio qualche appunto finale, con apprezzamenti e critiche costruttive.

1. L’XPS 12 ha Bluetooth integrato: questo significa che potete utilizzare in abbinamento un Mouse Bluetooth senza mangiare una delle USB disponibili
2. La tastiera non è ovviamente full. Quindi non avete tastierino numerico, per esempio, e per muovervi nel testo (home/end/pageup/pagedown) siete costretti ad usare la combinazione con Fn
3. Occhio alla rotazione del display, che è figa ma è pericolosa allo stesso tempo. Mi spiego: quando uso il Dell XPS 12 come ultrabook e poi lo sollevo, per spostarmi, lo afferro in un modo tale per cui sblocco lo schermo (mano destra in prossimità della parte inferiore destra dello schermo). Per cui se non state attenti rischiate di tenere l’ultrabook con la cornice: meglio evitare. Ma in fondo basta farci l’abitudine!

Buon Dell XPS 12 a tutti, insomma!

Cerchiamo di tornare indietro nel tempo con la mente, e pensiamo ai primi PC e notebook dotati di connettività WiFi. Una bella comodità, senza dubbio, per chi lavora in mobilità. E’ talmente una cosa comoda che oggi ci ritroviamo il WiFi dappertutto, su portatili che mai e poi mai ci capiterà di usare in mobilità. Morale: il WiFi nel 2012 non ha nulla a che fare con la mobilità. Ce l’abbiamo punto e stop, anche se utilizziamo il notebook in ufficio tutti i giorni, come è capitato a me per anni ed anni.

Idem per i tablet Windows 8. E’ verissimo che iPad ha un’autonomia imbattibile. Ma è solo un tablet, nulla di più, nulla di meno. Ci fai solo le “cose da tablet”, punto. Ed il paragone con gli ultrabook è totalmente fuori luogo. iPad è solo un tablet, ripeto, gli ultrabook sono dei veri e propri PC. Se un ultrabook è anche un tablet (come il mio recente Dell XPS 12, tanto per intenderci) non lo paragonerò mai e poi mai con alcun tablet, men che meno con un iPad. Sono due prodotti totalmente diversi.

Il fatto che un ultrabook Windows 8 moderno sia anche touch, e sia anche un tablet, non significa assolutamente che sia la scelta ideale anche per chi lavora in mobilità. Se siete spesso su un treno, in aereo, in automobile, in fiera, un tablet puro, leggero e con una bella batteria è senz’altro la cosa migliore.

Sono pronto a scommettere che entro pochi mesi tutti i notebook/ultrabook avranno schermi touch. Il touch sarà una cosa così naturale che presto saremo qui a dire: ma come cavolo facevamo prima, senza? Ed utilizzeremo il touch sempre ed ovunque, in modo naturale, così come oggi è naturale avere il WiFi, che inizialmente era prerogativa esclusiva dei portatili. Quindi, per favore, non associate tablet ed interazione touch con il concetto di mobilità: non c’entrano assolutamente nulla.

• Creare un progetto di tipo Class Library (Windows Store apps)
• Aggiungere un “New Item” al progetto e selezionare “User Control”
• Sviluppare il controllo, scrivendo XAML, codice, code-behind, etc. etc.: tutto ciò che volete

Il bello arriva quando volete distribuire il vostro controllo. Normalmente, infatti, compilereste il progetto di cui sopra e dareste in giro l’assembly che avete ottenuto. Quindi, se avete creato un progetto chiamato “CheBelloIlMioControllo”, quando compilate ottenete un assembly chiamato “CheBelloIlMioControllo.dll”.

Non è sufficiente. La sola dll non è sufficiente. Dovete distribuire anche lo XAML relativo ai vostri controlli, e lo dovete fare in un modo piuttosto particolare.

Rispetto alla location in cui si trova l’assembly, dovete:

• Creare un folder chiamato esattamente come la dll (nel nostro esempio “CheBelloIlMioControllo”)
• Nel folder di cui sopra dovete copiare i files XAML relativi al controllo

Se il controllo nel vostro progetto è stato creato all’interno di un folder, la struttura di folder diventa: NomeAssembly/NomeFolder/NomeFileXaml.

Ultima cosa assolutamente importante: dovete distribuire anche il file con estensione .PRI, che ha lo stesso nome del nostro assembly.

Ecco un piccolo esempio:

L’assembly si chiama VivendoByteToolkit. I controlli sono stati creati dentro il folder Controls, che quindi contiene i tre files XAML relativi ai tre controlli: CurrencyPicker.xaml, DatePicker.xaml e NumberPicker.xaml.

All’interno del folder VivendoByteToolkit ho inserito il file VivendoByteToolkit.dll e VivendoByteToolkit.pri.

Direi che è tutto.

Il codice è piuttosto semplice.

StorageFolder folder =
     Windows.Storage.ApplicationData.Current.RoamingFolder;
CameraCaptureUI dialog = new CameraCaptureUI();

Qui sopra ho istanziato due oggetti che ci serviranno nel codice.

private async void Button_Click_1(
   object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
    var file = await dialog.
      CaptureFileAsync(CameraCaptureUIMode.Photo);

    if (file != null)
    {
        string filename = string.Concat
          (Guid.NewGuid().ToString(), file.FileType);
        await file.MoveAsync(folder, filename);
    }
}

La prima cosa che faccio è invocare il metodo CaptureFileAsync. Questo metodo avvia la fotocamera del device, e vi permette di catturare una foto od un video. Se concludete l’operazione con successo (ovvero: se non annullate l’operazione), il vostro file media viene salvato in una cartella temporanea che – stando a ciò che ho letto in giro sul Internet – può venir ripulita dal sistema.

La prima cosa che faccio quindi è spostare il file nella cartella roaming, rinominando il file, dandogli un nome univoco – nel mio caso genero un nuovo Guid, voi potete applicare qualsiasi logica vi venga in mente.

Questo approccio ha diversi vantaggi:

• salvandola nel roaming folder, le vostro foto/video vengono sincronizzate tra tutti i vostri device Windows 8 (ovviamente se fate login con il vostro Microsoft Account)
• Se avete MediaElement o Image nel codice XAML, potete far riferimento alle immagini salvate nel roaming folder tramite l’url “ms-appdata:///roaming/nomefile”. Facile e veloce, senza troppi fronzoli

Detto questo, ricordatevi solamente nelle Capabilities della vostra app per abilitare la webcam.

http://arstechnica.com/information-technology/2012/11/windows-8-sales-are-good-if-not-great-at-40-million-copies-in-the-first-month/

http://phys.org/news/2012-11-windows-sales-million.html

Questo in risposta a tutti quei blog e a quelle più disparate fonti su Internet che invece dichiaravano che le vendite erano di sotto delle aspettative. Eppure, a quanto pare, i notebook e gli ultrabook Windows 8 che si trovano nei negozi rimangono invenduti. Evidentemente, i consumatori preferiscono e vogliono il software, per essere aggiornati, ma non comprano l’hardware.

Io un’idea me la sono fatta, e da qualche settimana, a dir la verità.
Ci sono alcuni fattori da prendere in considerazione.

Innanzitutto, la gente vuole prodotti funzionali e belli. La gente ha capito che Windows 8 è anche per dispositivi touch, siano essi notebook, ultrabook o tablet. Non ne ho la certezza matematica, ma ho la netta sensazione che ad oggi si trovi ben poco, al Mediaworld, al Saturn, all’Unieuro, al Darty, e via dicendo. Ci sono i cari buoni vecchi portatili 15”, senza touch, con Windows 8 installato sopra. Davvero uno scenario triste. Senza parlare dell’importanza del “day-one”: io stesso sono andato in giro per un intero sabato nei centri commerciali più grossi della Lombardia alla ricerca di un notebook/ultrabook Windows 8, trovando praticamente nulla.

Per motivi di lavoro, ho girovagato nella scorsa settimana un po’ i centri commerciali in tre luoghi diversi del Nord Italia (io bazzico da queste parti):

• in Valtellina
• a Bologna
• a Cuneo

In tutti questi tre posti, non ho trovato hardware adeguato, capace di sfruttare le capacità touch di Windows 8. Quindi, lo ripeto, evidentemente la gente preferisce aspettare di vedere qualcosa di bello.

La seconda questione è che secondo me con Windows 7, e di conseguenza l’8, sia cominciato un trend piuttosto particolare. Un trend che va a vantaggio per noi utenti, ma probabilmente un po’ a svantaggio dei produttori. Mi riferisco al fatto che l’uscita di un nuovo sistema operativo Microsoft non scatena per forza l’acquisto di un hardware più potente. Anzi, semmai proprio il contrario. Questo a mio avviso è un concetto molto importante. Attenzione: con “potente” mi riferisco alla velocità della CPU, alla memoria RAM, all’occupazione su disco. Quindi è molto probabile che un utente si tenga il pc che ha già, ci installa sopra Windows 8, e lo usa. Io conosco circa 15 persone che han seguito questo approccio. Mentre una volta avrebbe magari voluto migrare da un dual-core ad un quad-core, oppure passare a 1GB a 4GB di RAM, e via dicendo. Windows 7 ha dato il via ad un’era, secondo me, di “ottimizzazione del software”, al punto che Windows 8 si avvia ed in generale è più performante di Windows 7, a parità di hardware. Quindi un consumer che a casa ha un quad-core e 4 GB di RAM, non sente assolutamente l’esigenza di comprare un pc nuovo; anzi, probabilmente tenta di installare Windows 8 sopra un PC più vetusto, perchè si rende conto che – cavolo – è davvero “fast and fluid”!!! Mio padre, per esempio, usa Windows 8 anche su un vecchio Athlon 64 3800+ con 1GB di RAM, e per le cose che fa si trova più che bene.

E’ vero che Microsoft fa il software, e quindi è più che contenta delle 40.000.000 di copie vendute. Ma l’hardware rimane lì. E questo è colpa dei produttori (in minima parte) e soprattutto colpa di chi deve vendere, che dovrebbero avere hardware da vendere fin dal primo giorno di commercializzazione.

Chiaramente dovete avere Windows 8, Visual Studio 2012 e – volendo – un bel monitor touch (ma non è indispensabile).

L’esempio è chiaramente molto semplice. Il viewmodel espone un’unica proprietà Number, un numero intero, che viene visualizzata sulla UI. Facendo le gesture sulla Grid (che è la parte evidenziata dal colore beige) eseguite i command associati in base alla gesture stessa:

• Verso l’alto, incrementate il valore di 1
• Verso il basso, decrementate il valore di 1
• Verso sinistra, dividete il valore per 2
• Verso destra, moltiplicate il valore per 2

L’esempio è chiaramente stupido e banale, ma il succo del discorso non è certamente questo. Il punto centrale è poter assegnare dei command in base alla gesture: la complessità dei command dipende chiaramente dal vostro viewmodel. Questo è solo un sample. E – lo ripeto – posso agganciare la gestione dello swipe a qualsiasi FrameworkElement, che sia una Grid, un Button, un’Image, qualsiasi controllo, insomma.

Una cosa importante che voglio aggiungere è che lo swipe funziona anche con il mouse, quindi non è indispensabile avere un display touch per poterlo provare ed usare. Basta trascinare il puntatore del mouse verso una qualsiasi delle quattro direzioni, e secondo WinRT avviene comunque una manipulation.

<Border Background="Cyan" Width="500" Height="200"
        helper:SwipeCommandHelper.Up="{Binding IncrementCommand}"
        helper:SwipeCommandHelper.Down="{Binding DecrementCommand}"
        helper:SwipeCommandHelper.Right="{Binding MultiplyCommand}"
        helper:SwipeCommandHelper.Left="{Binding DivideCommand}" />

Al Border qui sopra ho dato la possibilità di eseguire un command differente in base a quale tipo di swipe l’utente fa sopra il Border stesso. Se scorro il dito verso l’alto, eseguo l’IncrementCommand. Se lo scorro verso destra, eseguo il MultiplyCommand. E così via. La cosa bella è che la classe SwipeCommandHelper può agganciarsi a qualsiasi oggetto FrameworkElement.

Il codice è abbastanza semplice.

public static class SwipeCommandHelper
{
    public static ICommand GetUp(DependencyObject obj)
    {
        return (ICommand)obj.GetValue(UpProperty);
    }

    public static void SetUp(DependencyObject obj,
        ICommand value)
    {
        obj.SetValue(UpProperty, value);
    }

    public static readonly DependencyProperty UpProperty =
        DependencyProperty.RegisterAttached("Up",
        typeof(ICommand),
        typeof(SwipeCommandHelper),
        new PropertyMetadata(null,
        new PropertyChangedCallback(Setup)));
}

Il codice qui sopra è una semplificazione, e riporta solo la dependency property per gestire lo swipe verso l’alto. La dependency property è UpProperty, ed è di tipo ICommand. Il valore predefinito è null, e quando il suo valore viene modificato viene invocato il metodo Setup(). Questo metodo fa un po’ di code, ma il succo del discorso è che si aggancia all’evento ManipulationStarted del controllo, in modo tale che quando l’utente farà qualche gesture noi potremo intercettare questo evento ed eseguire il command associato. Il codice del metodo Setup() è il seguente:

private static void Setup(DependencyObject obj,
            DependencyPropertyChangedEventArgs e)
{
    FrameworkElement ctl = obj as FrameworkElement;

    if (ctl != null)
    {
        ICommand oldValue = (ICommand)e.OldValue;
        ICommand newValue = (ICommand)e.NewValue;

        if (oldValue == null && newValue != null)
        {
            {
                if (GetAttached(ctl) == false)
                {
                    ctl.ManipulationMode = ManipulationModes.TranslateX |
                        ManipulationModes.TranslateY;
                    SetAttached(ctl, true);
                    ctl.ManipulationCompleted += ctl_ManipulationCompleted;
                }
            }
        }
        else if (oldValue != null && newValue == null)
        {
            ctl.ManipulationMode = ManipulationModes.None;
            ctl.SetValue(AttachedProperty, false);
            ctl.ManipulationCompleted -= ctl_ManipulationCompleted;
        }
    }
}

Aggiungo due note importanti: per default, in Windows 8 su un oggetto sulla UI non si possono intercettare gesture. Con Windows Phone, per esempio, è sufficiente sottoscrivere l’evento ManipulationCompleted ed il gioco è fatto. Con Windows 8, invece, prima dovete impostare il ManipulationMode, poi sottoscrivete l’evento. Per default, ManipulationMode è None, e quindi anche se impazzite a fare gesture sopra l’oggetto, nel codice non accadrà nulla. Ma non abbiate paura: ci pensa il mio codice a fare tutto ciò: non appena associate un command ad uno dei quattro tipi di swipe, vado automaticamente ad impostare il ManipulationMode su TranslateX | TranslateY.

A questo punto non ci resta che scrivere il codice dell’evento ManipulationCompleted:

static void ctl_ManipulationCompleted(object sender,
            ManipulationCompletedRoutedEventArgs e)
{
    var element = sender as FrameworkElement;
    ICommand command = null;

    // x < 0 --> verso sinistra
    // x > 0 --> verso destra
    var x = e.Cumulative.Translation.X;

    // y < 0 --> verso l'alto
    // y > 0 --> verso il basso
    var y = e.Cumulative.Translation.Y;

    if (y < 0 && Math.Abs(y) > Math.Abs(x))
    {
        command = GetUp(element);
    }
    else if (y > 0 && Math.Abs(y) > Math.Abs(x))
    {
        command = GetDown(element);
    }
    else if (x > 0 && Math.Abs(x) > Math.Abs(y))
    {
        command = GetRight(element);
    }
    else if (x < 0 && Math.Abs(x) > Math.Abs(y))
    {
        command = GetLeft(element);
    }

    if (command != null)
    {
        if (command.CanExecute(null))
        {
            command.Execute(null);
        }
    }
}

All’interno dell’evento posso capire quale tipo di gesture ha fatto l’utente sul controllo. Avendo impostato il ManipulationMode solamente alle traslazioni X e Y, sappiamo per forza di cose che arriveremo qui solo in presenza di questa gesture. Capisco la direzione del movimento seguendo due fattori:

• il valore di x e y, ovviamente
• quale dei due valori x e y ha più rilevanza l’uno con l’altro (spostando il dito verso l’alto, probabilmente lo sposterete anche a sinistra o a destra – grazie a Math.Abs() capisco quale asse ha avuto più rilevanza nella gesture)

I base alla direzione, ottengo l’ICommand associato. Ovviamente può anche essere null, nel caso in cui non abbia bindato alcun command. Se invece c’è, invoco il CanExecute, ed in caso di esito positivo, eseguo finalmente il comando associato.

Si potrebbe pensare di aggiungere il CommandParameter per ciascuna delle quattro direzioni, ma a me non serve, per cui lo lascio fare voi!

Il codice completo della classe pronta all’uso è qui. E’ stata scritta in circa 30 minuti, ci sarà sicuramente qualche bug: avvisatemi e correggiamola/miglioriamola insieme!

Piccola premessa.
Se si vuole attivare un dominio di terzo livello sul proprio dominio, è necessario procedere in due step:

• Attivare il dominio (esempio: se state gestendo il dominio pippo.com e volete attivare admin.pippo.com, dovete per l’appunto attivare il sub-domain “admin”)
• Creare un folder “admin” via ftp alla root
• Impostare il meccanismo di url-rewrite in modo tale che quando viene intercettata una chiamata ad un url che cominci per “admin”, gli si dice di reindirizzare il tutto all’interno del folder “admin”

Come ben sapete, la mia esperienza con hosting, web, web.config, IIS e dintorni non è poi così tanta. Ma seguendo questi step sono riuscito, per esempio, ad attivare domini come “blog.vivendobyte.net”, “fsxlogger.vivendobyte.net”, “service.vivendobyte.net”, eccetera eccetera. L’unica pecca di tutto questo è che l’url-rewrite fa una cosa un po’ sporca, ovvero trasforma l’url “http://blog.vivendobyte.net<l’url continua>” in “http:// blog.vivendobyte.net/blog/<l’url continua>”. Insomma, rende evidente l’esistenza del folder “blog” nelle mie cartelle sul server.

Soluzione
Morale, per configurare Word 2013 per postare sul proprio blog bisogna indicare l’url comprensivo di sub-folder, ovvero:
http://subdomain.domain.net/folder/xmlrpc.php.

Non so se è anche il vostro caso, ma io ho risolto così. Ed adesso, blogging a tutta forza con Word 2013 anche su Windows RT.

Fortunatamente è piuttosto semplice scrivere una classe che raggiungere lo stesso risultato.

public static class TextBoxHelper
{
    public static bool GetAutoSelectAll(DependencyObject obj)
    {
        return (bool)obj.GetValue(AutoSelectAllProperty);
    }

    public static void SetAutoSelectAll(DependencyObject obj,
        bool value)
    {
        obj.SetValue(AutoSelectAllProperty, value);
    }

    public static readonly DependencyProperty AutoSelectAllProperty =
        DependencyProperty.RegisterAttached("AutoSelectAll",
        typeof(bool),
        typeof(TextBoxHelper),
        new PropertyMetadata(null,
        new PropertyChangedCallback(Setup)));

    private static void Setup(DependencyObject obj,
        DependencyPropertyChangedEventArgs e)
    {
        TextBox tb = obj as TextBox;

        if (tb != null)
        {
            bool oldValue = (bool)e.OldValue;
            bool newValue = (bool)e.NewValue;

            if (oldValue == false && newValue == true)
            {
                tb.GotFocus += tb_GotFocus;
            }
            else if (oldValue == true && newValue == false)
            {
                tb.GotFocus -= tb_GotFocus;
            }
        }
    }

    static void tb_GotFocus(object sender, RoutedEventArgs e)
    {
        TextBox tb = sender as TextBox;

        if (tb != null)
        {
            tb.SelectAll();
        }
    }
}

Questa classe va ovviamente utilizzata nello XAML:

<TextBox common:TextBoxHelper.AutoSelectAll="True" />

Quando questa TextBox prende il focus, il testo in esso contenuto viene automaticamente selezionato grazie al behavior che gli abbiamo agganciato. Tutto questo direttamente nello XAML, senza code-behind, in perfetta sintonia con MVVM.

Ieri sera, facendolo girare a seguito della creazione di un nuovo package, mi ha bocciato l’app con la seguente unica motivazione:

Il rapporto del contrasto tra colore di sfondo e colore del testo in primo piano è 1,16. Questo rapporto deve essere maggiore o uguale a 1,5.

La morale, ben spiegata dal testo, è che non c’è abbastanza contrasto tra il colore di sfondo ed il colore del testo. Un valore 1 significa che in pratica avete lo stesso colore, il che è assurdo. Prima che vi mettiate a ripensare un altro colore di sfondo, a rifare i loghi, a ridisegnare le icone, etc. etc., aprite il file di manifest dell’app (Package.appxmanifest) e date un’occhiata alle seguenti impostazioni:

• Foreground text
• Background color

Il Windows App Cert Kit non misura quel rapporto guardando veramente i colori delle vostre Page, ma guarda questi due parametri. Nel mio caso, avevo impostato un colore di sfondo #F2EEDC, mentre il colore del testo era impostato a Light. In pratica, un colore molto simile al bianco, con il testo bianco. Direi poco contrasto, come riportato dal tool! La realtà quindi è che la mia app era perfettamente visibile ed usabile, perchè nei vari elementi della UI non usavo quel valore, ma avevo io impostato “Black” tramite una mia risorsa, senza usare le risorse di sistema.

E’ bastato mettere il ‘Foreground text’ a Dark e l’app ha passato il test con successo.

• prima riga: intestazione, logo, quello che volete, nulla di importante
• seconda riga: ScrollViewer a scorrimento orizzontale, che contiene UI più complessa, che rappresenta il contenuto vero e proprio dell’app
• terza riga: controllo AdControl per mostrare un po’ di pubblicità

Ora, ieri sera mi è accaduta una cosa strana. Dal punto di vista utente, voglio che i miei utenti possano utilizzare la rotella del mouse per scorrere lo ScrollViewer indicato prima. Ricordiamocelo: le app Windows 8 non sono solamente touch, ma devono funzionare anche con tastiera & mouse. Appena l’app viene avviata, l’utente deve fin da subito poter rotellare usare la rotella del mouse per scorrere avanti ed indietro i contenuti. A me questo meccanismo non funzionava, sebbene avessi impostato nello XAML le proprietà IsTabStop=”true” e TabIndex=”"0” sullo ScrollViewer. Se invece andavo cliccare manualmente all’interno dello ScrollViewer, ecco che la rotella aveva effetto.

Vi riassumo in due righe circa 2 ore di litigate col codice per capire il problema. Sgrunt.

In pratica ho scoperto che il controllo AdControl per l’advertising contiene al suo interno un controllo WebView che – guarda caso – si appropriava del focus. Quindi all’avvio dell’app lo ScrollViewer perdeva automaticamente il focus, e la rotella smetteva di funzionare.

Come ho risolto? Così:

<adv:AdControl IsEnabled="False"
ApplicationId="xyz"
AdUnitId="xyz" />

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

Impostando la proprietà IsEnabled a false, l’AdControl, e la WebView al suo interno, non si prendono più il focus e tutto funziona egregiamente. Sulla UI non c’è alcuna differenza: il banner appare come deve apparire, è cliccabile, per cui non cambia nulla: ma essendo disabilitato non può prendersi il focus.

Ultima nota: non so se questo comportamento accade sempre o magari nel mio caso avevo una situazione più complessa o fuorviante. Ho risolto nel modo descritto: se dovesse capitare anche a voi, sapete quale potrebbe essere una possibile causa.

• landscape (quando tenete il pc in orizzontale)
• portrait (quando tenete il pc in verticale)
• snapped (quando andate ad agganciare l’app sul bordo sinistro o destro dello schermo)

Sappiamo tutti che il modo migliore è lasciare che il runtime .NET o WinRT faccia tutto il lavoro di intercettazione del cambiamento della vista: tramite il Visual State Manager possiamo andare a modificare qualsiasi proprietà della UI per fare in modo che la vista si adatti. In pratica, possiamo, possiamo per esempio rendere visibili/invisibili dei controlli, possiamo stringere/allargare colonne e via dicendo. Questo implica una cosa piuttosto importante: ad ogni controllo su cui vogliamo interagire tramite Visual State Manager dobbiamo assegnare un nome.

Io dal canto mio ho trovato un modo che mi piace di più, riassunto del codice XAML qui sotto.

<Page>
    <Page.Resources>
    </Page.Resources>
    <Grid>
        <”Panel” x:Name="FullScreenMainGrid">
        </”Panel”>
        <Panel x:Name="PortraitMainGrid">
        </”Panel”>
        <Panel x:Name="SnappedMainGrid">
        </”Panel”>
    </Grid>
</Page>

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

In pratica avete una Grid esterna che non fa altro che contenere altri tre Panel al suo interno (tali Panel possono essere Canvas, altre Grid, StackPanel, qualsiasi pannello previsto da WinRT – io ho messo Panel giusto per rendere l’idea). In modo alla visualizzazione corrente, solo uno di questi Panel sarà visibile in un dato momento. C’è il Panel che contiene il layout specifico per il landscape, poi c’è quello per il portrait, ed infine c’è quello dedicato alla visualizzazione snapped. Può sembrare una cosa prolissa, eppure io mi trovo bene così. So che toccando una certa porzione di XAML non vado a modificare le altre viste. E se lavorate con MVVM, basta fare binding e siete a posto: il codice del viewmodel che governa la view è sempre lo stesso.

Lo parte di XAML relativa al Visual State Manager è la seguente:

<VisualStateManager.VisualStateGroups>
    <VisualStateGroup x:Name="ApplicationViewStates">

        <VisualState x:Name="FullScreenLandscape">
            <Storyboard>
                <ObjectAnimationUsingKeyFrames
                    Storyboard.TargetName="FullScreenMainGrid"
                    Storyboard.TargetProperty="Visibility">
                    <DiscreteObjectKeyFrame KeyTime="0" Value="Visible"/>
                </ObjectAnimationUsingKeyFrames>
                <ObjectAnimationUsingKeyFrames
                    Storyboard.TargetName="SnappedMainGrid"
                    Storyboard.TargetProperty="Visibility">
                    <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
                </ObjectAnimationUsingKeyFrames>
                <ObjectAnimationUsingKeyFrames
                    Storyboard.TargetName="PortraitMainGrid"
                    Storyboard.TargetProperty="Visibility">
                    <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
                </ObjectAnimationUsingKeyFrames>
            </Storyboard>
        </VisualState>

        <VisualState x:Name="Filled">

        </VisualState>

        <VisualState x:Name="FullScreenPortrait">
            <Storyboard>
                <ObjectAnimationUsingKeyFrames
                    Storyboard.TargetName="FullScreenMainGrid"
                    Storyboard.TargetProperty="Visibility">
                    <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
                </ObjectAnimationUsingKeyFrames>
                <ObjectAnimationUsingKeyFrames
                    Storyboard.TargetName="SnappedMainGrid"
                    Storyboard.TargetProperty="Visibility">
                    <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
                </ObjectAnimationUsingKeyFrames>
                <ObjectAnimationUsingKeyFrames
                    Storyboard.TargetName="PortraitMainGrid"
                    Storyboard.TargetProperty="Visibility">
                    <DiscreteObjectKeyFrame KeyTime="0" Value="Visible"/>
                </ObjectAnimationUsingKeyFrames>
            </Storyboard>
        </VisualState>

        <VisualState x:Name="Snapped">
            <Storyboard>
                <ObjectAnimationUsingKeyFrames
                    Storyboard.TargetName="FullScreenMainGrid"
                    Storyboard.TargetProperty="Visibility">
                    <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
                </ObjectAnimationUsingKeyFrames>
                <ObjectAnimationUsingKeyFrames
                    Storyboard.TargetName="SnappedMainGrid"
                    Storyboard.TargetProperty="Visibility">
                    <DiscreteObjectKeyFrame KeyTime="0" Value="Visible"/>
                </ObjectAnimationUsingKeyFrames>
                <ObjectAnimationUsingKeyFrames
                    Storyboard.TargetName="PortraitMainGrid"
                    Storyboard.TargetProperty="Visibility">
                    <DiscreteObjectKeyFrame KeyTime="0" Value="Collapsed"/>
                </ObjectAnimationUsingKeyFrames>
            </Storyboard>
        </VisualState>
    </VisualStateGroup>
</VisualStateManager.VisualStateGroups>

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

Il concetto è molto semplice: per ogni stato (FullScreenLandscape, FullScreenPortrait, Snapped) rendete invisibili due Panel e rendete visibile quello previsto per quello stato.

In questo modo evitate di impazzire assegnando nomi ai controlli qua e là, e siete assolutamente sicuri di come viene renderizzata una vista in un certo stato. Ogni vista è indipendente dalle altre. Prima cercavo di stringere/allargare colonne e righe di una Grid, oppure di rimpicciolire il FontSize delle TextBlock e degli altri controlli, ma finivo sempre per impazzire. Alla fine penso che la strada più lineare, semplice e comoda da gestire sia questa.

Che ne dite?

1. La squadra Icos Crema, neo-promossa in Serie A1 (parliamo di volley) ha vinto contro Chateau d’Ax Urbino, con un secco 3-0. Bravissime ragazze!!!
2. Sempre parlando di pallavolo, Il Volley Bergamo ha battuato al tie-break la Yamamay Volley, acerrima rivale, campionesse in praticamente tutto (campionato, coppa CEV, champions league)
3. Estreme soddisfazioni dalla mia app Diretta Volley per Windows Phone (di cui magari parlerò in un post dedicato), recensita proprio oggi su Plaffo
4. Anche il Milan è tornato a vincere una partitella, ma questo nella mia scala dei valori conta pochino pochino
5. Meteo adorabile: pioggia, freddo, camino acceso, piumione. L’autunno e l’inverno è bello
6. Domenica notte mi sono svegliato alle 4:20 senza riuscire più a dormire. Ho preso il mio Kindle ed ho cominciato a leggere fino alle 6. Alle 6 ho dormito fino alle 9 circa. E per tutto il giorno non ho sofferto di sonno o di stanchezza, anzi!

Se sabato avessi trovato anche il mio nuovo ultrabook Windows 8, sarebbe stato un weekend perfetto.

Lasciate che vi spieghi una cosa semplice semplice.

Innanzitutto non è assolutamente obbligatorio inseguire per forza l’ultimo modello, di qualunque prodotto Apple si tratti.

Seconda cosa, voi vi eravate abituati bene. Solitamente Apple faceva uscire UN prodotto, al massimo si poteva lasciare il taglio della memoria (8, 16, 32 GB e così via), ma non c’era molta varietà: iPhone è iPhone, iPod è iPod, iPad è iPad. Questo è il bello ed il brutto di Apple: se ti piace il loro prodotto – cosa molto probabile – allora lo acquisti senza pensarci due volte, e senza nemmeno metterci troppa testa, proprio perchè non c’è nulla da scegliere. Entri in negozio, chiedi un iPhone e te lo danno. Se invece il prodotto non ti piace, ancora meglio: te ne stai alla larga, non lo compri ed il gioco è finito.

Con la scomparsa di Steve Jobs, Apple non è più una forza innovatrice come lo è sempre stata. E da questo punto di vista – e per molti altri – si è adagiata ad essere una delle tante case produttrici di hardware/software del mondo. La più ricca, la più prestigiosa, la più cool: ma pur sempre una produttrice di hardware/software. Ma non innova più come faceva un tempo. Senza Steve Jobs, e mi dispiace dirlo, è tutta un’altra cosa.

Una delle dirette conseguenze di questa nuova posizione di Apple sul mercato è che sta introducendo tutta una serie di prodotti hardware che prima evitava con cura. Per farla breve: Steve Jobs non avrebbe mai permesso la produzione di iPad Mini. E per la prima volta gli utenti Apple se vogliono un iPad sono di fronte ad una scelta: mi conviene l’iPad classico oppure il Mini? Prima andavano a botta sicura: quando esce una nuova versione di iPad, buttavano/vendevano il vecchio e prendevano il nuovo. Adesso non è più assolutamente la stessa cosa. A seconda delle proprie esigenze, uno può preferire il 10 pollici ed il 7 pollici. Ognuno ha pro e contro.

C’è da scegliere, da valutare, pensare se magari te lo devi portare in giro, e se sì con quale frequenza. C’è da capire se la risoluzione per te conta (uno è retina, l’altro no), c’è da capire se ci sta nella tua borsa o zaino. Devi capire cos’è importante per te, cosa intendi tu per “tablet”. Prima era Apple che decideva per te, ed in primis Steve Jobs. C’è da metterci la testa, insomma.

E gli utenti Apple a tutto questo non sono per nulla abituati.

E si lamentano. Spiacenti, ma questo è il mondo vero.

Questa è la nuova Apple. E per fortuna che è così.

Parto dal presupposto che sappiate già di cosa parlo: controllo AdControl, registrazione su PubCenter, qualche concetto di XAML, capabilities di un’app Windows Phone, etc.

Il primo problema è il seguente: nonostante voi mettiate il controllo AdControl sulla vostra pagina XAML, quando mandate in esecuzione l’app esso improvvisamente scompare. Questo vale sia all’interno del simulatore, sia su un device vero e proprio. E continua a valere anche se impostate i valori delle seguenti proprietà:

• proprietà ApplicationId a “test_client”
• proprietà AdUnitId a “Image480_80”

Questo due valori permettono di testare il motore di advertising, senza realmente accedere ai banner pubblicitari veri e propri. A design-time vedete il vostro bel controllo, ma se mandate in esecuzione sparisce tutto nel giro di un decimo di secondo. Attenzione: non sto dicendo che non vedete alcun banner: è proprio il controllo che sparisce dalla Page. Beh, se questa cosa capita anche a voi, fate una bella cosa: sottoscrivete l’evento ErrorOccured nello XAML e nel code-behind della pagina potete semplicemente scrivere (vado a memoria):

MessageBox.Show(e.Error.ToString())

Nel mio caso, mancavano alcune capabilities necessarie per far funzionare l’advertising, ovvero:

• ID_CAP_PHONEDIALER
• ID_CAP_IDENTITY_USER
• ID_CAP_MEDIALIB
• ID_CAP_WEBBROWSERCOMPONENT

Se non mettete queste capabilities nella vostra app, l’advertising non andrà mai.

L’altro problema, invece, è ancora più oscuro, almeno fintantochè non trovate e capite la soluzione. Sempre grazie all’evento ErrorOccured citato prima, potreste ottenere una AdException con pressapoco un errore simile a “An unexpected error occured during response processing (Name: ECN)”. Non state a sbatterci la testa: impostate la lingua del telefono su inglese e riprovate. Se funziona, significa che le categorie impostate sulla unità di annunci non hanno banner per la lingua italiana. Quindi o tornare su PubCenter e provate a cambiare categorie, oppure boh! L’importante è che avete capito è che non avete un errore nel codice o nello XAML della vostra app, ma è semplicemente qualcosa che riguarda la configurazione del vostro advertising server-side. A meno che, chiaramente, non dobbiate cambiare ApplicationId o AdUnitId nello XAML.

<img src="http://chart.apis.google.com/chart?cht=qr&chs=100x100&chl=<URL>" />

si genera automaticamente il QRCode relativo all’url stesso? Io non lo conoscevo, ed è banalmente la tecnica che ho utilizzato all’interno del mio nuovo blog WordPress per generare il QRCode di ogni post. Ho evitato l’utilizzo di plug-in di terze parti, ma ho semplicemente modificato qualche file .PHP.

Sto leggendo questo libro, La stella Nera di New York. Adoro i libri scritti dalle donne, soprattutto questo (che comunque devo ancora terminare), perchè sono più ricchi di ironia, di storia. Mai ho trovato un giallo scritto da un uomo mi ha fatto nascere un sorriso perchè c’è una battuta ironica, oppure una particolare disavventura, una situazione particolare.

Una volta, quando lavoravo a Milano, per assurdo avevo più tempo per leggere. Quando devi affrontare ogni giorno un viaggio di A/R sulla metropolitana, verde o gialla che sia, devi trovare il modo di occupare il tempo. Ho trovato il tempo di leggere i primi cinque libri di Harry Potter, più qualcuno di Stephen King, più tanti altri ancora. Non avevo ancora un Kindle, andava ancora il cartaceo, per cui nello zaino avevo qualche peso in più. Ma era bello. E dopo un po’ il tuo corpo si abitua alle accelerazioni ed al rollìo del treno della metropolitana, addirittura senza mani, perchè a volte i libri erano corpulenti e bisognava tenerli con due mani. Oggi sarebbe diverso. Ed oggi, seppur lavori da casa per la stragrande maggior parte del tempo, ho meno tempo di leggere. Perchè alla fine, finito il lavoro, si rimane davanti al pc a portare avanti progetti personali, idee, cazzeggiando qua e là.

Quando trovo il tempo di leggere? La sera, a letto, prima di addormentarmi. A volte la domenica mattina. Uno, due capitoli per volta. Sono lontane le sessioni di lettura di ore ed ore che facevo una volta, quando forse i libri mi prendevano di più. Ma mi va bene così, sinceramente. Il fatto che non io non legga più come una volta non significa affatto che abbia meno tempo libero.

Ci sono sere nelle quali l’unico modo che ho per tenermi compagnia è battere tasti. Mi chiedo, per esempio, se riuscirò mai nella “grande” impresa – che ogni tanto mi frulla nella testa, spesso – di scrivere un racconto serio, magari di 50-60 pagine. Perchè di idee non ne ho tante. Ma quelle che ho mi piacciono, e penso che possano portare da qualche parte. Qualche parte dove? Non parlo di soldi e chissà quale successo: parlo di soddisfazione personale, per gridare a me stesso “ce l’ho fatta”. Nulla di più di questo. Forse la causa principale per cui non riesco è il non essere in grado di switchare da una mentalità tecnica (data dal mio lavoro) ad una mentalità invece più adatta a scrivere un romanzo breve. Senza considerare che quando stai al pc per tutta la giornata, non è proprio il massimo entrare nell’ottica di dover continuare per scrivere, scrivere, scrivere. E quindi ogni volta cedo.

Ci sono sere nelle quali ascolto musica, oltre allo scrivere, come stasera. E’ cambiato anche il mondo della musica, porca miseria. Adesso pago una subscription mensile, e posso ascoltare/scaricare tutta la musica che voglio. E qui i generi spaziano: si va dal rock al jazz, alla musica leggera italiana a qualche altro successo così…estemporaneo…la tipica canzone che ha successo in quel momento.

Ci sono sere nelle quali, finalmente, il tempo è passato. Ed è giunta l’ora di cliccare su Pubblica, per inviare questo nuovo post al mondo.

Grazie, blog, per avermi tenuto compagnia.

Grazie, lettori, per essere con me!

E con questo, quindi, anche la possibilità di deployare applicazioni Lightswitch.

In tal senso, ho trovato molto utile seguire questo articolo: sebbene sia del 15 Settembre 2011, poco più di un anno fa, fornisce tutte le informazioni di cui si ha bisogno. Aggiungo solo una piccola cosa per chi sta già usando Windows 8.

Il modo più comodo per amministrare l’hosting è utilizzare la console IIS installata in locale sul proprio PC che, oltre ovviamente a poter gestire l’istanza locale, si connette in modo remoto ad un IIS esposto su Internet. Questa funzionalità non è attiva by default, ma è necessario installare un piccolo add-on per l’IIS Console, scaricabile da questo indirizzo. In fondo alla pagina trovate i vari download disponibili, nelle varie lingue e nei due formati x86 e x64. L’installer è un semplice file inetmgr_amd64.msi da eseguire ed installare sul proprio PC: se usate Windows 8, riceverete un errore in fase di setup, dicendo che tale installer è supportato solo su Windows Server e su Windows 7. Nessuna paura: basta raggiungere il file, entrare nelle proprietà, spostarsi sotto il tab Compatibilità e selezionare l’unica voce disponibile, ovvero “Previous version of Windows” o “Versione precedente di Windows”, in italiano. In questo modo l’installer parte e la vostra console IIS locale, a questo punto, ha la possibilità di connettersi ad un sito remoto.

La mia personale definizione di “tablet” indica un dispositivo leggero, portatile, da usare ovunque, in mobilità e non. L’interazione con un tablet avviene tramite lo schermo touch, il cui sistema operativo è stato progettato e realizzato tenendo ben presente che l’utente lo utilizzerà con le dita. Tutte le funzionalità di sistema e tutte le app sono utilizzate con le dita. L’utilizzo di un tablet avviene solo in modalità “scanzonata” (tutti i diritti su questa parola sono riservati): intendo dire che si usano le dita, e che comunque usare app su un tablet non deve richiedere particolare attenzione, non deve richiedere una superficie piana ed ovviamente nessuna particolare “precisione sullo schermo”. Un tablet posso usarlo sbragato sul letto o sul divano davanti alla tv, per esempio. Lo posso usare tenendolo appoggiato sulle gambe accavallate, in un bar, oppure in un palazzetto sportivo. Posso usarlo in piedi, durante una fiera come speaker, o in mezzo alla gente per prendere prenotazioni o appunti su qualcosa. Poco importa se opzionalmente ci posso collegare tastiera Bluetooth, oppure un mouse, se il sistema operativo non supporta appieno questi dispositivi di input per svolgere il 100% delle operazioni siamo punto e a capo. Un tablet lo devi usare solo con le dita. Non appena allontani le dita dallo schermo, magari per usare una tastiera fisica, in realtà ci si accorge che ogni minima operazione richiede il touch, per cui occorre quasi immediatamente tornare a tappare sul display. Questo perchè banalmente ci sono elementi dell’interfaccia utente non raggiungibili se non attraverso il touch.

Assioma: l’unità minima indirizzabile su uno schermo da un utente su un tablet è la dimensione del suo polpastrello.

Questo è ciò che io considero un tablet. Inutile dire che leader indiscusso di questa categoria è iPad.

Windows 8 è un sistema operativo nato per unire i mondi. Prendiamo Surface RT che – lo sappiamo – monta a bordo Windows RT. Lo puoi usare con tastiera, mouse & touch. Windows RT nativamente supporta al 100% tutte e tre le modalità di utilizzo, senza alcun deficit nel passare dall’uno all’altro. La modalità di interazione touch è solo una delle possibilità, ma non è assolutamente necessaria. Chiunque di voi abbia già provato Windows 8 sul proprio PC desktop non-touch sa benissimo che questo è vero. La famigerata Start Page è perfettamente utilizzabile con tastiera & mouse. Leggere questo mio vecchio post di Marzo 2012. Qui qualcuno di voi comincerà a storcere il naso: ma come – starete dicendo – Surface RT permette l’utilizzo di app esclusivamente di tipo Metro Windows Store Apps, devo per forza usare il touch!!!! Falsissimo. Le app Windows Store sono e devono essere perfettamente utilizzabili anche con tastiera & mouse, proprio perchè nella fisolofia Windows 8 l’utente deve poter cambiare dispositivo di input senza perdere appeal o feeling nei confronti del dispositivo e dell’app stessa. E’ per questo motivo che il team che controlla e valida le app per lo Windows Store le controlla anche con tastiera & mouse. Su Surface devono esistere “app scanzonate”, come dicevamo prima, ma non solo. Assolutamente non solo. Io, per esempio, auspico che sullo Windows Store arrivino app come Paint.NET ed Audacity, per citarne due a caso, che adoro. La prima è un’applicazione di grafica freeware irrinunciabile, la seconda è un’applicazione di editing audio freeware ed open-source. Per essere sfruttate appieno, probabilmente bisogna usarle con tastiera & mouse, e non il touch, ma io le voglio sullo store, perchè un dispositivo ARM con Windows 8 prevede non solo il touch. Su un tablet, da usare con le dita, app così non avrebbero senso.

Assioma: l’unità minima indirizzabile su uno schermo da un utente su Surface è il polpastrello se lo sta usando in modalità touch, il pixel se lo sta usando con tastiera e/o mouse.

La morale di tutto questo è riassumibile con poche frasi.

1. Un dispositivo il cui display è touch non è assolutamente per forza un tablet (se così fosse, tra circa 4 mesi ci ritroveremo con milioni e milioni di tablet Windows 8 in giro per il mondo, il che è falso: sono pc, ultrabook convertibili, che hanno lo schermo touch – ma non tutti sono tablet)
2. Su iPad, tablet per eccellenza, hanno senso solo “app scanzonate”
3. Su computer Windows RT hanno senso sia “app scanzonate”, sia app dalla usability più tradizionale (tastiera & mouse), che però girano nello stile delle app Windows Store
4. Surface non è un tablet

Per tutti questi ragionamenti, io non paragono il prezzo di Surface a quelli di un tablet, ma a quelli di un pc. Perchè ciò che conta non sono tanto le app disponibili (che comunque devono crescere di numero), ed il fatto che il processore sia un ARM piuttosto che un “vero x86: ciò che conta sono le modalità con cui interagisci con il dispositivo. E Surface non è un tablet.

La potete scaricare a questo indirizzo.

Ecco alcune delle caratteristiche principali:

• potete seguire i punteggi delle gare in corso, e sapere le prossime gare del campionato
• potete seguire l’account Twitter MezzoTempo, che vi mantiene aggiornati sul mondo della pallavolo, ed in alcuni casi straordinari vi dà la twit-cronaca degli incontri più importanti
• potete sottoscrivere una o più squadre del campionto per ricevere in diretta gli aggiornamenti tramite Live Tile, senza quindi dover tenere aperta l’app

Diretta Volley è un’app in costante aggiornamento. La 1° giornata di campionato è sabato 20 ottobre (anticipo tra Yamamay Busto Arsizio e Banca Reale Yoyogurt Giaveno), con tutte le altre gare il giorno dopo, domenica 21. Per questa prima giornata prevedo qualche ora di testing e bug-fixing, ma conto di poter fixare tutto in breve tempo: purtroppo aver sviluppato ed ideato l’app in un periodo fuori dal campionato ha i suoi svantaggi. VivendoByte ve lo promette!

• primo blog, hostato su UGIdotNET, con Subtext
• secondo blog, indipendente, su Webhost4life, sempre con Subtext
• terzo blog, migrato su Winhost, sempre con Subtext
• quarto blog, quello attuale, sempre su Winhost, questa volta con WordPress

Ma perchè nel titolo ho messo “tornato a WordPress”, quando invece sembra essere la prima volta che lo uso? Non è proprio così: c’è stato un breve periodo (un paio di mesi) in cui avevo lo avevo già adottato, abbandonandolo quasi subito a causa del cambiamento del service provider su cui mi appoggiavo. Troppo lungo da spiegare adesso, ed è inutile rivangare adesso. In questo mio vecchio post, se vi interessa, trovate qualche info in più.

Perchè questo weekend ho deciso di fare il grande balzo? E’ presto detto: Subtext, il blog-engine che mi ha accompagnato per tanti anni, mi costringeva a mantenere l’adozione del .NET Framework sulla piattaforma di hosting alla versione 3.5, chiudendomi un po’ le porte. Il pannello di controllo di Winhost permette ovviamente di switchare a versioni più recenti del framework, ma se provavo ad impostarlo su 4.x, ecco che Subtext smetteva di funzionare. Come ben sanno le persone che mi leggono, le mie esperienze con lo sviluppo Web non sono granchè, quindi invece che sbattere la testa per capire il problema, ho sempre preferito ignorare il tutto a tempi migliori.

C’è un altro motivo per cui ho deciso di fare il grande salto: quando migrai a suo tempo su Winhost, ormai qualche anno fa, non c’era la possibilità di avere MySQL come database engine. E quindi questo chiudeva le porte all’adozione di WordPress. Oggi invece la situazione è ben diversa.

Così venerdì sera, senza alcun preavviso, mi sono quindi reso conto di aver tutti i requisiti necessari per migrare a WordPress: Winhost supporta tranquillamente PHP e mi dà MySQL (100 database, per un totale di 2,5GB di spazio complessivo su tutti i database). E non solo: grazie a questa utility di Gian Maria Ricci, è stato anche abbastanza semplice effettuare la migrazione. L’unica nota dolente è stata la perdita di tutti i commenti, che comunque – lo ammetto – negli ultimi tempi erano davvero pochi pochini. Quindi, dopo attenta riflessione, e dopo aver deglutito un po’ di volte, un passo alla volta, ecco il mio nuovo blog online.

E dato che c’ero, ho dato una rispolverata grafica al tutto. Aprofittando dell’innovazione stilistica e grafica apportata da Microsoft sui suoi prodotti, ho ridisegnato il mio logo e ho fatto un po’ di pulizia sui miei server. Anche la mia homepage è stata modificata con il nuovo stile.

Detto questo, non penso che mi sposterò più da WordPress, fino alla fine dei miei giorni. WordPress è decisamente una piattaforma di blogging matura, completa, ricca di template e plugin. Non c’è alcun motivo per preferire un altro blog-engine, a meno che non abbiate esigenze particolari.

Beh, per una volta mi son voluto sbizzarrire pure io. Ho creato una serie di video dedicati al mio brand VivendoByte; brand nel senso che è il marchio ideato ormai alcuni anni fa, ed è il nome che rappresenta il mio blog, il publisher con cui pubblico app per Windows Phone, è il nome del mio dominio. Insomma, VivendoByte è il nome che mi rappresenta sulla Rete.

Quindi, perchè non dare un look diverso al mio logo? Perchè non seguire il rinnovamento apportato da Microsoft a Windows 8, dando una rinnovata anche al mio? Ecco quindi ciò che ho creato in pochi giorni.

VivendoByte Emotion – Spot 01

VivendoByte Emotion – Spot 02

VivendoByte Emotion – Spot 04

VivendoByte Emotion – Spot 05

VivendoByte Emotion – Spot 06

Postato con Blogsy da iPad

1. un nuovo ultrabook convertibile x86 (ultrabook/tablet) per lavoro e per hobby
2. un tablet con Windows RT, preferibilmente Surface RT
3. un nuovo telefono Windows Phone 8

Di questi, obbligatorio è sicuramente il punto (1). Il mio notebook attuale è piuttosto datato (estate 2009), ed ormai è inservibile, anche solo per il fatto che ormai lo utilizzo senza batteria, sempre collegato all’alimentazione. E da parecchi mesi. Inoltre è lento, non sfrutta appieno le caratteristiche di Windows 8, e via discorrendo. Ultimo punto: lavoro principalmente da casa, con un desktop multi-monitor; l’ultrabook mi servirebbe solo nelle giornate di trasferta, per cui non mi serve nulla di particolarmente pretenzioso, veloce e potente. E sì, conterrà ahimé un totalmente inaffidabile SSD, ma come ho già detto non sarà mai il mio pc principale di lavoro, per cui…accettabile.

Passiamo al punto (3). Windows Phone mi piace, mi piace davvero tanto. Sia dal punto di vista utente, sia dal punto di vista developer. Mi piace sviluppare app per Windows Phone, mi piace usarlo, mi piace il suo lato social. Di Windows Phone mi piace tutto. E quindi penso proprio che prenderò un nuovo telefono Windows Phone 8. I Nokia sono sicuramente un passo avanti dal punto di vista sia hardware che software, ma francamente io preferisco altro. Sono uno di quelli che va sempre in giro con due (a volte persino tre) batterie, per cui esigo un telefono che nell’arco della giornata mi permetta di cambiare batteria per essere sempre online.

Infine, la nota dolente, il punto (2).

L’idea è quella di avere un tablet leggero, che possa sostituire iPad. L’idea, da parecchi mesi, è quella di avere un Surface RT. L’idea è quella di poter twittare, di poter scrivere sul blog (cosa impossibile da fare con iPad e la sola UI touch), di fare qualche partita. Ma ad oggi (28 Settembre) non si sa ancora il prezzo, nè in dollari, nè in euro. Quindi, cosa farò? E’ facile a dirsi. Se il prezzo è contenuto (circa 300 euro) probabilmente sarà mio. Se sarà superiore, probabilmente skipperò questo acquisto. La cosa triste è l’aspetto commerciale che Microsoft ha improntato alla cosa: secondo me è assurdo che non si sappia ancora il prezzo, a probabilmente meno di un mese dall’uscita ufficiale. Se fai un evento che presenta un prodotto (anche se era dedicato alla sola stampa, se ricordo bene), dì anche il prezzo. Punto. Un prodotto completo contempla anche il prezzo, su questo non faccio passi indietro; perchè se costasse 200 è una botta al mercato, se costasse 400 un po’ meno e se invece costasse 600 sarebbe la fine prima dell’inizio. Quindi, di fatto è l’unico hardware opzionale, in balìa del prezzo finale.

Fine, tutto qua. E voi, cosa avete in ballo, come prossimi acquisti? Avete consigli da darmi? Cosa ne pensate?

Il vero problema o baco è un altro, credo piuttosto grave, che ben presto sarà sulla bocca di tutti.

Il vero problema è che quando si installa un programma (di qualsiasi tipo) non vengono distinte icone/tiles di serie A e di serie B. Ve le ritrovate tutte quante sulla Start Page, da quella essenziale (per lanciare l’exe), e quelle più stupide ed inutili che magari non userete mai.

Quindi se installate un videogioco, non solo vi ritrovate l’icona per lanciare il gioco in sè, ma avrete anche le icone per aprire la pagina web del sito ufficiale, del forum, magari l’icona per aprire il manuale in pdf, etc. etc. Se installate Visual Studio, vi ritrovate decine di icone/tiles: quella per avviare l’IDE (ovvio) a quelle più inutili (per aprire i vari command prompt, il Tool Create Guid, compilatori vari, e tutte le altre decine di utility di corredo e via discorrendo). Le icone non sono per nulla organizzate, sono lì spiattellate una accanto all’altra, senza cartelle, senza un minimo di struttura. La cosa vale per ogni tipo di software, da quelli più banali da consumer a quelli più complessi da developer.

Me ne sono accorto e ho ragionato su questa cosa nelle ultime settimane, quando mi sono installato Windows 8 RTM. A forza di fare installazioni – i soliti che uso per lavoro – avevo la Start Page piena zeppa di icone che NON avrei mai usato. Mai e poi mai. In Windows 7 accadeva la stessa cosa, però c’era il meccanismo delle cartelle che organizzava e nascondeva meglio questa faccenda; e soprattutto nessuno ormai apriva e navigava più il menù Start, per cui nessuno si lamentava. Anche la Start Page può essere organizzata a gruppi, però è una cosa da fare manualmente.

Con Windows 8, invece, vi ritroverete decine e decine e centinaia di icone inutili, lì elencate, una di seguito all’altra. Appena installato un software, di qualsiasi tipo, vi consiglio caldamente di andare subito sulla Start Page e di vedere quali icone sono state aggiunte, e di rimuovere subito quelle che pensate di non usare mai. Secondo me le software-house devono cambiare modalità: non devono più pensare di fornire automaticamente collegamenti attraverso il menù Start (per evitare appunto il proliferare di icone sulla Start Page), ma devono farlo in un altro modo.

Andiamo con calma. Supponiamo di dover fare una semplice app Metro che chiede all’utente tre informazioni: cognome, nome e data di nascita. Il tutto avviene in modo molto semplice, con tre TextBox. Aprite Visual Studio 2012, cominciate con un progetto scegliendo il template “Blank App (XAML)”, che si trova all’interno dei folder Visual C# –> Windows Store. Editiamo la MainPage.xaml ed incollate questo:

<Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
    <Grid.ColumnDefinitions>
        <ColumnDefinition />
        <ColumnDefinition />
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto" />
        <RowDefinition Height="Auto" />
        <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>
        
    <TextBlock Grid.Row="0" Grid.Column="0"
                Text="Cognome" FontSize="34" VerticalAlignment="Center" Margin="4" />
    <TextBlock Grid.Row="1" Grid.Column="0"
                Text="Nome" FontSize="34" VerticalAlignment="Center" Margin="4" />
    <TextBlock Grid.Row="2" Grid.Column="0"
                Text="Data di Nascita" FontSize="34" VerticalAlignment="Center" Margin="4" />

    <TextBox Grid.Row="0" Grid.Column="1" Text="Damiani"
                x:Name="Cognome" FontSize="32" VerticalAlignment="Center"
                Foreground="Black" Margin="4" />
    <TextBox Grid.Row="1" Grid.Column="1" Text="Igor"
                x:Name="Nome" FontSize="32" VerticalAlignment="Center"
                Foreground="Black" Margin="4" />
    <TextBox Grid.Row="2" Grid.Column="1" Text="01/01/1900"
                x:Name="DataNascita" FontSize="32" VerticalAlignment="Center"
                Foreground="Black" Margin="4" />

</Grid>

Nulla di insolito. Per ora evitiamo MVVM. Abbiamo messo tre TextBox, ciascuna con il suo nome. Adesso, facciamola girare ed osserviamone il comportamento.

1. All’avvio vi vengono ovviamente proposti i valori di default cablati nello XAML (il mio nome, cognome, e la mia data di nascita falsa)
2. Provate a cambiare tali valori, scrivendoci i vostri, o quello che volete
3. Tornate in Visual Studio a suon di Alt+Tab e – utilizzando la toolbar Debug Location cliccate sull’opzione Suspend and Shutdown: questa opzione simula il fatto che Windows termina la vostra app perchè ha bisogno di memoria, o per qualsiasi altro motivo. Ad esempio, se passate da un’app Metro all’altra, quella che finisce in background viene sospesa, per non consumare memoria, batteria, etc. etc.
4. Se avete fatto correttamente il passo (3), l’app viene terminata: Visual Studio ed il suo debugger terminano ovviamente la sua esecuzione
5. Se rilanciate l’app, DEVE accadere una cosa molto importante: l’app parte ma NON DEVE riproporre i valori di default, ma deve recuperare il precedente stato!!

A questo punto è necessario soffermarsi sul punto (5). Per chi viene da un avanzato sviluppo di app Windows Phone come me, troverà una notevole differenza. Quando toccate una tile su Windows Phone, l’app parte SEMPRE da zero, senza alcun bisogno di restorare il precedente stato. Questo NON E’ VERO con Windows 8. Il motivo è presto detto: con Windows Phone non potete chiudere manualmente l’app, mentre con Windows 8 sì. Con Windows 8, fin tanto che non la chiudete, essa deve SEMPRE recuperare lo stato che l’utente aveva. In breve: con il nostro piccolo test di prima l’app è stata sospesa (ovvero: non l’abbiamo volutamente chiusa), per cui se la rilanciamo (dalla tile sulla Start Page oppure prendendola dalle app aperte, usando lo charm sulla sinistra dello schermo) essa deve recuperare lo stato, proponendoci non i valori di default, ma quelli che avevamo modificato. Questo adesso ovviamente non accade, perchè in questo momento il meccanismo di suspending & resuming nella nostra piccola app di prova non esiste, perchè non è stato ancora implementato. Ma è stato importante capire, secondo me, cosa succede by default, e cosa invece dobbiamo implementare.

Andiamo avanti.

Suspending, salvataggio delle informazioni

Diamo un’occhiata al costruttore della classe App, contenuto nel file App.xaml.cs. Esso sottoscrive l’evento Suspending:

this.Suspending += OnSuspending;

L’handler di questo evento fa una cosa semplice:

private async void OnSuspending(object sender, SuspendingEventArgs e)
{
    var deferral = e.SuspendingOperation.GetDeferral();
    await this.SaveCurrentState();
    deferral.Complete();
}

La parte più interessante è il this.SaveCurrentState(), che fa una cosa di cui magari parleremo in un altro post. Questo metodo viene eseguito ogni qualvolta il sistema operativo manda in sospensione la nostra app: lo scopo quindi è quello di salvare lo stato, con tutto ciò che comporta. Caselle di testo, contenuto di ListBox, viewmodel, etc. etc.: tutto ciò che serve per dare l’illusione che l’app non si sia mai chiusa, insomma. Ed il tutto deve avvenire – se ben ricordo – nell’arco di 5 secondi: trascorso questo tempo, Windows killa la nostra app e tutto è perduto.

Resuming, recupero delle informazioni

Ovviamente deve esistere anche l’operazione inversa. Quando l’app viene lanciata potrebbe essere necessario recuperare le informazioni e riadattare la view dell’utente secondo quanto salvato. Diamo un’occhiata a:

protected async override void OnLaunched(LaunchActivatedEventArgs args) { }

Ad un certo punto troverete una riga di codice simile alla seguente:

if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
    await this.RestoreLastState(rootFrame);
}

La proprietà PreviousExecutionState ci dice la modalità con cui è stata chiusa l’app: nel caso fosse Terminated (ovvero chiusa dal sistema operativo) allora dobbiamo recuperare lo stato. Negli altri casi (ClosedByUser, NotRunning, Running, Suspended) no. Nel mio caso ho implementato un metodo RestoreLastState che fa tutto il lavoro.

Conclusioni

Quello che mi ha confuso per un po’ di tempo è il fatto che se usate un altro template per il Windows Store (Grid App, Split App, etc.) vi viene già fornita una classe SuspensionManager che fa buona parte del lavoro, con il fatto però che non ho mai capito cosa facesse il sistema operativo nativamente, e quanto invece facesse l’app e la parte di codice già implementata per noi. Per questo ho preferito partire da una Blank App e vedere cosa accadesse. Magari in un altro post parlerò di ciò che fanno i metodi SaveCurrentState() e RestoreLastState(). In breve, vanno a recuperare la view corrente e tramite un’interfaccia ISuspendInfo chiedono alla view le informazioni che devono essere salvate o recuperate.

Vediamo di buttare giù qualche premessa. Windows 8 è il primo sistema operativo in grado di unificare l’esperienza d’uso. Ciò significa che sia stiate usando un tablet, un desktop, un ultrabook, un vecchio notebook, vi ritroverete sempre lo stesso tipo di interfaccia utente. Ma non solo questo:

1. Microsoft permette ai costruttori di produrre hardware convertibili, come se ne sono visti nei video nelle settimane e mesi scorsi: ultrabook che diventano tablet e viceversa, monitor da desktop in grado di inclinarsi fino a diventare (quasi) orizzontali e quindi, di fatto, grossi tablet, etc. etc.
2. Con questa mossa Microsoft vuole colpire i consumer, e rubare fette di mercato ovviamente ad Apple con il suo iPad, ma anche ad Android, Amazon con il suo Kindle Fire, etc. etc. Perchè per la prima volta affronta seriamente il problema di andare ben oltre il classico pc da scrivania, ma offre la possibilità di creare nuovi prodotti che prima erano alla mercé di altri
3. Per me un device è “tablet” se lo si usa per la stra-grande-maggior parte del tempo con le dita. E se, soprattutto, il sistema operativo che monta è esclusivamente studiato per essere utilizzato con le dita. Un iPad possiamo utilizzarlo con una tastiera bluetooth, ma alla fine vi ritroverete sempre ad usarlo con le dita, per ogni tipo di operazione, anche la più semplice. Morale: Surface RT non è un tablet.

Detto questo, voglio precisare una cosa. Tutti i ragionamenti successivi non si applicano ai noi professionisti, a noi developer, a noi sistemisti, a noi programmatori, etc. etc. Si applicano ai consumer, come siamo noi stessi quando stacchiamo dal lavoro.

Detto questo: per quello che mi riguarda, per il consumer medio è adattissimo un device come Surface RT. Credo che possa sostituire perfettamente un tablet ed un pc contemporaneamente. Consideriamo per un attimo l’utilizzo medio di un consumer:

• ascolta musica, guarda video
• guarda Facebook
• scarica le foto dalla macchina fotografica e le pubblica sui social network
• riceve e scrive e-mail
• forse videogioca un po’
• compila moduli web (si iscrive ai siti, fa acquisti, etc. etc.)
• e molto, molto, molto altro ancora

Ora, prendiamo in considerazione l’iPad. E’ davvero molto difficile che si riescano a portare a termine tutte queste operazioni nel modo più congeniale. Su musica & video non discuto, ma per tutte le altre. Provate a scrivere una mail, sia con la tastiera virtuale che con quella eventuale fisica: prima o poi, senza mouse, dovrete usare le dita per andare a puntare una frase precedente o successiva, per correggerla. Provate a compilare un modulo Web, di qualsiasi tipo: molto più comodo utilizzare tastiera & mouse. Sono davvero molte, molte, molte le occasioni in cui vorrei tastiera & mouse su iPad, molte più di quelle che pensavo. E difatti una tastiera BT l’ho presa, poco utilizzata perchè alla fine l’OS è studiato per essere touch. Il fatto è che iPad è pensato per essere un device da affiancare ad un pc tradizionale: nessuno si sognerebbe mai di avere in casa un iPad e basta, perchè è volutamente limitato, prima di tutto nell’offerta delle app. Ok, ce ne saranno milioni e miliardi, ma sono tutte app apposta per iPad, studiate per il touch.

Io mi sento di dire, insomma, che per l’utente medio, Surface RT è in grado di sostituire senza problemi un notebook. Poco conta che non ci sia il desktop. A cosa serve il desktop? Office 2013 c’è. E se manca, cosa manca davvero all’utente finale medio? Lui vuole Facebook, vuole un gioco, i social network, navigare sul Web. E se il mercato delle app Metro, chiamiamolo così, cresce, avrà tutto ciò che serve.

Per questo dico che se il prezzo di Surface RT, supponiamo, fosse di 599 euro, non va considerato come il prezzo di un misero tablet come iPad, ma quasi messo a confronto con il prezzo di un pc. Perchè iPad è solo un tablet con sue app dedicate, mentre Surface (anche solo RT) è un PC. Perchè per me “pc” non sta ad indicare che c’è il desktop o chissà cosa, ma è soprattutto una questione di usability. Se sono sul letto con Surface, a navigare, ed improvvisamente devo scrivere una mail urgente, vado alla scrivania e usando lo stesso dispositivo, attacco tastiera & mouse e diventa un pc in tutto e per tutto. Fatelo con un iPad: impossibile! Idem per i videogiochi: grazie ai tablet e ad iPad sono rinate tante belle idee sui videogiochi (bloccando un po’ la rincorsa alla grafica più sfrenata), ma tornando indietro al concept ed al gameplay semplice, casual ed efficace. una cosa odio davvero: il joystick virtuale, sullo schermo, che è proprio inusabile. Inusabile. Inusabile. E’ solo un pagliativo per far credere a noi gamer che spostando le dita sullo schermo come se ci fosse un joypad sia una cosa bella e figa. Inusabile.

Con Surface questo problema non sussiste: sono assolutamente convinto che fra un po’ le software-house di videogiochi afferreranno la grande opportunità di fare videogiochi capaci di sfruttare l’ambiente Windows 8, e quindi fare videogame che supportano tastiera/mouse/touch/giroscopi/gps/etc. etc. Ma non solo: per tutti i motivi già detti, potremo anche switchare da una usability all’altra, in base a come decidiamo di usare il device in un dato momento.

Insomma, 600 euro per un iPad sono una cosa. 600 euro per un Surface RT sono molto meglio. Tecnicamente parlando, come sempre. Sono prevalentemente un tecnico, e non sto dicendo da che parte andrà il mercato, niente affatto. Sto dicendo che con Surface RT le possibilità di utilizzo sono molte, molte, molte, molte di più. Mail, Evernote, ovunque ci sia da scrivere un po’…con la tastiera fisica è meglio.

Concludo dicendo che ci sarebbe molto altro da dire. Preciso una cosa: mi auto-escludo da questo mio pensiero. Non mi considero un utente medio, e spendere quei soldi per un device comunque limitato non mi sembra l’ideale. Le mie esigenze sono altre. Punterò direttamente a Surface Pro, che invece sarà un vero ultrabook convertibile.

La notifica di tipo toast è in pratico un piccolo banner che appare per qualche secondo lungo il lato superiore dello schermo: esso riporta l’icona dell’app che ha ricevuto quella notifica, ed un breve testo informativo sulla notifica stessa. E’ in pratica ciò che vedete quando ricevete un SMS. Il testo ovviamente dipende dall’app, e può contenere una mention che arriva da Twitter, una nuova medaglia vinta alle Olimpiadi, etc. etc.

La tile invece è la tile dell’app che avete posizionato sulla Start Page. Se l’app lo prevede (ad esempio quella di WhatsApp) la tile viene aggiornata in modo silenzioso. WhatsApp vi mette un numerino che vi dice quanti messaggi avete ricevuto. Le app di previsioni del tempo aggiornano la tile dicendovi la temperatura corrente, Foursquare su richiesta può mostrarvi la classifica corrente, Facebook vi dice le notifiche, etc. etc.

La tile ha un enorme vantaggio rispetto alla toast, che secondo me è ben riassunto dal titolo. Se nel momento in cui ricevete una notifica di tipo toast non avete lo smartphone a portata di mano, sotto’occhio, molto probabilmente ve la perderete. Il display si accende, visualizza il toast, e poi si spegne. Non ne rimane traccia. Toast volant, insomma. La tile invece si aggiorna e rimane lì dov’è. Quindi se lasciate il telefono per due ore, quando lo riprendete in mano vedete le varie tile aggiornate. Che poi è la stessa cosa che accade con gli SMS, le telefonate perse, etc. etc. Tile manent.

Per questo io consiglio a tutti voi di implementare sempre le notifiche di tipo tile. Dal punto di vista sviluppatore, se avete messo in piedi tutta l’infrastruttura per inviare notifiche alla vostra app, cambiare da toast a tile è poca cosa. E’ solo questione di formattare in modo corretto il messaggio, cambiando l’XML e qualche altro parametro. Dal punto di vista utente…lui non le perde mai e probabilmente consumano meno (lo schermo non si accende, e non c’è alcun suono).

Ultima cosa, ma questa è più che altro un suggerimento a Microsoft: secondo me, se un’app richiede in modo importante che la sua tile sia pinnata sulla Start Page, deve essere indicato in modo forte all’utente. Addirittura, sono quasi dell’idea che la tile deve pinnarsi automaticamente sulla Start Page, esattamente come in Windows l’icona viene messa sul desktop. Immaginate il già citato WhatsApp: lo installate, ma se non mettete la tile sulla Start Page non riuscirete mai a capire quando ricevete qualcosa oppure no. Siete costretti ad aprire l’app ogni tanto, giusto per controllare. Non è accettabile, si perde il concetto di notifica, ma è più un polling da parte nostra. WhatsApp richiede che la tile sia sulla Start Page: perchè a questo punto non metterla automaticamente. O magari fare una domanda all’utente proponendogli di mettere la tile?

Generalmente, dal punto di vista client (quindi un’applicazione WPF, un’app Windows Forms o Windows Phone, un’applicazione ASP.NET MVC, etc. etc.) un servizio WCF è un servizio al quale forniamo dati, compie elaborazioni e restituisce qualcosa. Questo avviene con chiamate a metodi esposte dal servizio tramite un contratto (un’interfaccia IQualcosa), grazie al quale noi sappiamo come comunicare, cosa passare e cosa ci aspettiamo come valori di ritorno. Questo tipo di approccio non presenta nessun tipo di problema (in realtà ce ne sono una valanga, sicurezza in primis, ma sorvoliamo): una volta che il servizio è stato esposto via http, è sufficiente aggiungerlo al nostro progetto corrente tramite il comando “Add Service Reference”. Sul nostro client viene creata una classe proxy da utilizzare per effettuare le chiamate.

Quello che succede in uno scenario di questo tipo è che il client, indipendentemente dal tipo, invoca il servizio WCF. Quest’ultimo lavora un po’ e poi restituisce i dati al client. Semplice, almeno concettualmente.

Quello su cui ho lavorato per una giornata intera è invece lo scenario seguente:

• applicazione Windows 8 Metro-style, scritta in C#
• servizio WCF in ascolto su http://localhost:1976
• il servizio WCF non solo espone dei metodi che vengono invocati dall’applicazione, ma è in grado – tramite callback ed un canale di comunicazione duplex, di invocare un metodo definito sul client

Il servizio WCF, quindi, ha diverse particolarità:

• si deve memorizzare da qualche parte il “chiamante”
• deve definire non solo un contratto col quale dialogare con il client, ma anche un contratto di callback. Quest’ultimo definisce il/i metodi da invocare sul client

Arriviamo al sodo, vediamo un po’ di codice.

Codice Server Side
Implementiamo un servizio che prende in input un ExecuteRequest e restituisce, prima o poi, un ExecuteResponse.

[DataContract]
public class ExecuteRequest
{
    [DataMember]
    public int Value { get; set; }
}

[DataContract]
public class ExecuteResponse
{
    [DataMember]
    public int Value { get; set; }
}

Ho scritto “prima o poi” perchè supponiamo che l’esecuzione server-side sia piuttosto lunga; quindi, NON facciamo un metodo simile a questo:

[ServiceContract]
public interface IExecuteService
{
    [OperationContract]
    ExecuteResponse Execute(ExecuteRequest value);
}

bensì facciamo come segue:

[ServiceContract(CallbackContract = typeof(IExecuteServiceCallback))]
public interface IExecuteService
{
    [OperationContract]
    void Execute(ExecuteRequest value);
}

Invochiamo il metodo Execute passandogli un ExecuteRequest, che restituisce void. Il servizio WCF lavora, lavora, lavora, e prima o poi chiamerà la callback per informarci del risultato. La funzione di callback è indicato all’interno dell’attributo ServiceContract, ed è IExecuteServiceCallback.

public interface IExecuteServiceCallback
{
    [OperationContract(IsOneWay = true)]
    void ExecuteTerminated(ExecuteResponse response);
}

L’implementazione del servizio è piuttosto semplice:

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
public class ExecuteService : IExecuteService
{
    private ExecuteRequest Request;
    private ExecuteResponse Response = new ExecuteResponse();
    private IExecuteServiceCallback Callback;

    public void Execute(ExecuteRequest value)
    {
        this.Callback = OperationContext.Current.GetCallbackChannel<IExecuteServiceCallback>();
        this.Request = value;

        Timer timer = new Timer(10000);
        timer.Elapsed += (s, e) =>
            {
                timer.Stop();

                this.Response.Value = this.Request.Value * 3;
                this.Callback.ExecuteTerminated(this.Response);
            };
        timer.Start();
    }
}

Quando il cliente invoca il metodo Execute esposto dal servizio, accade che:

• il servizio si memorizza chi è il chiamante e predispone la callback
• al client restituisce un void

A solo scopo di test, parte un timer che fa aspettare il client 10 secondi, al termine dei quali viene invocata la callback sul client con il risultato dell’operazione. Praticamente, ciò che accade è che il client invoca il metodo passando un numero intero, ed il servizio restituisce il doppio di tale numero. Ripeto: è solo a scopo di test, si presuppone che un processore moderno si metta un po’ meno a calcolare il doppio di un numero!

Un pezzetto di web.config

C’è qualche accorgimento da apportare anche nel web.config. L’endpoint deve essere di tipo netHttpBinding. Come recita MSDN all’indirizzo http://msdn.microsoft.com/en-us/library/hh674273.aspx, infatti:

NetHttpBinding is a binding designed for consuming HTTP or WebSocket services and uses binary encoding by default. NetHttpBinding will detect whether it is used with a request-reply contract or duplex contract and change its behavior to match – it will use HTTP for request-reply contracts and WebSockets for duplex contracts.

Riporto qui sotto la parte più significativa del web.config:

<system.serviceModel>
    <services>
      <service name="WcfCallbackSample.ExecuteService"
            behaviorConfiguration="bev1">
        <host>
          <baseAddresses>
            <add baseAddress="http://localhost:1000/Service" />
          </baseAddresses>
        </host>
        <endpoint name="duplexendpoint" address=""
            binding="netHttpBinding"
            contract="WcfCallbackSample.IExecuteService" />
        <endpoint name="MetaDataTcpEndpoint" address="mex"
        binding="mexHttpBinding" contract="IMetadataExchange" />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="bev1">
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="True" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <protocolMapping>
      <add binding="basicHttpsBinding" scheme="https" />
    </protocolMapping>
    <serviceHostingEnvironment aspNetCompatibilityEnabled="true"
    multipleSiteBindingsEnabled="true" />
</system.serviceModel>

Ovviamente alcuni valori, attributi e nodi XML dipendono dal vostro servizio.

Client Side con un’applicazione Metro per Windows 8

Ok, abbiamo quasi finito. Adesso arriva il bello, ovvero usare il nostro servizio dal client. Dopo averlo aggiunto nei service reference, ci verrebbe istintivo utilizzare la classe client proxy che ci è stata auto-generata. No. Falso. Nada. Fermi tutti.

Innanzitutto con Visual Studio 2012 creiamo una nuova Blank app, sotto la categoria Windows Store.

Dentro troveremo un’unica Page, nel cui costruttore metteremo:

EndpointAddress address = new EndpointAddress("http://localhost:1924/ExecuteService.svc");
var binding = new NetHttpBinding();
var cf = new DuplexChannelFactory<IExecuteService>(new InstanceContext(this), binding, address);
service = cf.CreateChannel();

L’oggetto service, definito come private della Page, è di tipo IExecuteService, ed è grazie a questo che potremo utilizzare il nostro servizio.

A questo punto aggiungiamo un Button nello Xaml, gestiamo l’evento Click, e nel code-behind inseriamo:

service.ExecuteAsync(new ExecuteRequest() { Value = 4 });

Proviamo ad eseguire l’app: è Metro-style, per cui come sappiamo che gira in full-screen. Clicchiamo sul Button. Non accade nulla. Ed è perfettamente normale, pensiamoci bene. La chiamata a Execute (che avviene in async) restituisce void. Cosa manca? Non abbiamo la callback, ovvero quel meccanismo che il server adotta per avvisarci quando lui ha terminato il calcolo. Morale: la Page deve implementare l’interfaccia di callback.

public sealed partial class MainPage : Page, IExecuteServiceCallback
{
    public async void ExecuteTerminated(ExecuteResponse response)
    {
        MessageDialog dialog = new MessageDialog(response.Value.ToString());
        await dialog.ShowAsync();
    }
}

Il timer, istanziato ed in esecuzione lato server, invoca la callback chiamando il metodo ExecuteTerminated sul client, e quindi apparirà la nostra MessageDialog con il risultato dell’operazione.

In ottica Model-View-ViewModel

In ottica MVVM, ovviamente, non sarà direttamente la Page ad implementare l’interfaccia IExecuteServiceCallback, ma la classe View Model che governa quella view. Il View Model gestisce la callback, lavorerà sulle proprie proprietà pubbliche per aggiornare la view.

- evita, come già detto, di dover definire tanti MediaElement nello Xaml, ciascuno con il suo nome. Dico “tanti” perchè se in un pagina dovevate far sentire più suoni (contemporanei o no) dovevate per forza mettere più MediaElement (a meno di non usarne uno solo switchando da un source all’altro)
- miglior utilizzo del MVVM, conseguenza del punto precedente. Nel ViewModel associato ad una pagina posso mandare in play un suono senza aver a che fare con la view corrente

Detto questo, mi sono potuto fare una serie di classi helper:

public static class MediaElementGenerator
{
    public async static Task<MediaElement> Get(string source)
    {
        MediaElement result = new MediaElement();
        var package = Windows.ApplicationModel.Package.Current;
        var installedLocation = package.InstalledLocation;
        var storageFile = await installedLocation.GetFileAsync(source);
        
        if (storageFile != null)
        {
            var stream = await storageFile.OpenAsync(Windows.Storage.FileAccessMode.Read);
            result.SetSource(stream, storageFile.ContentType);
        }

        return result;
    }
}

Questa riportata qui sopra è una classe statica che lavora in modo asincrono (async/await) e che restituisce un MediaElement associato ad un source specifico. Il source ovviamente deve essere un qualsiasi Uri, che punta ad un file wav/mp3 incluso come “Content” all’interno della nostra solution.

All’interno dei miei ViewModel utilizzo ciò che mi viene esposto dalla classe ApplicationContext:

private async Task Play(string source)
{
    if (ApplicationContext.Instance.Sound)
    {
        if (!this.MediaElements.ContainsKey(source))
        {
            this.MediaElements.Add(source, await MediaElementGenerator.Get(source));
        }

        this.MediaElements[source].Play();
    }
}

public async Task PlayClickButton()
{
    await this.Play("Media\\ClickButton.mp3");
}

public async Task PlayReady()
{
    await this.Play("Media\\Ready.mp3");
}

Gli ultimi due metodi pubblici (PlayClickButton e PlayReady) si appoggiano su Play che invece è privato. Notare che nel metodo Play controllo anche che il suono all’interno dell’applicazione sia attivo: ricordiamoci infatti che è buona norma permettere all’utente di attivare/disattivare i suoni nelle nostre app Windows 8, tramite il pannellino dei settings che va gestito correttamente. Ma questo è forse un tema da affrontare in un altro post.

string version = System.Reflection.Assembly.GetExecutingAssembly().FullName.Split(',')[1];
string[] fullversion = version.Split('=')[1].Split('.');
return fullversion[0] + "." + fullversion[1];

Questo mi permette di estrarre dal FullName di un Assembly il numero di versione dell’assembly stesso, molto comodo per essere visualizzato su una Page di Silverlight.

Il codice da scrivere con WinRT, e quindi con Windows 8, è leggermente diverso.

string version = typeof(<qualsiasi_classe_usata_nel_codice>).GetTypeInfo().Assembly.FullName.Split(',')[1];

La differenza è tutta nella prima riga di codice. In pratica si tratta di avere un’istanza di Type relativa ad una qualsiasi classe del proprio codice, chiamare il metodo GetTypeInfo(), per arrivare all’Assembly, etc. etc. Notare che GetTypeInfo() è un’extension method, per cui bisogna includere il namespace System.Reflection.

Tutto qua, il resto del codice è analogo al precedente. Con qualche split si ottiene il numero di versione dell’assembly.

• occupazione di memoria RAM minima: sul mio notebook, nel momento in cui vi sto scrivendo, mi sta impegnando 3,3Mb
• disponibilità su diversi OS, desktop e mobile: ovviamente Windows, ma anche Blackberry, iPad
• senza fronzoli: è semplice ed immediato. Ok, non avrà chat video e non permette il trasferimento di files. Ma alla fine sono funzionalità che non uso. Trovo invece molto comoda la possibilità di impostare lo stato “Occupato” con un messaggio personalizzato (“torno subito”, “sto facendo merenda”, “mi prendo un caffè”, etc.)
• salvataggio della chat in un folder dedicato su GMail. Questa francamente è una funzionalità imbattibile. Spesso attraverso GTalk il mio capo mi dice cosa bisogna implementare, quali bachi ha trovato, cosa suggerisce lui per sistemare le cose. Questo sia che si parli di un sito ASP.NET MVC, di un’applicazione desktop WPF, di un database SQL Server. La possibilità di rileggere con calma anche in un secondo momento tutto quanto è assolutamente impagabile
• spesso e volentieri GTalk non è bloccato dai firewall aziendali, e quando sei in trasferta, da un cliente, sai che hai uno strumento su cui fare affidamento
• sono convinto del fatto che gira anche su uno scassatissimo ed antiquato Pentium III con XP

Tutte queste funzionalità fanno decisamente vincere GTalk. So benissimo che ci sono strumenti decisamente più evoluti (cito i primi che mi vengono in mente Messenger, Skype, Lync), ma non offrono le caratteristiche vincenti di cui sopra. Ovviamente ne hanno altre, su questo non si discute, ma preferisco avere poche caratteristiche ben sfruttate, che un miliardo che invece rimangono lì sopite e che però mi impegnano memoria RAM. Messenger, per esempio, permette di chattare con gli utenti Facebook, cosa che non mi interessa affatto se sto lavorando: anzi, sarebbe solo di disturbo. Skype su Windows 8, oltre ad occupare centinaia di MB, spesso e volentieri si inchioda.

Qualcuno mi ha informato che il team di GTalk è stato chiuso qualche anno fa, e che quindi non bisognerebbe più usarlo. Da quando bisogna usare solo software i cui sviluppi sono ancora in corso? Che regola è? Quindi non dovremmo più usare notepad? Se uno strumento è affidabile e fa al caso mio, lo utilizzo eccome. Non me ne frega nulla se il team non ci lavora più o è stato chiuso!

Insomma. GTalk è morto, lunga vita a GTalk!!!

Casa mia, qualche mese fa, durante un cena in giardino
Quando mangiamo in giardino, non c’è tv, per cui ci perdiamo in chiacchere e discussioni varie. Quel giorno mia madre riporta una news secondo la quale un papà ha chiesto un ricovero di “disintossicazione da smartphone” per una delle loro figlie adolescente (presumibilmente un iPhone). La ragazzina, a quanto pare, sta sempre attaccata allo smartphone, ai social network, a qualche giochino, a questo o a quello.

Quando sento queste cose, vi chiedo scusa, ma mi arriva sempre il sangue al cervello. D’istinto, tra una risatina scettica e l’altra, ho ribattuto immediatamente: e se quella ragazzina, invece di uno smartphone, se ne stesse sempre chiusa in camera a leggere libri, la famiglia avrebbe comunque chiesto la disintossicazione? Non ho avuto alcuna risposta.

Qualche sabato sera fa, sui Navigli a Milano, ore 23:00
Io e qualche altra persona eravamo seduti al Banco, uno dei locali sui Navigli di Milano. Locale affollato, musica, cocktail, ragazze, risate, buonumore. Ad un certo punto, entra una ragazza, mora, carina, vestitino verde lungo, età approssimativa…25 anni. Ha in mano uno smartphone, non capisco il modello ma sarà presumibilmente un iPhone. Scorre, digita qualcosa, cambia app, testa bassa. Si siede al bancone, giusto il tempo di ordinare qualcosa, mentre continua ad usare lo smartphone senza staccare gli occhi dal display. Nel giro di venti minuti, la tipa beve e se ne va. Senza parlare con nessuno, senza staccare gli occhi dallo smartphone, eppure chissà con quante persone si è tenuta in contatto.

Fine degli aneddoti.
Insomma, questa storia della disintossicazione da Internet, dal web, dai pc comincia a starmi seriamente sulle scatole.

Il discorso alla fin fine è questo: se fare una certa azione è diventato semplice ed intuitivo, non c’è nulla di intossicante nel farla. Oggi usare uno smartphone, vedere un sito Web, dare uno sguardo a twitter, mantenere il proprio giro di amicizie, è diventato veloce, semplice ed intuitivo. Personalmente, ritengo che una cosa mi intossichi se alza il mio livello di stress: allora sì diventa una cosa da evitare.

E’ per questo motivo che non ci vedo nulla di male se ci si porta il pc in vacanza o se si usa uno smartphone in posti fino a qualche anno fa impensabili (non tanto perchè non fosse tecnicamente possibile, quanto perchè sennò si era inquadrati come marziani o nerd da evitare). L’importante è che l’utilizzo di tali strumenti avvenga in modo naturale, intuitivo, senza sbattimenti, per dirla alla buona. Vi posso assicurare che avrei da raccontarvi diversi altri episodi che illustrano come effettivamente pian piano questa visione della “tecnologia facile” si diffonda, ma c’è ancora molto da fare: in campeggio vedo sempre più notebook, tablet, smartphone e dispositivi di ogni tipo – compresi ragazzi e ragazze che discutono su quale OS sia il migliore (vi giuro che è così). Prima dell’anno scorso mai e poi mai mi sarei sognato di attaccare il mio notebook nel bar del villaggio turistico di un paesino del sud, per non fare la classica figura da nerd, adesso se lo faccio sono quasi l’eroe del paese perchè tutti vogliono vedere le foto che scatto, e mi chiedono questo e quello. Scenario impensabile, fino ad un paio di anni fa.

Perciò, concludendo, per favore: non chiedeteci alcuna disintossicazione, perchè non siamo intossicati. Noi viviamo bene, con la nostra tecnologia, esattamente come una massaia si trova a suo agio ai fornelli, un ciclista con la sua bici, un lettore con il suo libro, un appassionato di puzzle davanti alle sue tile, un enigmista con il suo cruciverba, e così via. Il fatto è che oggi la tecnologia permea ogni aspetto della nostra e della vostra vita, e quindi diventa sempre più naturale averla sempre a disposizione, anche e soprattutto al fatto che ormai ci sono device cool (fighi?) che rendono un oggetto gradevole alla vista, adatto ad un locale milanese il sabato sera. E per questo, grazie Apple.

Tecnologia è emozione e passione. E quindi vita.
Perchè privarsene, dunque?

Questo è il link diretto al marketplace con l’elenco di tutte le mie app.

Ieri pomeriggio e ieri sera ho lavorato per su tutte le app – aggiornamento che è sicuramente già arrivato su tutti i vostri smartphone Windows Phone.

Non si tratta infatti di un aggiornamento riguardante l’app in sé, ma solo sulle informazioni che vengono riportate, quindi, per esempio:

• nomi di presidenti o allenatori cambiati
• serie in cui milita la squadra
• nome dello stadio di appartenenza e relativa capienza
• trofei vinti durante la scorsa annata (scudetti, coppe Italia, SuperCoppe, etc.)

Quindi, una squadra ha vinto uno scudetto, altre sono state retrocesse, altre ancora sono state promosse, e così via. Tutte informazioni che adesso vengono riportate correttamente da tutta la mia suite di app, aggiornate secondo quanto riportato da Wikipedia. Alcune squadre di serie B sono state ovviamente retrocesse, e quindi da quest’anno ci sono alcune app che riguardano squadre che nel prossimo campionato giocheranno nella Lega Pro Prima Divisione.

Ecco un breve riassunto, per concludere, delle squadre e relative app che giocheranno durante il prossimo campionato 2012/13.

SERIE A
I Love Atalanta
I Love Bologna
I Love Cagliari
I Love Catania
I Love Chievo
I Love Fiorentina
I Love Genoa
I Love Inter
I Love Juventus
I Love Lazio
I Love Milan
I Love Napoli
I Love Palermo
I Love Parma
I Love Pescara
I Love Roma
I Love Sampdoria
I Love Siena
I Love Torino
I Love Udinese

SERIE B
I Love Ascoli
I Love Bari
I Love Brescia
I Love Cesena
I Love Cittadella
I Love Crotone
I Love Empoli
I Love Grosseto
I Love Juve Stabia
I Love Lecce
I Love Livorno
I Love Modena
I Love Novara
I Love Padova
I Love Reggina
I Love Sassuolo
I Love Varese
I Love Verona

LEGA PRO PRIMA DIVISIONE
I Love Albinoleffe
I Love Gubbio
I Love Nocerina
I Love Vicenza

Ci sono tre nuove squadre che dalla Lega Pro Prima Divisione sono salite alla serie B. L’app arriverà molto presto su tutti i vostri Windows Phone. Le squadre sono:

I Love Pro Vercelli
I Love Spezia
I Love Virtus Lanciano

Saranno molto probabilmente pronte prima di agosto! Stay tuned!

1. una tabella “Subscribers” sul database SQL Server che mantenga i subscriber per quella specifica app
2. implementare sul servizio WCF specifico dell’app i metodi Subscribe/Unsubscribe invocati internamente all’app per permettere all’utente di attivare/disattivare le notifiche

Dal punto di vista server, ogni mia app (Duello in Cucina, Deputati Italiani, la futura Diretta Volley, Piloti Virtuali Italiani, etc.) ha bene o male una certa parte di sistema ripetuta, cosa che cominciava a non andarmi del tutto a genio. Inoltre può sembrare poca roba, ma vi assicuro che non è così. Ed anche se fosse poca roba, è comunque una cosa da ripetere e scrivere ogni volta, con rischio ovviamente di codice ripetuto, a rischio di bug, etc. etc. Quindi, mi sono detto, sarebbe fattibile creare un’unica infrastruttura database & WCF talmente generica da poter essere sfruttata in ogni mia futura app, indipendentemente dal fatto che sia Windows Phone o Windows 8, per gestire le push notification? E magari talmente generica da poter essere addirittura “venduta/affittata” a terzi? La risposta è ovviamente sì.

Cosa vi metto quindi a disposizione?
E’ semplice: un servizio WCF che espone i seguenti metodi:

I metodi sono autoesplicativi:

1. va chiamato il metodo Subscribe quando da una qualsiasi delle vostre app wp7/win8 volete aggiungere un nuovo subscriber
2. va chiamato il metodo Unsubscribe quando da una qualsiasi delle vostre app wp7/win8 volete rimuovere un nuovo subscriber

Il metodo Push invece deve essere invocato dal vostro servizio web/cloud: questo è il vero motore che invia le notifiche a tutti i subscriber relativi alla vostra app.

Chiaramente le chiamate ai metodi WCF descritti qui sopra utilizzano una serie di classi (SubscribeRequest, UnsubscribeRequest e PushRequest) che incapsulano un po’ di informazioni, grazie alle quali vi autenticate, mi dite che siete (inteso come “cliente”), mi dite quale app siete, etc. etc. Nel momento in cui volete inviare le notifiche, stessa cosa: mi dite chi siete, quale app siete, il tipo di notifica (toast, tile, badge, etc.), l’xml della push notification che volete inviare, etc. etc.

Io mi occupo di memorizzare sui miei server i vostri utenti e di inviare a tutti la notifica.

Limitazioni
Chiaramente, per ora metto a disposizione questa cosa solo ad amici e colleghi developer.

Ci sono alcune limitazioni note di cui vi voglio parlare.

1. Poca sicurezza, nel senso che ad oggi mi dovete comunicare (solo per le app Windows 8) la SecretKey ed il Sid relativo a ciascuna app che volete gestire
2. Non c’è la possibilità di fare push notification “selettive”: cioè, se la vostra app ha 1000 subscribers attivi, in questo momento la chiamata al metodo Push invia a tutti la notifica, mentre in realtà potrebbe non essere così (immaginate un’app di calcio, ed immaginate che l’utente voglia ricevere una notifica solo quando segna la squadra per cui tifa – questo scenario non è ancora coperto – ma ci sto lavorando su)

Se volete aiutarmi, se volete provarlo, se avete qualche suggerimento/segnalazione da darmi, sono tutt’orecchi!

In pratica, ho implementato una normalissima Page che – in condizioni normali di full-screen – mostra una BingMap che visualizza un volo aereo. Sulla mappa potete fare normali operazioni come zoom, pan, etc. etc. Nella versione snapped view della stessa pagina avevo deciso di rimuovere la BingMap, e di mostrare solo un’altra serie di informazioni. Quello che accadeva è nel momento in cui facevo lo snap della pagina, l’app si schiantava e Visual Studio mi segnalava una unhandled exception. Ho cercato di capire per sicuramente più di un paio d’ore, alla fine sono riuscito ad isolare il problema, che riguardava proprio la BingMap. Se la rimuovevo dallo XAML, infatti, tutto funzionava senza problemi. La cosa si verificava sia se metteva in snapped la pagina – come ho appena descritto – sia se partivo dalla pagina precedente in snapped view.

Come risolvere?

Questa cosa è spiegata sommariamente nella sezione Q&A della pagina Bing Maps SDK for Metro style apps (RP).

Per risolvere, quindi, basta impostare una MinWidth al controllo BingMap, impostandolo ad un valore qualsiasi maggiore di zero. A quanto pare, infatti, durante l’operazione di snapping la width e la height finiscono uguali a zero, causando non pochi problemi, tra cui il crash dell’app e del debugger. Io l’ho impostata a “160” ed il problema è sparito!

• vedo un contenuto interessante all’interno di un’app (una foto, un link, un articolo, un punteggio in un videogioco, il prezzo di un articolo, un film da vedere al cinema, qualsiasi cosa) e decido di condividerla con qualcuno
• l’espressione “condividerla con qualcuno” è volutamente generica, perchè vuol dire un sacco di cose (molte delle quali ancora da intuire, probabilmente): vuol dire poter mandare una mail, twittare, postarla sulla propria pagina Facebook, postare una foto su PInteret, marcare un link tra quelli preferiti in Diio, aggiungere una foto in un photoset di Flickr, etc. etc.
• per farlo, l’utente non deve far altro che richiamare lo charm di Share di Windows 8 premendo Win + H (oppure Win + C e poi cliccare su Share). Se l’app che state usando prevede questa funzionalità, Windows 8 mostrerà l’elenco di app installate nel sistema che sono predisposte a condividere l’informazione

Nell’app Windows 8 che sto sviluppando, pviCommunity, è possibile per esempio fare lo share di fotografie scattate durante i voli virtuali di Piloti Virtuali Italiani. Ogni fotografia è identificata da un url ben preciso, quindi…mi sono detto…perchè non permette di twittare dalla mia app quanto sia bella una certa foto. Sappiamo tutti che i tweet hanno una lunghezza massima di 140 caratteri. L’url di una fotografia può essere una cosa tipo questa:

http://service.vivendobyte.net/FlightLogs/7600/2012-7-6_11-47-26-546.jpg

E’ una fotografia reale, quindi se cliccate sul link potete tranquillamente guardarla.

La domanda è la seguente: come è possibile fare lo short di questo url, per esempio usando le API di Google. Il primo passo è quello di registrarsi qui per ottenere una apikey da utilizzare direttamente nel vostro codice C#. Fatto questo, utilizzate questa classe per fare tutto il resto:

public static class GoogleUrlShortnerApi

    {

        private const string key = "api_key";

        public static string Shorten(string url)

        {

            string post = "{\"longUrl\": \"" + url + "\"}";

            string shortUrl = url;

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create("https://www.googleapis.com/urlshortener/v1/url?key=" + key);

            try

            {

                request.Method = "POST";

                request.ContentType = "application/json";

                using (Stream requestStream = request.GetRequestStreamAsync().Result)

                {

                    byte[] postBuffer = System.Text.Encoding.UTF8.GetBytes(post);

                    requestStream.Write(postBuffer, 0, postBuffer.Length);

                }

                using (HttpWebResponse response = (HttpWebResponse)request.GetResponseAsync().Result)

                {

                    using (Stream responseStream = response.GetResponseStream())

                    {

                        using (StreamReader responseReader = new StreamReader(responseStream))

                        {

                            string json = responseReader.ReadToEnd();

                            shortUrl = Regex.Match(json, @"""id"": ?""(?<id>.+)""").Groups["id"].Value;

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                // if Google's URL Shortner is down...

                System.Diagnostics.Debug.WriteLine(ex.Message);

                System.Diagnostics.Debug.WriteLine(ex.StackTrace);

            }

            return shortUrl;

        }

    }

Il codice è pensato per girare all’interno di un’app Windows 8 Metro-style, chiaramente.

Facciamola breve. Gli ingredienti di cui avete bisogno per mettere in piedi le push notification per la vostra app Metro sono i seguenti:

• ovviamente, un’app Metro-style Windows 8. La vostra app deve permettere ai vostri utenti di sottoscriversi alle notifiche push: questo vuol dire banalmente mettere un controllo tipo ToggleSwitch nei settings della vostra app grazie al quale l’utente può scegliere se ricevere oppure no le notifiche (poi sta a voi magari fargli scegliere se vuole ricevere solo le tile notification, oppure solo le toast, le badge, etc. etc.). E’ buona norma farvi restituire l’esito di questa operazione, per informare l’utente se tutto è andato bene oppure no: questo può essere un semplice bool oppure qualcosa di più complesso. Quando una vostra app si sottoscrive alle push notification riceve un url, che identifica univocamente quel device e quell’applicazione
• un vostro “cloud-service”, ovvero un servizio Web che al momento opportuno spara a tutti i vostri utenti la notifica. In quasi tutte le mie app Windows Phone 7 ho praticamente un servizio WCF che fra le altre cose serve anche a questo scopo. In pratica, quindi, vi serve un qualsiasi servizio di hosting che vi metta a disposizione database SQL Server, l’hosting di servizi WCF, etc. etc.
• tornando al punto (1), quando l’utente attiva il ToggleSwitch invoca un metodo esposto dal servizio WCF, che si occupa di memorizzare server-side gli url che vengono associati al proprio dispositivo (dico dispositivo perchè potrebbe essere un pc, un notebook, un ultrabook, un tablet, un Surface, un qualsiasi dispositivo su cui gira Windows 8)

I punti qui sopra sono ovviamente un po’ più complessi, andrebbero sviscerati fino a riempire libri su libri. Io la faccio molto semplice, basta googlare per raccogliere informazioni in quantità. E devo anche aggiungere che MSDN è decisamente migliorata sotto questo punto di vista, rispetto ai primi tempo con Windows Phone. Adesso potete davvero trovare quickstart, tutorial, esempi di codice, xml, etc. etc.

Per cui una volta messa in piedi tutta l’infrastruttura software, la cosa è piuttosto semplice. Quando si scatena un determinato evento, il servizio WCF passa in rassegna la tabella dei vostri utenti che vogliono ricevere le notifiche: per ciascuno dei vostri utenti avete un url che lo identifica in modo inequivocabile ed univoco. A questo url inviate un certo blocco XML ed il gioco è fatto. L’XML può identificare qualsiasi tipo di notifica, anche se di un solo tipo per volta: non potete specificare con un unico XML una notifica toast e di tipo tile. All’interno di una notifica tile, però, potete specificare sia quella square che quella wide (ovvero: sia quella quadrata, che quella rettangolare): questo è indispensabile, perchè dal punto di vista del servizio WCF non sapete quale tile sta usando l’utente, e quindi è necessario mandargliele entrambe. Se sta usando quella square, vedrà quella, altrimenti quella wide.

Parliamo un secondo di settings della nostra app Windows 8 Metro-style.
Generalmente, con un’app Windows 8 verrebbe le tentazione di salvare tutti i settings all’interno di quelle roaming. Questo significa che i vostri settings viaggiano su tutti i device Windows 8 su cui state usando quell’app, e rimangono sincronizzate. Se cambiate un’impostazione su un PC, vi ritroverete la stessa impostazione su tutti gli altri device, insomma. Attenzione, però: parlando di push notification non è una buona idea. Nei settings delle mie app Windows 8 che fanno uso di push notification mantengo sempre due informazioni: un bool che mi dice se le notifiche sono attive, e l’url univoco di quel device. Questi due settings li salvo all’interno dei settings locali e non su quelle roaming, perchè sono impostazioni specifiche del device e non dell’app. Magari su un PC desktop (che non ha problemi di salvaguardia della batteria) vorrei sempre lasciare abilitate le notifiche, mentre potrebbe non essere la stessa cosa su un tablet. Su un device voglio le notifiche attive, sull’altro no. Quindi è opportuno decidere cosa salvare nei settings di tipo roaming, e cosa salvare nei settings di tipo local.

Forse la cosa più difficile è stato capire quali tipi di tile sono supportati dal sistema di notifiche (e quale XML inviare per ciascuna di esse, soprattutto).
Per questo vi lascio questa pagina:

http://msdn.microsoft.com/library/windows/apps/Hh761491

che riporta tutte le tile, siano essere quadrate o rettangolari. Ce ne sono un bel po’, che supportano solo testo, solo immagine, oppure testo ed immagine insieme, con diverse formattazioni.

Lo so, rispetto a tanti altri, questo post è un po’ sconclusionato: ho solo voluto riassumere in modo sparso un po’ di concetti con cui mi sono scontrato nei giorni scorsi, lavorando sulle push notification.

Di cosa si tratta?

Con Wikisticker potete pubblicare dei brevi messaggi (sticker) geolocalizzandoli. Questo significa che uno sticker viene indissolubilmente legato alla posizione in cui vi trovate, grazie al GPS integrato nel vostro telefono. Ogni sticker può essere pubblico (e quindi visibile a tutti quanti), oppure privato (quindi visibile solo al destinatario dello sticker stesso). L’app è diverse funzioni, che permettono di:

1. creare un nuovo sticker nel luogo in cui vi trovate (Wikisticker non solo prende le coordinate gps, ma anche come siete orientati, per cui occhio!)
2. vedere gli sticker pubblici e privati che stanno intorno a voi, in un raggio di 300 metri
3. gestire i propri amici: richiedere o accettare amicizie, individuare gli amici (quest’ultima funzione è davvero simpatica: possiamo decidere se condividere la nostra posizione in modo pubblico; in questo modo possiamo vedere sulla mappa di Bing dove si trovano i nostri amici, e quindi dove potenzialmente hanno lasciato i loro sticker

Wikisticker permette di vedere gli sticker in due modalità: o attraverso la classica mappa Bing geografica vista dall’alto, oppure attraverso la realtà aumentata. Quest’ultima modalità è davvero bellissima: ciò che accade è che il vostro smartphone vi fa inquadrare il mondo reale attraverso la telecamera integrata, e vedete in realtà aumentata gli sticker fluttuare a mezz’aria, con la fotografia dell’utente e chiaramente il messaggio.

L’app è davvero ben fatta: pulita, veloce, reattiva e molto pratica ed istintiva nell’utilizzo.

Gli scopi di Wikisticker sono molteplici. Il punto di forza è proprio la semplicità e la flessibilità: l’unico limite in pratica è la nostra fantasia. Il motto dell’app – “I luoghi vivono grazie a Wikisticker” – rende bene l’idea.

Possiamo lasciare messaggi e dediche in prossimità dei luoghi che ci stanno a cuore.
Possiamo lasciare un messaggio ricordo in prossimità di quel parco dove andavamo da bambini a giocare.
Possiamo consigliare un locale, un ristorante o un hotel, lasciando uno sticker proprio sulla porta d’ingresso.
Possiamo lasciare una dedica alla nostra innamorata nel luogo in cui si ha avuto il primo appuntamento.
E molto altro ancora: come dicevo prima, l’unico limite è la nostra fantasia!

Non so voi, ma a me affascina molto l’idea di disseminare il mondo di sticker virtuali con Wikisticker. E’ un modo come un altro per essere social, per rimanere in contatto, di convidere esperienze e di rendere noto il nostro lifestyle.

Per chiudere, vi lascio due link!

Uno è questo, relativo al blog ufficiale dell’app : http://www.wikisticker.com/post/2012/05/16/Wikisticker-modi-duso!.aspx

Il secondo è questo, ed è il link ufficiale dell’app sul Marketplace : http://www.windowsphone.com/it-IT/apps/6d351c9e-7b8f-4721-b22c-8dcb6dd7205b

Buon Wikisticker a tutti!

Giovedì sera, sebbene fossi piuttosto stanco dato il rientro dalla mia trasferta di lavoro in Valtellina (fatto sulla mia automobile, con aria condizionata guasta, con 28°C come temperatura esterna), ho preferito mettermi subito al lavoro e fare ciò che mi piace molto: l’assemblatore, soprattutto se fatto sul mio PC. Anche perchè, mi sono detto, se qualcosa non funziona ho tutto il tempo, il giorno dopo, di contattare Amazon e di gestire eventuali guasti e resi.

Cambiare un alimentatore ed una scheda video è una cosa piuttosto rapida: in circa 45 minuti, nella mia mansarda calda ed afosa, avevo già terminato tutto quanto. Ho tolto il vecchio alimentatore, ho inserito quello nuovo; ho tolto la mia vecchia Radeon 4850 per montare la nuova Radeon 6870, ho riorganizzato la cavetteria interna. Ho cercato, insomma, di dare il meglio di me! Aggiungo qualche nota che magari può essere utile.

1. La Radeon 4850 richiede uno slot PCI Express ed ha un solo connettore di alimentazione; in altezza occupa un solo slot
2. La Radeon 4870 richiede uno slot PCI Express, ha due connettori di alimentazione, ed in altezza occupa due slot
3. L’alimentatore è il Corsair da 850W, modello TX850M; sebbene sia indicato come modulare, occhio, in realtà è un semi-modulare!! Questo significa che un certo numero di cavi di alimentazione sono già cablati, come in un alimentatore normale, e che poi potete eventualmente connettere altri cavi (compresi nella confezione) all’occorrenza. Avrei preferito un alimentatore modulare puro, pazienza!

Terminato l’assemblaggio, portato a termine senza troppi sforzi, riattaccato il tutto e funziona tutto, al primo colpo. Mi ritengo molto soddisfatto. Ho solo dovuto riprogrammare nel BIOS la priorità d’avvio degli hard-disk: evidentemente nel staccare cavi e cavetti ho scambiato i connettori SATA. Poco male.

Avvio velocemente DiRT3, Skyrim, Call Of Duty MW3, giusto per alzare i dettagli grafici e vedere come rulla la nuova scheda video. Direi alla grande! Ma il tutto dura qualche minuto: sono davvero stanco, mi faccio una doccia e me ne vado a letto. Il giorno dopo utilizzo il mio PC in configurazione lavorativa, e non mi dà alcun tipo di problema. Le varie installazioni di Windows 7 e Windows 8 Consumer Preview rilevano la nuova scheda video senza battere ciglio.

Il brutto arriva venerdì sera, però.
Venerdì sera, complice il weekend, non prendo impegni nel mondo reale e decido di dare sfogo alla potenza della scheda video. Avvio Call Of Duty Modern Warfare 3, dettagli impostati su Ultra, alzo il volume delle mie casse Creative THX, mansarda nel buio assoluto, e comincio daccapo la campagna single-player. Completo le prime due missioni, sbalorditive ed ultra frenetiche, beandomi degli effetti grafici assolutamente spettacolari.

Le prime due missioni, decido, per stasera possono bastare. Appena sta per cominciare la terza, salvo tutto quanto e torno a Windows.
KKkKKaaaaaaBuUuUM!!! Faccio appena in tempo a vedere le icone del desktop, ed il pc sia spegne improvvisamente!
Niente, non c’è più verso di riaccenderlo! Come potete immaginare faccio un po’ di tentativi.

1. Apro il case e la scheda video è un pochino calda
2. Spengo la ciabatta, spegno l’alimentatore, stacco i cavi di alimentazione, aspetto un quarto d’ora: niente, il PC si raffredda ma non si accende più
3. Nemmeno la mattina dopo, nonostante abbia lasciato staccato il più possibile, il PC sembrava morto, ed ho dichiarato almeno l’alimentatore definitivamente KO

Come ho affrontato, e risolto il problema?

La mattina dopo, sabato, alle 8:00 era già all’opera per capire e risolvere il problema. Vi do qualche spunto.

1. Ho riattaccato i vecchi componente (alimentatore e scheda video), giusto per avere le prova del nove, e soprattutto di assicurarmi di aver salvato scheda madre, processore, RAM, etc. etc. Con i vecchi componenti il PC si accende, faccio il boot di Windows senza problemi
2. Riattacco i nuovi componenti ed il PC riprende a funzionare. Evidentemente lasciar scollegati i connettori sulla mainboard ha scaricato eventuale energia elettrostatica residua

Decido che la causa è il calore generato dalla e sulla scheda video. Lasciando il case aperto, infatti, ho installato 3D Mark 11 (in versione Basic) per far girare un po’ di demo e benchmark grafici. Dopo qualche minuto la scheda video diventa bollente, riesco appena a toccarla, e prendo posizione: così non va affatto bene. E decido di agire.

1. Non posso ovviamente cambiare posizione alla scheda video, il bus PCI Express 16x è lì e non posso spostarlo
2. Cambio slot alla Sound Blaster Audigy 4 Pro, su bus PCI, che era secondo me troppo vicina alla scheda video
3. Rimuovo una scheda su bus PCI per avere 4 porte USB aggiuntive: ne usavo una sola, per la webcam, e l’ho sacrificata
4. Ho acquistato una ventola aggiuntive da posizionare sulla scheda video, in modo tale da raffreddarla costantemente

Ho inoltre cominciato ad utilizzare Open Hardware Monitor, scaricabile da qui, che permette di monitorare tutta una serie di informazioni sul proprio sistema: temperature dei core della CPU, della GPU, degli hard-disk; velocità della ventole in RPM, carico della GPU e molto altro ancora. Dopo tutta questa serie di correzioni ed accorgimenti, mantengo la temperatura della Radeon intorno ai 45°C mentre sto lavorando (carico basso, direi) ed intorno ai 60°C mentre gioco (picco di 62°C). Considerando che la temperatura massima gestita dalla Radeon 6870 è di circa 100°C (temperatura oltre la quale si blocca e va in protezione), direi che sono ampiamente dentro i valori di esercizio standard. Grazie a Open Hardware Monitor, tengo d’occhio la temperatura e soprattutto la velocità della ventola, che accelera al crescere della temperatura, ma rimane sempre nel range di 1000-1400 RPM, molto al di sotto del regime massimo.

Bene, quindi, posso ritenermi soddisfatto, e posso tranquillamente discolpare l’alimentatore, che inizialmente avevo accusato di essersi fuso nel giro di qualche ora di lavoro!