[Google – doodle] Iniziano i veri mondiali di calcio !!!

Sarà di nuovo: «Poo po-ro po-po-po pooo… Poo po-ro po-po-po pooo…!!!»In occasione dell’inizio dell’ottavo Campionato Mondiale di Calcio femminile 2019, che quest’anno si svolgerà in Francia dal 7 giugno al 7 luglio, Google ha predisposto un bellissimo doodle in sostituzione del solito logo nella sua pagina principale raffigurante diverse giocatrici di nazionalità diverse in azione.

Dopo 20 anni le azzurre tornano nella massima competizione iridata giocandosi il passaggio del turno nel Gruppo C contro Australia, Giamaica e Brasile.

Dopo la delusione dell’anno scorso di essere costretti a guardare i Mondiali di Calcio senza una maglia azzurra per cui tifare, finalmente quest’anno sarà l’occasione per rifarci visto che la rassegna sarà trasmessa in chiaro dai canali Rai e a pagamento su Sky.

Calendario dell’Italia

9 giugno 2019, ore 13:00 Australia – Italia allo Stade du Hainaut a Valenciennes
14 giugno 2019, ore 18:00 Italia – Giamaica allo Stadio Auguste Delaune a Reims
18 giugno 2019, ore 21:00 Italia – Brasile allo Stade du Hainaut a Valenciennes

 

[Google – doodle] Buon compleanno WWW

Giusto oggi trent’anni fa nasceva il WWW. Nato dalla mente geniale di Tim Berners-Lee che lavorava presso il CERN di Ginevra, il World Wide Web (o più comunemente “il Web“) e quella cosa che dal 1989 (il documento ufficiale in cui si parlava di un “ampio database intertestuale con link” è stato redatto proprio il 12 marzo) sfrutta la rete internet tramite una serie di pagine collegate tra loro tramite link ipertestuali.

Oggi ‘navigare’ tra i siti è cosa data quasi per scontata, ma come ci ricorda il doodle di Google è un invenzione che 30 anni fa ha cambiato il mondo. Agli inizi è stata una rivoluzione per addetti ai lavori, ma dopo qualche anno (cavolo, io c’ero) nascevano i primi browser (Mosaic e poi Netscape), con i quali pure noi poveri mortali potevamo visitare le pagine web partendo da portali come Altavista, WebCrawler, Lycos (dove i link dei siti erano raggruppati in elenchi tematici), altro che la ricerca di Google o il web semantico.

La prima pagina che ho visitato è stata proprio quella del CERN, che emozione!!! (e quanta pazienza visto che al tempo usavo un modem a 9600 baud, ovvero  960 bytes/s, diciamo un migliaio di volte più lento di un’odierna scrausa ADSL a 8Mb/s), impensabile allora mettersi davanti alla tv e guardare un film in alta definizione via internet, ah ah ah!

 

[Python] Traduttore automatico di sottotitoli

La mia smodata passione per le serie tv made in USA mi ha iniziato al binge watching molto prima che ne venisse coniato il termine per diventare una moda. Ricordo ancora il week end di una decina di anni fa, passato a ‘recuperare’ su internet gli episodi delle prime tre stagioni di «Battlestar Galactica» poco prima della trasmissione in America della quarta stagione. Di lì ho scoperto che non mi piaceva attendere qualche anno prima di poter guardare una serie tv che mi interessava e che internet da questo punto di vista era una notevole risorsa se si era disposti ad abituare l’occhio a non perdersi nessuna scena sbirciando contemporaneamente i sottotitoli sullo schermo (ancora tante grazie Italiansubs!).


Ora che i sottotitoli in italiano si fa più fatica a trovarli, un po’ per gioco e un po’ per utilità, ho pensato di creare uno script in Python che traduce un file di sottotitoli in inglese nel corrispettivo in italiano utilizzando la libreria googletrans (link) che sfrutta l’API di Google Translate. Il risultato non sarà dei più corretti ma IMHO abbastanza accettabile per godersi un episodio della propria serie tv preferita.


Ingredienti:

    • python 3
    • libreria googletrans (per la traduzione)
    • librerie sys, os (per la gestione dei file)
    • libreria timeit (per computare le prestazioni)

Per installare la libreria avendo a disposizione l’utility PIP è sufficiente digitare il seguente comando:

pip install googletrans

Analizziamo le parti principali del sorgente:

Innanzitutto importiamo le librerie che ci necessitano:

import sys, os
from googletrans import Translator
from timeit import default_timer as timer

Memorizziamo in una variabile il tempo iniziale che ci servirà per calcolare successivamente le prestazioni dello script:

start = timer()

E inizializziamo il traduttore sull’API pubblica di Google Translate:

translator = Translator(service_urls=[
      'translate.google.com',
      'translate.google.it',
    ])

Il progetto prevede di dare in pasto al traduttore le frasi contenute in un file in formato .srt contenente i sottotitoli in inglese, strutturalmente fatto in questo modo:

Per quanto riguarda il nome del file da tradurre lo passeremo come argomento nell’istruzione di esecuzione del programma. Il nome del file prodotto con i sottotitoli tradotti in italiano sarà generato conseguentemente aggiungendo il suffisso “_tradotto”. Viene anche controllata l’esistenza di un eventuale precedente file di traduzione avente lo stesso nome di quello in produzione e nel caso verrà cancellato.

try:
sourcefile = sys.argv[1]
resultfile = sys.argv[1].replace('.srt', '')+'_tradotto.srt'
except:
sourcefile = "sottotitolo.srt"
resultfile = sourcefile.replace('.srt', '')+'_tradotto.srt'

if os.path.isfile(resultfile) == True:
os.remove(resultfile)

Nessun problema ad aprire il file in questione e scomporre le righe di testo in elementi di una lista. Inoltre già che ci siamo cancelliamo gli eventuali inutili spazi vuoti in testa e in coda a ciascuna riga con il metodo strip():

with open(sourcefile) as f:
    content = f.readlines()
content = [x.strip() for x in content]

Ovviamente al nostro traduttore dovremo passare ‘solo’ i testi e non gli altri elementi utili alla renderizzazione a video dei sottotitoli. Inoltre al traduttore dobbiamo passare delle frasi intere, anche se nel file dovessero risultare ‘spezzate’ su più righe.

Processiamo ciascuna riga della lista creata e scartiamo quelle righe (senza eliminarle perché ci occorreranno poi per scrivere correttamente il file .srt dei sottotitoli tradotti) contenenti un numero intero (cioè il numero del sottotitolo) piuttosto che la durata del sottotitolo (che Python vede comunque come una stringa di testo da qui la trovata di pulire la riga dal segno di separazione (“:”) e di considerarne solo i primi 5 caratteri, in modo che ad esempio la riga “00:00:03,886 –> 00:00:07,961” venga computata come “00000” che Python riconosce giustamente come numero e quindi ce la fa scartare:

for item in content:
    count += 1
    if item.isdigit() == False:
        try:
            control = item.replace(":","")
            part = control[0:4].isdigit()
        except:
            part = False

Per risolvere il problema delle frasi spezzate su più righe come abbiamo ad esempio in questo caso:

Dove per ottenere una traduzione corretta occorre passare al traduttore una corretta frase interaBut you won’t fix the real problem” e non due righe separate come si presentano nel file. Si andrà quindi a tradurre quanto memorizzato in una lista ‘volatile’ solo dopo aver incontrato un salto di riga vuoto come questo:

Di seguito la mia soluzione che memorizza il testo da tradurre nella stringa “datradurre” che viene passata al traduttore istanziando l’oggetto translations da cui ricaviamo il testo tradotto quando la variabile trigger ‘accio’ processa una riga vuota. Ovviamente occorre tenere conto che sebbene al traduttore la frase di due righe verrà fornita in una riga sola, al momento della ricostruzione del sottotitolo tradotto la frase dovrà essere nuovamente divisa se troppo lunga per non perdere in leggibilità del sottotitolo: la frase sarà ‘spezzata in due righe dovesse essere composta da più di 5 parole e comunque da più di 40 caratteri (esclusi i segni ‘speciali di renderizzazione). Dopo aver passato la stringa al traduttore questa viene azzerata, pronta per le righe successive. Il tutto viene memorizzato in una lista denominata ‘traduzione’ a cui si aggiungeranno man mano tutte le righe processate, comprendenti il numero del sottotitolo, i tempi di inizio e fine visualizzazione e la traduzione ottenuta (o il testo originale se il programma non è riuscito a tradurre).

       if part != True:
            datradurre = datradurre +' '+item
            datrad_non.append(datradurre)
            accio = ("_______"+str(item)+"________________>")
            if accio == "_______________________>":
                try:
                    translations = translator.translate(datradurre, src='en', dest='it')
                    trad = translations.text
                    parole = 0
                    a = trad.split(" ")
                    for i in a:
                        if (i!=" " and i!="<i>" and i!="</" and i!="i>" and i!="-" and i!="..."):
                            parole=parole+1
                    if parole >5 and len(trad) >40:
                        frase = range(6,parole)
                        primariga = str(a[0])+' '+str(a[1])+' '+str(a[2])+' '+str(a[3])+' '+str(a[4])+' '+str(a[5])
                        secondariga = ''
                        for x in frase:
                            secondariga = secondariga+' '+str(a[x])
                        traduzione.append(primariga)
                        traduzione.append(secondariga[1:])
                        traduzione.append(item)
                        TRcount += 1
                    else:
                        traduzione.append(trad)
                        traduzione.append(item)
                        TRcount += 1
                except:
                    for x in datrad_non:
                        traduzione.append(x)
                    traduzione.append(item)
                    NOcount += 1
                datradurre = ""
                datrad_non.clear()
        else:
            traduzione.append(item)

Dopo aver processato tutte le righe si può procedere a generare scrivendo riga per riga il file .srt con i sottotitoli tradotti:

with open(resultfile, 'a') as f:
    for item in traduzione:
        f.write(item+'\n')

Possiamo calcolare a questo punto il tempo di esecuzione in secondi del programma:

end = timer()
tempo = "{0:.2f}".format((end - start))

E infine visualizzare le statistiche raccolte con i vari contatori alimentati durante il processo di traduzione:

print('\n')
print ('Totale righe _________ '+str(count))
print ('Totale traduzioni ____ '+str(TRcount))
print ('Problemi traduzioni __ '+str(NOcount))
print ('Totale tempo _________ '+tempo+'s')
print('\n')

Non sarà lo script meglio scritto, ma in un tempo ragionevole (circa 300 secondi per processare un episodio di tre quarti d’ora) riesce a sfornare dei sottotitoli in italiano discretamente accettabili.

Codice sorgente completo disponibile su GITHUB (link).

CITTADINO IMPERFETTO: I migliori articoli del 2018

Come ormai tradizione pubblichiamo una rassegna dei post più gettonati dell’anno appena trascorso.


Titolo Post   Views 2018

  1. Il router wifi va spento durante la notte?

 

7.4k

  2. Problema “Memoria quasi piena” su Samsung Galaxy

 

6.7k

  3. Utilizzare HyperTerminal in WINDOWS 7

 

6.2k

  4. Come vedere la televisione con VLC e una chiavetta USB DVB-T

 

 5.4k

  5. Come fare in casa la Ginger beer

 

 4.2k

  6. [Risolto] Aiuto!!! Non riesco a disinstallare Microsoft Office

 

  4.1k

  7. [RISOLTO] Come trovare l’ICCID della SIM in Windows Mobile 10

 

 4.0k

  8. Testare e riparare le chiavette USB con Check Flash 1.08

 

 3.5k

  9. [Risolto] Installazione Windows 7: “codice errore: 0x80070017”

 

  2.6k

10. Testare e riparare le chiavette USB con Check Flash 1.10

 

  2.5k


Un ringraziamento per averci seguito così numerosi.
Da parte nostra ce la metteremo sempre tutta per postare articoli interessanti.

Buon 2019!!!


Link migliori articoli 2017
Link migliori articoli 2016
Link migliori articoli 2015
Link migliori articoli 2014
Link migliori articoli 2013
Link migliori articoli 2012
Link migliori articoli 2011
Link migliori articoli 2010
Link migliori articoli 2009

[ SPOT ] «Mamma ho perso l’aereo» al tempo di Google Assistant

Sono passati quasi trent’anni da quando una mia versione più mocciolosa rimase a bocca aperta di fronte alle imprese del piccolo Kevin McCallister lasciato erroneamente da solo a casa durante le festività natalizie a fronteggiare con il suo ingegno da bambino i ladri cattivi.

Un film divenuto quasi da subito un cult del genere, che fortunatamente la televisione ripropone ogni anno a cavallo di Natale e Capodanno alla stregua di “Una poltrona per due” senza il quale al Natale mancherebbe qualcosa tipo la scintillante punta dell’albero addobbato e/o il calore del bue nel presepe.

I ragazzi di MountView hanno ben pensato di sdoganare il loro Google Assistant al grande pubblico riproponendo alcune scene iconiche del film Mamma ho perso l’aereo interpretate da un più maturo Macaulay Culkin che oggi ha a disposizione le moderne tecnologie per fronteggiare i cattivi senza fare molta fatica. 

In questo caso la pubblicità è così ben fatta e ben pensata da far dimenticare per un attimo di essere spettatori dell’ennesimo strumento di marketing e di godere di essere trasportati per qualche secondo nei ricordi della nostra magica infanzia.

Comunque in concomitanza di questa campagna pubblicitaria e quindi per un tempo limitato (e presumibilmente solo per il mercato anglofono), Google Assistant risponderà così ai seguenti comandi vocali:

  • “Did I forget something?” – farà esclamare al dispositivo il celebre “KEVIN!!!!”
  • “How much do I owe You?” o “It’s me Snakes. I got the Stuff” – farà ricreare il dialogo del film che guarda Kevin, creato appositamente per il film, “Angels with filthy souls”
  • “The Wet Bandits are here” – farà sentire cosa farebbe Kevin in uno dei momenti più iconici del film
  • “I’m the man of the house” – farà rivivere la scena in cui Kevin si mette il dopobarba

 

[Tutorial domotica] Sonoff + Python = punto luce intelligente

La possibilità di incrementare le prestazioni dell’interruttore wifi economico Sonoff della iTead grazie al firmware della Tasmota che, tra l’altro, lo svincolano dall’uso tramite App proprietaria, mi ha fatto venire l’idea di far accendere al Raspberry Pi nella mia stanza un punto luce in maniera automatica e magari intelligente (è la domotica baby!)

  • Livello di difficoltà: medio/basso
  • Costoestremamente ridotto (~10 €)

Ingredienti:

  • Sonoff Basic (acquistabile su Amazon.it)
  • saldatore e cavetti prototipazione
  • conoscenza di Python
  • spina elettrica maschio
  • spina elettrica femmina
  • filo elettrico bipolare q.b.
  • server controllo (es. Raspberry Pi)

Procedimento:

  • Innanzitutto occorre programmare il Sonoff con il firmware Tasmota. Per farlo ci sono diversi metodi, tutti magnificamente descritti nella relativa Wiki. Per conto mio non ho avuto fortuna con l’installazione via OTA: il mio interruttore montava un firmware di fabbrica troppo recente, risultato incompatibile con questa modalità di upload. Scartato il metodo via adattatore USB/TTL (che non trovo più nel cassetto e per il quale avevo trovato quest’ottima guida in italiano) mi sono arrangiato via Arduino Uno (e un saldatore) che ho sfruttato per trasferire il nuovo firmware dal PC al Sonoff, seguendo questa chiarissima guida in italiano. Cmq in caso si può fare affidamento sulla community di smanettoni che potete trovare in questo Forum o in questo canale Discord. Infine per chi proprio non se la sente, consiglio di farsi un giro su Ebay e di acquistare un dispositivo già pronto e funzionante con firmware Tasmota pre-installato.
  • Collegamenti elettrici. Ho utilizzato un cavo bipolare tipo H03VVH2 2×0,75mm, una spina elettrica maschio per il collegamento alla rete elettrica e una spina elettrica femmina per il collegamento al punto luce. Ovviamente la lunghezza dei cavi deve essere predisposta secondo necessità.
    ATTENZIONE CON LA CORRENTE 220V NON SI SCHERZA!!!
  • Il software di controllo. Il firmware Tasmota consente già di programmare (tramite la funzione timer) l’orario di accensione e di spegnimento del carico collegato all’interruttore, ma io voglio qualcosa di più intelligente.
    Voglio che il punto luce si accenda in mia presenza e al verificarsi di precise condizioni. Quindi ho creato uno script in Python (che ho chiamato myTwilight) che gira avviato via crontab sul Raspberry Pi. Lo script completo è disponibile sulla mia pagina Github e fa le seguenti cose:


    • Controlla che il Sonoff sia effettivamente operativo:

      • def pingSonoff(): ##Test ping SonOff
            var = os.popen("ping sonoff -c 1").read()
            l = var.index('received')
            l = l-2
            if var[l] == '1':
                return 'ON'
            else:
                return 'OFF'
        

      Ho assegnato l’hostname ‘sonoff’ al mio interruttore così da non essere costretto, per contattarlo, a ricordare il suo indirizzo IP.


    • Controlla via API l’ora del crepuscolo del giorno preciso (calcolata sulle coordinate geografiche della mia stanza);

      • def tramonto(lat, lng): ##Orario calcolato secondo GMT (senza ora legale/ora solare)
            request = requests.get("http://api.sunrise-sunset.org/json?lat="+lat+"&lng="+lng+"&formatted=0")
            return datetime.strptime(str(request.json()['results']['sunset'][11:16]), '%H:%M')
        

      Le coordinate geografiche della stanza le ho ottenute facilmente via Google Maps,  e la richiesta all’API del sito “sunrise-sunset.org” è gratuito e molto semplice da utilizzare, purtroppo il valore orario restituito è calcolato sull’ora GMT. Ho quindi dovuto calcolare l’offset dell’ora legale con una richiesta ad un’altra API di “worldtimeapi.org”:

      • def oralegale(): ##controllo ora legale
            request = requests.get("http://worldtimeapi.org/api/timezone/Europe/Rome")
            utc_offset = str(request.json()['utc_offset'])
            return int(utc_offset[2])
        

      E quindi l’ora del tramonto risulta essere così determinata (richiamando le suddette funzioni):

      • tramonto = tramonto(lat, lng)
        ora_tramonto = str(int(str(tramonto)[11:13])+oralegale())+':'+str(tramonto)[14:16]
        

    • Controlla la situazione meteo (indice copertura delle nuvole e quindi situazione luminosa);

      • def clima(lat, lng, api_key):
            url = "https://api.darksky.net/forecast/"+api_key+"/"+lat+","+lng+"?units=si&lang=it&exclude=daily,hourly,alerts,minutely"
            request = requests.get(url)
            print "Situazione clima: " + request.json()['currently']['summary']
            cloud = request.json()['currently']['cloudCover'] # controllo indice copertura cielo (da 0 a 1, da sereno a molto coperto)
            if  cloud > 0.50:
                if cloud > 0.75: 
                    return -600 # molto coperto
                else:
                    return -300 # coperto
            else:
                if cloud < 0.25:
                    return 0    # sereno
                else:
                    return 750  # molto sereno
        

      La suddetta funzione si è resa necessaria perché voglio che il punto luce si accenda anticipando l’ora del tramonto di qualche minuto nel caso il cielo risulti essere particolarmente coperto e quindi la stanza sia particolarmente buia, piuttosto che rimandare l’accensione di qualche minuto in caso di cielo sereno. Il sito “darksky.net” mette a disposizione via API (gratuitamente fino al limite di 1000 richieste giornaliere) diversi parametri meteorologici calcolati sulla base delle coordinate geografiche tra le quali l’indice ‘cloudCover’ che da 0 a 1 mostra lo statodella nuvolosità del cielo.


    • Controlla se sono presente nella stanza (quindi controlla se almeno uno dei due pc che solitamente utilizzo risultano accesi);

      • def ping(): ##Check presenza (attraverso ping PC e Laptop)
            var1 = os.popen("ping 192.168.1.124 -c 1").read()
            l1 = var1.index('received')
            l1 = l1-2
            if var1[l1] == '1':
                stato1 = 'OK'
            else:
                stato1 = 'NO'	
            var2 = os.popen("ping 192.168.1.111 -c 1").read()
            l2 = var2.index('received')
            l2 = l2-2
            if var2[l2] == '1':
                stato2 = 'OK'
            else:
                stato2 = 'NO'	
            if stato1 == 'OK' or stato2 == 'OK':
                return 'OK'
            else:
                return 'NO'
        

      Anche in questo caso utilizzo il ping per verificare se uno dei due PC che di solito utilizzo risultano accesi, determinando così l’effettiva mia presenza in stanza.


    • La funzione ‘main’ controlla se tutte le condizioni sono soddisfatte:

      • def main(ora, delay):
            diff = int((max(ora) - min(ora)).total_seconds())
            if ora[1] > ora[0] and diff >= delay:
                if pingSonoff() == 'ON':
                    if ping() == 'OK':
                        print 'Accendo Sonoff'
                        powerOn()
                    else:
                        print 'Sole tramontato, ma non rilevo presenza attiva...'
                else:
                    print 'Sole tramontato, ma Sonoff non operativo...'
            else:
                print 'Ancora troppo presto...'
        

      Ovviamente nel caso in cui non sussistano le condizioni il programma prosegue con questo loop:

      • while count <24:
            print str(count)+' - Check: '+strftime("%d-%m-%Y %H:%M:%S", localtime())
            adesso = datetime.strptime(strftime("%H:%M", gmtime()), '%H:%M')
            ora = [tramonto,adesso]
            delay = clima(lat, lng)
            main(ora, delay)
            print '\n'
            count += 1
            time.sleep(750) #loop ogni 15'
        

      Il programma procede quindi per un numero massimo di 24 volte, a distanza di 15 minuti, a controllare le condizioni impostate. Facendo partire il programma alle 16:00 il numero di loop è sufficiente per coprire i possibili scenari.


    • … e nel caso accende il punto luce eccitando il relé del Sonoff:

      •  
        def powerOn(): ##attivazione Sonoff
            r = requests.get("http://sonoff/cm?cmnd=Power%20ON")
            print(r.content)
            sys.exit()
        
    • Una volta provveduto ad accendere il punto luce lo script Python ha terminato la sua funzione quindi viene terminato.

Considerazioni finali:

  • Con poca spesa e un po’ di ingegno ho centrato il mio obiettivo: avere un interruttore intelligente in grado di accendere un punto luce al verificarsi di determinate condizioni (presenza, orario e luminosità).
  • Una peculiarità del Sonoff Basic è quella di consumare veramente poco (circa 0,70-0,80W o qualcosina in più quando il relè è eccitato), inoltre è possibile ridurne ‘sensibilmente’ i consumi impostando il valore Sleep del firmware Tasmota da 50 a 200 espresso in millisecondi. Inoltre ho spento le funzionalità MQTT che di fatto non utilizzo (tramite il comando PowerRetain)..
  • Sempre via console ho disattivato l’accensione del led presente sul Sonoff (comando LedPower e LedState) che quindi ora lampeggia brevemente solo al momento in cui si connette alla rete elettrica segnalando la ricerca della connessione Wifi.
  • La presenza del bottoncino sulla parte alta della copertura di plastica del Sonoff mi consente di accendere e di spegnere manualmente il punto luce.
  • Una prossima versione del programma di controllo, a cui sto già pensando, prevede di modificare il rilevamento di presenza integrando funzionalità via bluetooth (in questo caso andrei a rilevare o meno la connessione con il mio smartphone).
  • Ho già pensato/realizzato un’integrazione con il client Telegram che è già in esecuzione sul mio Raspberry Pi così da ricevere comunicazioni sul funzionamento del Sonoff.
  • Lo script Python completo è disponibile sulla mia pagina Github insieme agli altri progetti.
  • Ho già ordinato un Sonoff Dual (quindi in grado di comandare due uscite) da collegare alla tapparella motorizzata che si abbasserà e si alzerà a seconda delle condizioni da me impostate…

[Google – doodle ] 20 anni insieme…

googles-new-logo-5078286822539264.2-hp

Sono abbastanza vecchio da ricordare il mondo prima dell’avvento di Google.

Il cellulare ce l’aveva solo il capo che nessuno invidiava per quell’aggeggio che lo rendeva reperibile H24, le serie tv arrivavano in Italia minimo un paio di anni dopo rispetto al resto del mondo, ma nessuno lo sapeva e quindi non si lamentava nessuno, se ti serviva qualcosa lo cercavi sulle pagine gialle che arrivavano ogni anno già sgualcite insieme all’elenco telefonico… e internet non lo conosceva nessuno.

Avere il PC a casa (almeno in Italia) era un hobby per pochi. Se dovevi scrivere una lettera o un documento (ufficiale)  tutt’al più usavi la vecchia Lettera32, il PC non lo avevi nemmeno in ufficio che al massimo c’erano terminali con enormi monitor (con schermo minuscolo massimo 14′) a fosfori verdi che ti facevano diventare cieco dopo una settimana d’utilizzo. I floppy per memorizzare i dati non contenevano quasi niente, erano da 5 pollici che quelli da 3,5 erano troppo piccoli e si perdevano nei cassetti. Le email sconosciute, si faceva tutto con il modernissimo fax e il massimo della messaggistica ‘istantanea’ erano gli SMS che arrivavano a destinazione in un lasso di tempo variabile dai pochi minuti agli eoni.

Se dovevi cercare un sito con il fidato browser Netscape sulle onde del modem 14.4 baud che occupava la linea telefonica di casa, eri fortunato se te lo passava un amico, lo avevi letto su una rivista, su una BBS o su uno di quei portali che censivano i siti per macro categoria d’interesse.

Poi è arrivata questo sito con una pagina quasi totalmente bianca con uno strano logo colorato, una casella per scrivere i termini della ricerca e due pulsanti grigiolini: uno con scritto ‘cerca’ e l’altro con la scritta ‘mi sento fortunato’ che non premevi mai.

Il mondo è cambiato e internet è cambiato. Tanti auguri Google.

 

%d blogger hanno fatto clic su Mi Piace per questo: