Ironia della sorte

Qualche giorno fa Consumer Reports, la principale organizzazione nord-americana di consumatori, ha annunciato di non poter raccomandare l’acquisto dell’ultimo modello di MacBook Pro perché non produceva risultati consistenti nei test di misura dell’autonomia della batteria. Nei tre modelli provati la batteria sembrava avere una durata semi-casuale, che poteva andare da poco meno di 4 ore fino ad oltre 19 ore.

Non voglio entrare nel merito dei test effettuati da Consumer Reports (o dalla nostra Altroconsumo), che a volte sono semplicemente ridicoli.

Ma in questo caso specifico la cosa sembrava avere un fondamento reale, non a caso Apple si è data immediatamente da fare per cercare di scoprire la causa del problema.

E cosa è venuto fuori? Che per fortuna il problema non ha una origine hardware ma è legato ad un baco di Safari quando nel browser si attiva la modalità Sviluppatore (Developer Mode), usata da Consumer Reports nei suoi test.

Consumer Reports, infatti, misura la durata delle batterie dei portatili accedendo ripetutamente ad una serie di 10 pagine web predefinite e facendo in modo che le pagine vengano scaricate ogni volta dal sito web e non dalla cache del browser. Con Safari, il browser di default dei Mac, l’unico modo per non utilizzare la cache è proprio quello di attivare la modalità Sviluppatore, che non serve agli utenti normali ma che è invece indispensabile per chi sviluppa siti e applicazioni per il web.

È chiaro che Apple correggerà facilmente il baco nella prossima release di Safari.

Ma è altrettanto chiaro che quanto è successo — vera ironia della sorte o forse contrappasso dantesco — dimostra ulteriormente che il MacBook Pro 2016 non è proprio un modello adatto agli sviluppatori, uno dei target naturali della linea di notebook professionali di Apple.

Speriamo che nel 2017 Apple rinsavisca e riesca a mettere alla luce dei nuovi modelli di Mac degni della sua lunga storia e dell’ottimo sistema operativo che ci gira sopra.

Tagged with: , , ,
Pubblicato su hardware

Dieci anni di iPhone

Non mi piacciono particolarmente le celebrazioni, ma per oggi faccio una eccezione doverosa. Perché il 9 gennaio di dieci anni fa Steve Jobs presentò il primo iPhone, il telefono che avrebbe reinventato il concetto stesso di telefono intelligente, rendendo finalmente praticabile portare con sé un vero e proprio computer con cui essere sempre connessi con il resto del mondo.

L’iPhone non venne fuori dal nulla, lo avevano preceduto i vari Communicator di Nokia e l’accoppiata Treo 600 e Treo 650 di Palm/Handspring, senza dimenticare i vari PDA Palm o gli Psion Revo e 5/5mx, computer palmari senza funzioni telefoniche che hanno però reso popolare l’idea del computer da portare in tasca.

Con l’iPhone Apple non ha inventato il telefono intelligente, ma lo ha reso realmente utilizzabile da chiunque e ovunque, affermando l’idea che si potesse interagire con il telefono solo con le dita, senza intermediazioni fisiche come la tastiera o lo stilo, che facevano a pugni con le dimensioni limitate dell’apparecchio.

Io ho usato per parecchi anni con molta soddisfazione sia i Treo che un Communicator,1 ma quando ho avuto a che fare (in treno e purtroppo solo per pochi minuti) con uno dei primissimi iPhone arrivati in Italia, mi sono accorto che era un vero e proprio game changer.

Il primo iPhone aveva però un grosso difetto: le applicazioni di terze parti potevano essere solo applicazioni web, quelle che oggi vengono dette applicazioni HTML5, una cosa che era troppo avanti per i tempi e che venne duramente criticata anche da personaggi del calibro di John Gruber.

“Se le web app che girano dentro Safari sono un ottimo mezzo per scrivere applicazioni per l’iPhone, perché le web app che girano dentro Safari non sono un ottimo mezzo per scrivere applicazioni per il Mac?… Non c’è dubbio che ci saranno delle fantastiche web app per l’iPhone. Ma ci sono tonnellate di grandi idee per il software dell’Phone che non possono [semplicemente] essere realizzate nella forma di web app.” — John Gruber

Apple ebbe il coraggio di correggere la rotta, introducendo pochi mesi dopo la possibilità di installare applicazioni (o meglio app, come siamo ormai abituati a chiamarle) che giravano nativamente sull’iPhone e con le quali si potevano adattare le funzioni del telefono alle necessità e agli stili di vita di ciascuno.

Ma il vero colpo di genio fu quello di mettere a disposizione un vero e proprio negozio virtuale da cui scaricare e installare con facilità tutte le app disponibili per l’iPhone. Una vera benedizione per chi ha usato gli smartphone precedenti, che costringevano a vagare per decine di siti diversi — spesso rapidamente evanescenti — in cerca dell’applicazione giusta o ad affrontare procedure bizantine e sempre diverse di installazione.

Per non parlare dei costi: prima dell’iPhone una applicazione per smartphone costava cifre da capogiro, anche svariate decine di dollari per cosucce tutto sommato limitate. Con l’iPhone i costi delle app si sono abbassati enormemente, perché l’enorme diffusione dello smartphone di Apple consentiva agli sviluppatori di aumentare a dismisura la base potenziale di installazione del proprio software.2

Ma realizzare l’iPhone non è stato affatto facile: dieci anni fa i telefoni avevano dimensioni decisamente inferiori a quelle odierne e gli ingegneri Apple hanno dovuto affrontare delle sfide tecniche enormi per riuscire a ficcare tutto l’hardware necessario nello spazio limitato a disposizione.

Il prototipo presentato il 9 gennaio di dieci anni fa nel corso del Macworld 2007 funzionava a malapena e si bloccava di continuo. Se fosse successo nel corso della presentazione sarebbe stato un fiasco inaudito. Invece — un po’ per fortuna ma tanto per la cura maniacale di Steve Jobs e dei suoi collaboratori verso i più piccoli dettagli — tutto è andato per il meglio e ha cambiato la storia della tecnologia.

La storia dello sviluppo dell’iPhone è stata raccontata qualche anno fa da Fred Vogelstein sul New York Times. Per chi non è troppo pratico dell’inglese ne esiste anche una sintesi in italiano, purtroppo molto meno godibile dell’originale.

Una lettura imperdibile per chi voglia capire come funziona, visto da dentro, lo sviluppo di un nuovo prodotto.


  1. Li ho ancora nella mia piccola collezione personale di hardware retro
  2. L’enorme successo dell’App Store sta creando oggi gravi problemi di visibilità per i piccoli sviluppatori indipendenti, ma questo è un altro discorso. 
Tagged with: , , , , ,
Pubblicato su hardware

FTP con caffé e cornetto

Schermata di apertura di Yummy FTP Pro

Ha senso oggi trasferire file tramite FTP (l’acronimo sta per File Trasfer Protocol)?

Il protocollo FTP è stato ideato nei primi anni ’70, agli albori di internet, quando solo pochissimi ricercatori usavano la rete e i problemi di sicurezza erano sconosciuti. Riuscire a trasferire file in modo efficiente ed affidabile da un punto all’altro della rete era un’esigenza fondamentale, in un’epoca di collegamenti lenti ed effettuati per lo più tramite la rete telefonica. Se questo comportava dover trasmettere i propri dati in chiaro attraverso la rete, pazienza, al massimo significava (allora!) dover subire qualche scherzo più o meno divertente.

Oggi FTP è sempre meno usato, anche nella versione più sicura SFTP basata su ssh (Secure SHell). Ormai il protocollo è integrato nei browser web (provate ad esempio questo link, ftp://ftp.debian.org/debian/), mentre i servizi cloud hanno reso sempre inutile mettere su un server FTP per condividere grossi file con colleghi ed amici (un vecchio classico: mettere a disposizione le foto di qualche manifestazione o festa).

Ma ci sono casi in cui può ancora servire, in particolare se vogliamo trasferire file di grosse dimensioni, meglio ancora intere directory, oppure se sviluppiamo siti e applicazioni web e vogliamo poter sincronizzare facilmente le modifiche effettuate sul nostro computer con un server remoto.

Sia FTP che SFTP sono presenti in tutti i sistemi Unix come applicazioni da riga di comando. Il Mac non fa eccezione: i programmi ftp e sftp sono installati di default in macOS/OS X e possono essere usati dal Terminale.

Ma anche un appassionato del Terminale come me si rende conto che per gestire i file un’interfaccia grafica è in tanti casi molto più comoda di una a riga di comando.

Per fortuna sul Mac i programmi grafici per FTP/SFTP non mancano di certo e tanti implementano anche protocolli meno diffusi ma altrettanto utili come rsync, per mantenere sincronizzati singoli file e intere directory su due o più computer senza dover usare un servizio cloud, o WebDAV, che permette di modificare file remoti tramite il comune protocollo http utilizzato dai browser web.

Negli anni ne ho usati parecchi, sia i pesi massimi commerciali ForkLift e Transmit che l’open source CyberDuck, che per tanto tempo è stato il mio preferito e che poteva essere usato anche dal Terminale. Ho provato brevemente Flow e pure RBrowser e Fetch, i cui siti web hanno ormai un aspetto vintage, ma ormai da tempo uso solo Yummy FTP Pro, che secondo me ha il miglior equilibrio fra potenza e facilità d’uso.

Schermata di apertura di Yummy FTP Pro

Il pannello di configurazione può mettere in soggezione, ma le opzioni di default sono scelte con molta cura ed in genere non è necessario modificarle. Dopo anni di uso credo di aver cambiato solo la directory su cui salvare i file trasferiti. Allo stesso tempo, il fatto di poter configurare il programma in modo così dettagliato può permettere di risolvere i casi più difficili senza penare troppo.

Pannello di configurazione di Yummy FTP Pro

Comodissima è anche la possibilità di salvare i bookmark dei server a cui si accede più spesso, con tutte le opzioni di connessione relative, e di sincronizzarli fra tutti i Mac tramite Dropbox, iCloud Drive o Google Drive.

In questi giorni Yummi FTP Pro ha un prezzo imbattibile sull’App Store, costa praticamente quanto un caffé e cornetto. Fatevi un favore e non fatevelo sfuggire. Anche se non usate spesso FTP/SFTP, a questo prezzo è una applicazione che non può mancare sul vostro Mac.

Tagged with: , , , , , , , ,
Pubblicato su software

Auguri dal Terminale


  ########    ###    ##    ## ######## ####       ###    ##     ##  ######   ##     ## ########  ####  
     ##      ## ##   ###   ##    ##     ##       ## ##   ##     ## ##    ##  ##     ## ##     ##  ##   
     ##     ##   ##  ####  ##    ##     ##      ##   ##  ##     ## ##        ##     ## ##     ##  ##   
     ##    ##     ## ## ## ##    ##     ##     ##     ## ##     ## ##   #### ##     ## ########   ##   
     ##    ######### ##  ####    ##     ##     ######### ##     ## ##    ##  ##     ## ##   ##    ##   
     ##    ##     ## ##   ###    ##     ##     ##     ## ##     ## ##    ##  ##     ## ##    ##   ##   
     ##    ##     ## ##    ##    ##    ####    ##     ##  #######   ######    #######  ##     ## ####  
  
  ########  ######## ########     ##     ## ##    ##  #######   
  ##     ## ##       ##     ##    ##     ## ###   ## ##     ##  
  ##     ## ##       ##     ##    ##     ## ####  ## ##     ##  
  ########  ######   ########     ##     ## ## ## ## ##     ##  
  ##        ##       ##   ##      ##     ## ##  #### ##     ##  
  ##        ##       ##    ##     ##     ## ##   ### ##     ##  
  ##        ######## ##     ##     #######  ##    ##  #######   
  
   ######  ########  ##       ######## ##    ## ########  #### ########   #######   
  ##    ## ##     ## ##       ##       ###   ## ##     ##  ##  ##     ## ##     ##  
  ##       ##     ## ##       ##       ####  ## ##     ##  ##  ##     ## ##     ##  
   ######  ########  ##       ######   ## ## ## ##     ##  ##  ##     ## ##     ##  
        ## ##        ##       ##       ##  #### ##     ##  ##  ##     ## ##     ##  
  ##    ## ##        ##       ##       ##   ### ##     ##  ##  ##     ## ##     ##  
   ######  ##        ######## ######## ##    ## ########  #### ########   #######   
  
  ##    ##    ###    ########    ###    ##       ######## ####  
  ###   ##   ## ##      ##      ## ##   ##       ##       ####  
  ####  ##  ##   ##     ##     ##   ##  ##       ##       ####  
  ## ## ## ##     ##    ##    ##     ## ##       ######    ##   
  ##  #### #########    ##    ######### ##       ##             
  ##   ### ##     ##    ##    ##     ## ##       ##       ####  
  ##    ## ##     ##    ##    ##     ## ######## ######## ####  

Tagged with: ,
Pubblicato su tecnologia

Compleanno con permessi

Configurazione di bash

Oggi melabit compie tre anni. Per l’occasione ho chiesto all’amico Lux il permesso di ripubblicare un mio vecchio intervento sul suo (bellissimo) blog Ping, chiuso purtroppo con la cessazione della pubblicazione dell’edizione italiana di Macworld.

Perché pubblicare di nuovo questo articolo dopo più di sei anni?

Innanzi tutto perché quello che c’è scritto è ancora attuale e, come ha scritto a suo tempo Lux con il suo stile inimitabile, può essere utile per “avvicinarsi agli incantesimi Unix che danno vita al mondo magico di Mac OS X“, una cosa a cui tengo sempre moltissimo. Magari oggi proporrei di usare sul Mac launchd al posto di cron, anche se quest’ultimo rimane la soluzione più generica, valida su un qualunque sistema Unix.

C’è poi un motivo più personale: proprio dopo questo intervento ho cominciato a pensare che tenere un blog non fosse un’idea proprio fuori dal mondo. Ci ho messo un po’ (come sempre!) a realizzarla, ma dopo tre anni devo ammettere che è stata un’ottima decisione, le soddisfazioni non sono mancate.

Introduzione

L’articolo rispondeva all’esigenza di un lettore di Ping di cambiare automaticamente i permessi di determinati tipi di file contenuti in una cartella del Mac. Cosa ci può essere di meglio del Terminale per fare queste cose?

Ho lasciato praticamente inalterato il testo originale, limitandomi a correggere alcune imprecisioni e ad aggiungere qualche dettaglio qui e là.

Me li do io i permessi

Premessa #1: il Terminale in Mac OS X si trova in Applicazioni > Utility. Una volta lanciato può essere configurato in molti modi (tramite le Preferenze) perdendo quell’aspetto un po’ triste e troppo serioso che spaventa l’utente normale.

Dopo l’avvio, il Terminale presenta il cosiddetto prompt, che su OS X mostra tipicamente il nome del computer, la cartella dove ci si trova e il nome dell’utente. L’ultimo carattere del prompt è normalmente il $. Nel Terminale i comandi vengono inseriti dopo il simbolo $ su quella che viene definita la riga di comando e si eseguono premendo il tasto Invio.

Il Terminale di OS X esegue di default la cosiddetta shell bash, uno strumento potentissimo per interagire con il sistema operativo. La shell bash può essere usata direttamente, scrivendo i comandi uno ad uno sulla riga di comando e leggendone il risultato direttamente nel Terminale.

Il Terminale di OS X

Oppure si possono scrivere degli script, piccoli programmi nel linguaggio di bash nei quali si inseriscono in sequenza i comandi da far eseguire alla shell, che si dimostrano molto utili per automatizzare delle operazioni che eseguiamo ripetutamente sul Mac.

Premessa #2: perché usare i comandi di bash invece di Automator o di AppleScript? Beh, innanzitutto perché bash è multipiattaforma e quindi funziona su Linux e, volendo, anche su Windows. E poi semplicemente perché bash mi piace!

Lanciamo quindi il Terminale (magari configurandolo prima, io consiglio almeno di aumentare le dimensioni della finestra a circa 100×40 per stare comodi e di scegliere un tema grafico più accattivante di quello bianco e un po’ spento di default) e iniziamo a lavorare.

Configurazione di bash

Creiamo innanzi tutto una cartella ~/bin, dove il carattere ~ (tilde, ALT+5) indica per convenzione sui sistemi basati su Unix la cartella Inizio (detta anche Home) dell’utente che sta usando il computer in questo momento. Per farlo da Terminale, digitiamo (ATTENZIONE, come già detto $ indica solo l’ultimo carattere del prompt e NON va mai inserito nei comandi seguenti):

$ cd
$ mkdir bin
$ chflags hidden bin
$ cd bin

Il primo comando serve per essere sicuri di partire dalla Home, il secondo crea una nuova cartella bin nella Home, il terzo la nasconde al Finder e l’ultimo comando ci fa spostare nella cartella bin appena creata.

In teoria siamo liberi di salvare i nostri comandi bash in una qualunque cartella del Mac e possiamo anche usarne una già esistente. Ma usare la cartella bin nella nostra Home rispetta le convenzioni dei sistemi Unix e mi sembra preferibile.

A questo punto usiamo nano (un editor testuale molto semplice installato di default sul Mac) per editare lo script bash cambia_permessi, nel quale inseriremo i comandi veri e propri che ci servono per cambiare i permessi dei file contenuti nella cartella nella quale verrà eseguito lo script:

$ nano cambia_permessi

Non preoccupatevi per l’interfaccia un po’ ostica di nano, qui ci basta usare solo due comandi, CTRL+O per salvare il file editato e CTRL+X per uscire da nano. Dimenticavo: CTRL+O significa premere contemporaneamente il tasto CTRL, l’ultimo in basso a sinistra sulle tastiere Mac (nei portatili è a fianco di fn), e il tasto O. Analogamente per CTRL+X.

Torniamo al nostro file cambia_permessi. A questo punto bisognerebbe copiare a mano le linee mostrate qui sotto. Ma OS X è furbo e il copia e incolla funziona anche nella finestra del Terminale, per cui è sufficiente selezionare tutte le linee mostrate qui sotto, copiarle e poi incollarle nella finestra del Terminale dove è attivo nano:

#!/bin/bash
#
DIR=~/scansioni/
FILES=*
PERM=u+rw
#
if [ -d $DIR ]; then
    cd $DIR
    chmod -R $PERM $FILES
    cd
fi

Salviamo lo script premendo CTRL+O ed usciamo da nano con CTRL+X.

Cosa significano questi comandi? Il più importante è chmod, che cambia i permessi di tutti i file contenuti nella cartella “~/scansioni/` in modo che siano leggibili e scrivibili dall’utente attuale del Mac. Il resto è solo roba di contorno.

Quello che è ancora più importante è che lo script è totalmente parametrico: basta cambiare i valori di DIR, FILES e PERM per adattarlo alle proprie esigenze.

Per esempio, se la cartella ~/scansioni/ contenesse vari tipi di file e si volessero cambiare i permessi dei soli file pdf lasciando gli altri file invariati, la riga FILES=* diventerebbe FILES=*.pdf.

Non è finita. Controlliamo prima di tutto di avere veramente fatto tutto bene con il comando:

$ cat cambia_permessi

che dovrebbe mostrare sullo schermo lo script appena inserito.

Per semplificarci la vita, rendiamo lo script eseguibile con il comando:

$ chmod u+x cambia_permessi

Bisogna notare che con questo comando abbiamo reso eseguibile lo script solo per l’utente attuale del Mac. I motivi li tralascio per brevità, ma credetemi, è decisamente meglio fare così.

Un ultimo passo necessario. In questo momento, per cambiare i permessi dei file nella cartella ~/scansioni/ bisogna eseguire a mano il comando dal Terminale:

$ ~/bin/cambia_permessi

(anche se, per come è configurato di default OS X, usare soltanto $ cambia_permessi, senza scrivere esplicitamente il percorso dove è salvato lo script basta e avanza).

Ciò è sicuramente molto più comodo di cambiare uno ad uno i permessi dei file, ma si può fare di meglio.

Qui entra in gioco cron, uno strumento che esegue dei comandi stabiliti dall’utente a intervalli di tempo predefiniti. Sembra una cosa un po’ cretina, ma in realtà permette di far fare al computer un mare di cose automaticamente. Purtoppo la sintassi di cron è orrenda. E questo post sta diventando troppo lungo.

Cercherò di sintetizzare ma se qualcuno è interessato posso scrivere qualcosa in proposito. (Nel frattempo l’ho fatto, chi fosse interessato può leggere questo articolo dettagliato su cron.)

Diciamo che vogliamo che ogni cinque minuti lo script cambia_permessi venga eseguito automaticamente. Dal solito Terminale dobbiamo allora eseguire i comandi:

$ export EDITOR=/usr/bin/nano
$ crontab -e

La prima riga serve ad evitare di usare l’editor preimpostato, vi, vn vero reperto archeologico che sarebbe bene dimenticare una volta per tutte. Dovrebbe invece aprirsi il solito nano, in cui dobbiamo incollare esattamente la riga seguente:

*/5 * * * * ~/bin/cambia_permessi

(prima e dopo ciascun asterisco è presente una tabulazione), eventualmente aggiungendola in coda ai comandi già presenti.

Salviamo con CTRL+O e usciamo da crontab con CTRL+X.

Ovviamente se vogliamo che lo script venga eseguito più o meno frequentemente, basta cambiare il valore */5 in, diciamo, */2 o */15 (per eseguire lo script ogni 2 o 15 minuti). Per casi più complicati basta leggere qui.

Abbiamo finito. Sembra complicato, ma credetemi, è molto più lungo da leggere (e da scrivere!) che da mettere in pratica.

Nota finale

Per chi ha paura del Terminale e soprattutto di cron, un programma potente ma, bisogna ammetterlo, ben poco user-friendly, ecco una soluzione aggiuntiva, farina di Lux.

Aggiungo solo una piccola nota per gli inesperti di Terminale che si scontrano con cron (e, su Snow Leopard, con launchd). Una scorciatoia artigianale consiste nel definire un evento ricorrente dentro iCal e, nelle informazioni relative, stabilire che in occasione dell’evento va eseguito uno script.

Molto pratica se si ha bisogno di ripetere uno script una o due volte al giorno al massimo, in tutti gli altri casi temo che finirebbe per riempire all’inverosimile il proprio Calendario, con conseguenze che francamente mi sfuggono.

Tagged with: , , , , , ,
Pubblicato su programmazione
Informativa
Questo sito utilizza cookie di terze parti per inviarti pubblicità e servizi in linea con le tue preferenze. Se vuoi saperne di più o negare il consenso a tutti o ad alcuni cookie, clicca qui. Scorrendo questa pagina, cliccando su un link o su qualunque altro elemento o proseguendo la navigazione in altra maniera, acconsenti all'uso dei cookie.
Follow MelaBit on WordPress.com
Categorie
%d blogger hanno fatto clic su Mi Piace per questo: