GitHub: caricare tutti i diff con un solo click

In un mondo ideale tutte le pull requests (PR) dovrebbero essere piccole e concise non arrivando mai a superare le 200-300 righe di diff. Spezzare il lavoro in piccoli task, infatti, permetti di semplificare la vita al collega che dovrà fare la code-review prima del merge del codice.

Adoro i diff piccoli

Sfortunatamente nel mondo reale non sempre è possibile mantenere le PR di dimensioni accettabili. Soprattutto quando è necessario rilasciare in produzione nuove funzionalità può capitare che non si riesca a spezzarle in rilasci più piccoli.

La pull request che non vorrei mai incontrare

Quando capitano mostri del genere GitHub, per ovvie ragioni di performance, non mostra il diff completo ma richiede di caricare in maniera asincrona i file da rivedere.

Il famigerato bottone “Load Diff”

Quando è necessario fare le review di Pull Request del genere cliccare il pulsante “Load Diff” per ogni file modificato può diventare il peggior nemico del tunnel carpale.

Ma prima di vedere come risolvere questo problema mi presento, sono Lorenzo Millucci e sono un ingegnere del software che ama lavorare con PHP e Symfony. Nel tempo libero mi piace condividere in questo blog le cose che imparo. Iscriviti al mio canale Telegram per non perderti nessuna notizia!

Aprire tutti i diff insieme

Per salvare il tunnel carpale da una montagna di click sul pulsante “Load diff” fortunatamente ci vengono incontro due righe di JavaScript:

document.querySelectorAll('.load-diff-button').forEach(node => node.click())

Ti basterà incollarle nella console degli strumenti per sviluppatori per far si che vengano automaticamente clickati tramite JavaScript tutti i pulsanti “Load Diff”.

Et voilà, il gioco è fatto!

Tip: memorizzare lo script in Chrome/Edge

Si, lo so, è una sola riga di codice. Potrei anche memorizzarla…. Ma se non fossi pigro non avrei mai fatto lo sviluppatore. Ecco perché ho trovato un modo che permetta di utilizzare questo script sfruttando una funzione poco nota di Chrome e Edge: i Frammenti (o Snippets in inglese).

Se ti capita di dover digitare continuamente le stesse righe di codice all’interno della console del browser puoi pensare di salvarle all’interno di un frammento. Infatti memorizzandole in un frammento potrai eseguirle all’interno di qualunque pagina utilizzando direttamente gli strumenti del browser.

La prima cosa da fare per creare un nuovo Frammento è aprire gli strumenti per sviluppatori, spostarti nella sezione Origini (Sources in inglese) e da li selezionare Frammenti (Snippets) e premere su Nuovo frammento (New snippet).

Il browser a questo punto ti chiederà di assegnare un nome al nuovo script e di definirne il contenuto.

Ritornando all’obiettivo dell’articolo, per automatizzare l’apertura dei diff ho creato un nuovo frammento chiamato GitHub PR in cui ho incollato lo script riportato sopra.

Aggiunta di un nuovo frammento

Una volta salvato il frammento, per richiamarlo all’interno di una pagina basterà aprire nuovamente gli strumenti per sviluppatori e premere Ctrl+O per aprire l’elenco dei comandi e digitare le iniziali dello Snippet appena salvato precedute dal simbolo ! (ad esempio nel mio caso il comando sarebbe !GitHub PR)

Esecuzione di un frammento memorizzato

Facendo click sul nome del frammento questo verrà eseguito dal browser e, nel caso in questione, tutti i diff verranno caricati in una sola volta.


Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!

Fonte

Ubuntu: Installare i driver stampa Samsung (HP)

Samsung Xpress 2070FW

E’ una normale mattina di un giorno infrasettimanale. Come sempre alle 7.00 suona la sveglia ed inizia la routine dei preparativi per andare al lavoro.

Oggi sono stato bravo, ho ben 5 minuti di anticipo sul solito orario di partenza in modo da stampare con calma quel foglio che devo da consegnare al lavoro.

Avvio velocemente il mio notebook con Ubuntu 20.04, apro il documento che mi serve e premo il pulsante di stampa.

Cosa potrebbe mai andare storto?

Si dice che non si debba mai far capire ad una stampante che si ha fretta altrimenti questa si incepperà inesorabilmente.

Legge di Murphy

Questo è quello che tira fuori la stampante:

Eh si, era proprio questo il documento che volevo stampare….

Dannazione!

Ero così felice che Ubuntu avesse riconosciuto subito la stampante senza bisogno di dover intervenire manualmente. E invece anche questa volta è stato necessario installare manualmente i driver.

Ma prima di mostrarti come installare i driver per la stampante mi presento, sono Lorenzo Millucci e sono un ingegnere del software che ama lavorare con PHP e Symfony. Nel tempo libero mi piace condividere in questo blog le cose che imparo. Iscriviti al mio canale Telegram per non perderti nessuna notizia!

Installazione driver

In questo articolo io faccio riferimento all’installazione dei driver per la stampante Samsung Xpress M2070FW su Ubuntu 20.04. Se utilizzi un modello di stampante diverso o se hai una versione differente del sistema operativo la procedura potrebbe cambiare leggermente ma dovrebbe essere comunque valida.

  • Andiamo con ordine, la prima cosa da fare è verificare che la stampante sia accesa e collegata al computer,
  • Dopodiché collegati al sito Samsung/Hp, seleziona il modello della stampante e scarica il pacchetto Unified Linux Driver contenente i driver,
  • Estrai il pacchetto appena scaricato utilizzando il click destro del mouse e selezionando la voce estrai dal menù a tendina. Oppure se preferisci il terminale puoi utilizzare il comando:
tar -zxvf uld_V1.00.39_01.17.tar.gz
  • Spostati all’interno della cartella appena estratta e dai i permessi di esecuzione allo script di installazione utilizzando il comando:
chmod +x ./install.sh
  • Avvia l’installazione con il comando
./install.sh

ATTENZIONE: sarai obbligato a scorrere tutti i termini di servizio di Samsung/Hp prima di poter procedere all’installazione effettiva dei driver. Alla fine delle lunghe paginate di condizioni da accettare ti verrà chiesto di accettarle rispondendo alla domanda **** Do you agree ? [y/n]. Se anche tu stavi tenendo pigiato il tasto invio per scorrere velocemente i termini di servizio ti capiterà di sicuro di saltare questa domanda rifiutando quindi i termini di contratto. Purtroppo in questa situazione l’unica soluzione è riavviare l’installazione da capo.

Accetti i termini di servizio?
Attenzione a non rifiutare l’accettazione dei termini di servizio tenendo premuto invio

Una volta che la procedura sarà terminata potrai andare nelle impostazioni di Ubuntu e aggiungere la stampante seguendo la procedura guidata del sistema operativo.

NOTA: se avevi provato ad aggiungere la stampante prima di installare i driver potresti doverla rimuovere e ri-aggiungere affinché vengano utilizzati i driver appena installati al posto di quelli generici.


Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!

La leggibilità del codice

Codice illeggibile?

The rationale for the code being the primary source of documentation is that it is the only one that is sufficiently detailed and precise to act in that role [….].

This principle comes with a important consequence – that it’s important that programmers put in the effort to make sure that this code is clear and readable.

Martin Fowler – CodeAsDocumentation

Di solito gli sviluppatori non dedicano particolare attenzione alla scrittura della documentazione. Nel caso migliore è vista come un male necessario, nel caso peggiore invece è trattata come un task da fare il più tardi possibile (e tendenzialmente mai).

Recentemente, grazie alla diffusione di metodologie agili, la scrittura della documentazione sta diventando parte integrante del processo di sviluppo di un software. Infatti il processo di scrittura e di mantenimento della documentazione può essere semplificato inserendola all’interno del codice stesso. In questo modo il codice assume il ruolo di sorgente principale di documentazione di un progetto.

In questo articolo ti voglio parlare dell’importanza di mantenere una documentazione a scopo interno che sia ben fatta, con un codice che sia “parlante” e con il giusto numero di commenti. Per farlo cercherò di rispondere alle seguenti 3 domande:

  • Perché il codice deve essere leggibile?
  • Quando è che un codice è leggibile?
  • Come scrivo codice che sia leggibile?

Ma prima di rispondere a queste domande mi presento, sono Lorenzo Millucci e sono un ingegnere del software che ama lavorare con Symfony e a cui piace condividere in questo blog le cose che impara. Iscriviti al mio canale Telegram per non perderti nessuna notizia!

Perché il codice deve essere leggibile?

Affrontiamo subito l’elefante nella stanza: perché devo prendermi la bega di scrivere del codice che sia leggibile?

Lo sviluppo di software è un task che viene affrontato in team nella quasi totalità dei casi. Ormai quasi nessun progetto viene sviluppato da una singola persona. Questo vuol dire che il codice che oggi io scrivo da solo davanti al mio PC prima o poi dovrà essere letto e capito da altri sviluppatori in modo che possano modificarlo per correggere bug o per aggiungere nuova funzionalità.

Quando il codice non è facilmente leggibile, lo sviluppatore che dovrà modificare dopo di me quelle righe dovrà perdere una notevole quantità di tempo solo per capire cosa ho fatto e come l’ho fatto per quello che magari poteva essere un fix facile e veloce.

Nel caso peggiore il codice scritto potrebbe essere così astruso che uno sviluppatore, piuttosto che perdere tempo nel cercare di decifrarlo, potrebbe decidere di riscriverlo da capo. Ma il processo di riscrittura non è esente da rischi. Infatti non è raro che qualche edge-case particolare non venga coperto dal nuovo codice o che venga introdotto qualche bug che il codice originale non aveva. Tutto ciò rende quindi necessario iterare più e più volte il processo di scrittura aumentando notevolmente i tempi e i costi di sviluppo.

Un altro fenomeno che spesso si verifica quando il codice non è facilmente interpretabile dagli sviluppatori è quello chiamato “Shanghai programming”.
Hai presente il gioco Shanghai? Quello in cui c’è un mucchio di bastoncini e i giocatori si sfidano a chi ne sfila il numero maggiore senza muovere gli altri.
Bene, può accadere la stessa cosa nello sviluppo di un software. Uno sviluppatore, non riuscendo a capire cosa faccia il mio codice, potrebbe essere portato a cambiare solamente le parti strettamente necessarie ad implementare la funzionalità richiesta senza toccare il resto. Questo comportamento non può che portare ad un’ulteriore riduzione della leggibilità del codice.

Arrivati a questo punto non devi stupirti del fatto che il codice non leggibile sia uno dei più grandi contribuenti all’aumento incontrollato del debito tecnico.

Ora che hai capito il perché il codice deve essere facilmente leggibile da chiunque procediamo a chiarire quando è che un codice è leggibile (e di conseguenza quando non lo è).

Malore: La tipica reazione di uno sviluppatore di fronte ad un codice illeggibile
La tipica reazione di uno sviluppatore di fronte ad un codice illeggibile

Quando è che un codice è leggibile?

Sfortunatamente non esiste una risposta universale a questa domanda. A seconda del linguaggio utilizzato, del team o della singola persona presa in considerazione la risposta a questa domanda varia.

Quello che sicuramente possiamo dire è che un codice è illeggibile se non è formattato in modo coerente.
Ti è mai capitato di aprire un libro e vedere una pagina fitta-fitta di testo senza alcuna suddivisione in paragrafi? Quando succede a me la prima reazione è quella di chiudere il libro e lasciare perdere la lettura. Questa è la stessa reazione di uno sviluppatore che vede un codice mal-formattato.

Quindi una prima costatazione da fare è che per aumentare la leggibilità del codice è necessario stabilire delle convenzioni da seguire per l’impaginazione/formattazione del codice. Ad esempio definire che tutti i metodi devono essere scritti in camelCase. Oppure che l’indentazione del codice deve essere fatta utilizzando gli spazi piuttosto che tabulazioni. Ecc…
Tipicamente per queste regole stilistiche ci vengono incontro vari tool automatici di analisi statica che, una volta definite le regole, evidenziano (e a volte correggono automaticamente) tutti gli errori che incontrano.

Ma è sufficiente definire delle regole stilistiche per scrivere del codice leggibile? Ovviamente la risposta è no.

Una volta che il codice è ben formattato bisogna iniziare a vedere che ciò che abbiamo scritto sia comprensibile anche agli altri membri del team di sviluppo.

La prima cosa da fare in questo caso è farsi una serie di domande:

  • Si riesce a seguire il flusso del codice?
  • Il nome di un metodo/variabile aiuta a capire a cosa serve?
  • E’ necessario aggiungere un commento ulteriore per chiarire cosa sto facendo?
  • ecc…

Una volta terminata questa fase di “auto-analisi” del codice posso finalmente affermare che il codice è chiaramente leggibile da me stesso.

Ma come dicevamo all’inizio orma si lavora sempre in team e quindi non è sufficiente che il codice che ho scritto sia leggibile da me ma deve essere leggibile da qualunque altro collega.

Ecco quindi la prova finale per garantire la leggibilità di un software: superare la code-review.

Solo nel caso in cui un altro sviluppatore sia effettivamente in grado di capire cosa fa il mio codice senza porre domande sul suo funzionamento e senza fraintenderne in alcun modo il flusso logico posso dire di aver prodotto un codice veramente leggibile.

Reazione di festeggiamento quando finalmente la code review passa
Finalmente il codice è leggibile

Come scrivo codice che sia leggibile?

Anche a questa domanda non esiste una risposta universalmente riconosciuta. Tuttavia alcuni principi da avere bene a mente durante lo sviluppo del software sono:

  • Single-responsibility principle (SRP): ogni elemento di un programma deve avere una e una sola responsabilità. In modo tale che per uno sviluppatore sia facile capire cosa andare a modificare in caso di necessità.
  • Don’t repeat yourself (DRY): ogni elemento di un programma deve essere scritto una e una sola volta all’interno della code-base. Deve esistere una sola fonte di verità in modo da garantire che la modifica di un blocco di codice non debba mai essere ripetuta in più volte in più punti dell’applicazione.
  • Naming significativo: i nomi degli attributi, delle funzioni e delle classi deve essere significativo ed essere pensato in modo tale da aiutare la comprensione del codice.
  • Commenti solo se necessari: con un buon naming si può fare a meno di molti blocchi di commenti. Tuttavia esistono porzioni di codice che richiedono ulteriori spiegazioni e che quindi devono essere necessariamente commentate. I buoni commenti spiegano il “perché” di una determinata scelta. Il “come” è spiegato dal codice.
  • Testing: sebbene i test automatici non migliorino direttamente la leggibilità di un blocco di codice, questi permettono di capire il contesto in cui il codice è utilizzato. Inoltre, anche con il codice più leggibile del mondo è facile incappare in errori. Solo con una suite di test automatici in grado di coprire tutto il software è possibile modificare un software senza il terrore di aver rotto qualcosa nel tentativo di aggiustare qualcos’altro.

Conclusioni

Spero che questo articolo ti abbia aiutato a capire “perché”, “quando” e “come” scrivere un codice leggibile. Sicuramente ha aiutato me a mettere in ordine varie idee e nozioni che avevo acquisito ma che non avevo mai avuto modo di organizzare in modo strutturato.

Come hai potuto leggere nel corso dell’articolo alla base di un codice leggibile non c’è nessun concetto astratto o complesso da capire. Si tratta di nozioni che chiunque abbia provato a programmare con un qualunque linguaggio conosce ma che di solito si tende a dimenticare in quanto concetti considerati banali.

Un ulteriore punto che ci tengo a precisare è che la perfezione non esiste. Esisterà sempre un modo più ricercato o più elegante per rendere maggiormente leggibile una porzione di codice.
Il problema è che poiché la leggibilità non è un concetto universalmente definito dagli sviluppatori si possono creare delle situazioni di stallo in cui opinioni differenti rischiano di bloccare completamente lo sviluppo. Proprio per evitare di cercare la perfezione a tutti i costi è fondamentale tenere a mente che molte volte è sufficiente che il codice sia leggibile da chi effettivamente dovrà lavorare sul codice. Ed è per questo che le code-review sono lo strumento principale per garantire la leggibilità del codice.

Infine c’è da dire che il codice non è scritto nella pietra. La ricerca della miglior leggibilità del codice è un processo continuo. Ogni volta che puoi migliorare la leggibilità è bene non indugiare e farlo subito in modo da ridurre il debito tecnico. Grazie alla suite di test automatici (che non a caso ho inserito tra i requisiti per un buon codice leggibile) potrai rifattorizzare il codice avendo la certezza di non aver rotto nulla.


Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!

Fonte
Fonte

Responsible disclosure: esposizione della cartella .git su di un sito di comparazione prezzi

responsible disclosure

Era un normalissimo Lunedì mattina. Come sempre, prima di iniziare a lavorare, stavo facendo una navigata sul web. Ero appena entrato sul sito di una compagnia di comparazione prezzi quando una notifica del browser cattura la mia attenzione: Found an exposed .git.

L’estensione del browser che utilizzo per verificare automaticamente se un sito web ha la cartella /.git esposta ne aveva appena beccato uno.

Ops, ho appena trovato una cartella .git pubblicamente accessibile

Se non sei uno sviluppatore ti starai chiedendo: “è quindi”? Se invece conosci Git sai già quanto possa essere potenzialmente grave avere la cartella .git pubblicamente accessibile.

Infatti attraverso l’accesso a quella cartella sono riuscito ad estrapolare le chiavi di accesso al database!

A livello puramente teorico, in assenza di ulteriori meccanismi di protezione, ottenere credenziali del genere potrebbe garantire ad un malintenzionato l’accesso in lettura e scrittura ai dati di tutti gli utenti della piattaforma (username, hash di password, ecc…).

Ma prima di vedere nel dettaglio che strumenti ho usato per accorgermi della vulnerabilità e come è andata a finire la storia lasciami presentare. Io sono Lorenzo Millucci e sono un ingegnere del software che ama lavorare con Symfony e a cui piace condividere in questo blog le cose che impara. Iscriviti al mio canale Telegram per non perderti nessuna notizia!

Cos’è Git?

Andiamo con ordine. La prima cosa che ti serve sapere per capire quale sia stato il problema di sicurezza è capire cosa sia Git e perché avere accesso a quella cartella è un problema di sicurezza.

Git è un popolarissimo software utilizzato dagli sviluppatori per tracciare le modifiche del codice sorgente (versionamento) creato da Linus Torvalds (il creatore di Linux) nel 2003.

Per tracciare tutti i cambiamenti all’interno di una codbase, Git mantiene tutti i (meta-)dati necessari all’interno di una cartella nascosta chiamata .git.

Normalmente Git è uno strumento utilizzato esclusivamente internamente ai team di sviluppo e i meta-dati che produce non sono accessibili pubblicamente. Può però capitare che a causa di una dimenticanza o di una cattiva configurazione del server questa cartella non venga opportunamente protetta e che sia quindi leggibile da chiunque.

Avendo accesso alla cartella .git è possibile estrapolare diverse informazioni sensibili sul sito web semplicemente guardando i file in essa contenuti:

  • .git/config: è il file di testo utilizzato da git per tracciare le informazioni generali sul repository (es. l’URL del server con il repository, l’username, le branch attive… )
  • .git/index: è il file contente l’indice di tutti i file presenti nel repository e di tutte le modifiche fatte. Il file è in formato binario ma esistono dei tool appositi in grado di leggerne il contenuto.
  • .git/objects: è la cartella che contiene tutte i file del progetto. Tutti i file sono salvati senza estensione e utilizzando l’hash SHA1 come file name. E’ da questa cartella che è possibile estrapolare dati sensibili del sito web.

Come mi accorgo di una cartella .git esposta pubblicamente?

Ora che hai capito cos’è Git ti chiederai come si fa a verificare se la cartella .git è pubblicamente accessibile su una web-app.

Il metodo più semplice (e più macchinoso) per verificare se una cartella .git è esposta pubblicamente è quello di provare a modificare l’URL della pagina aggiungendo di volta in volta il percorso alla cartella .git nel seguente modo:

  • https://example.com/.git/config
  • https://example.com/.git/HEAD
  • https://example.com/.git/logs/HEAD
  • https://example.com/.git/index

Siccome farlo manualmente è una scocciatura è possibile scaricare un estensione del browser (per Firefox e Chrome) chiamata DotGit che permette di effettuare la verifica automaticamente. Nel caso in cui i file sono pubblicamente accessibili l’estensione lo farà presente immediatamente con una notifica.

Che ci faccio con la cartella .git?

Ora arriva la parte divertente. Una volta che ho trovato una cartella Git esposta tutto quello che devo fare è utilizzare un software chiamato GitTools per scaricare ed estrarre automaticamente tutto il codice lasciato incustodito.

Per scaricare il contenuto della cartella .git basta dare il comando:

./Dumper/gitdumper.sh https://example.com/.git/ /output-directory/

Siccome spesso i repository vengono compressi può succedere che i dati scaricati non siano immediatamente leggibili. Proprio per questa evenienza i GitTools mettono a disposizione un altro strumento che permette di carpire quanta più informazione possibile dal repository scaricato.
Per usare questo strumento il comando da utilizzare è:

 ./Extractor/extractor.sh /output-directory/ /output-directory-extracted/

Una volta che il tool avrà finito di estrarre il contenuto della cartella sarà possibile esplorare il codice sorgente. A seconda dell’applicazione web è possibile cercare all’interno del codice chiavi di accesso, credenziali hordcodate, nuovi endpoint segreti, ecc…

Disclosure

Ma ritorniamo a Lunedì mattina. Avevo appena ricevuto la notifica da parte di DotGit. Ero abbastanza stupito che un sito così famoso avesse potuto commettere un errore tanto banale senza che nessuno se ne accorgesse.

Così ho provato a vedere cosa ci fosse all’interno del repository utilizzando i GitTools e mi sono accorto che tra i file c’era il file di configurazione .env contenete le chiavi di accesso ai vari database del sito.

Uno dei “pericolosi” file che contengono le chiavi di accesso ai database. Naturalmente ho oscurato i dati sensibili

Io non ho provato a connettermi ai vari database del sito visto che il mio interesse era puramente “accademico” e visto che molto probabilmente sono protetti da ulteriori meccanismi di protezione. Tutto quello che ho fatto è stato segnalare la vulnerabilità al supporto tecnico del sito che si è rivelato svelto a rispondermi e a risolvere il problema.

Timeline

  • Lunedì 22/06/2020 navigando prima di attaccare al lavoro mi accorgo della vulnerabilità;
  • Lunedì 22/06/2020 11:24 contatto il supporto del sito per segnalare la vulnerabilità;
  • Lunedì 22/06/2020 13:05 mi risponde il responsabile tecnico del sito;
  • Lunedì 22/06/2020 13:17 segnalo il problema al responsabile;
  • Lunedì 22/06/2020 15:21 il supporto mi segnala che il problema è stato risolto.

Conclusioni

Alla fine tutto bene quel che finisce bene. Sfortunatamente il problema di lasciare cartelle .git esposte è più comune di quanto si pensi. Tanto è vero che anche OWASP (il progetto che ha come scopo la sicurezza delle applicazioni web) lo inserisce tra i requisiti da verificare per garantire la protezione da accessi indesiderati ai siti web.

In ogni caso l’assistenza si è dimostrata rapida ed efficace nel risolvere il problema e mi piace pensare che ora il web sia diventato un po’ più sicuro anche per merito mio.

Nonostante il problema sia stato gestito e risolto in maniera impeccabile l’azienda in questione mi ha chiesto di non divulgare il suo nome e di conseguenza non è riportato da nessuna parte nell’articolo.


Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!

Cos’è il debito tecnico?

Debito tecnico

Fin da quando ho iniziato a lavorare ho sentito parlare di “debito tecnico”. Al lavoro recentemente abbiamo anche creato una board dedicata esclusivamente al tracciamento del debito tecnico.

Ma che cos’è il debito tecnico? Pur non avendo mai approfondito il concetto è facile capire a grandi linee di cosa si tratta: sono tutte quelle cose che uno lascia indietro oggi per poter rilasciare prima il software sapendo che prima o poi sarà necessario ritornarci sopra.

In realtà la metafora del debito tecnico è un po’ più articolata di così e oggi ho approfittato di un giorno di ferie per studiare meglio la questione analizzando le parole del leggendario Martin Fowler.

Prima di cominciare mi presento, sono Lorenzo Millucci e sono un ingegnere del software che ama lavorare con Symfony e a cui piace condividere in questo blog le cose che impara. Iscriviti al mio canale Telegram per non perderti nessuna notizia!

Definizione

Il debito tecnico è una metafora concepita da Ward Cunningham che assimila la complessità di un software ad un debito finanziario e lo sforzo necessario ad aggiungere una nuova funzionalità all’interesse pagato sul debito.

Ogni riga di codice scritta, ogni libreria installata nel progetto incrementa il livello di complessità generale al progetto andando ad incrementare il debito tecnico.

Esattamente come accade per i debiti finanziari, la scelta migliore è pagare gradualmente in “comode” rate mensili.

La forza di questa metafora consiste nel rendere evidente anche a chi non è un ingegnere del software come anche le attività di refactoring del codice, pur non portando nuove funzionalità al progetto, sono necessarie a “ripagare” la quota del debito.

Ogni volta che è necessario aggiungere una nuova funzionalità al progetto sarebbe buona norma investire del tempo per ristrutturare il codice esistente. Chiaramente in questo modo si otterrebbero dei cicli di sviluppo più lunghi. Tuttavia, qualora dovesse capitare di lavorare nuovamente sulla stessa porzione di codice il lavoro potrebbe procedere in modo molto più spedito avendo già pagato la quota di debito.

Se invece si decidesse di non pagare periodicamente le quote di debito tecnico si finirebbe per avere cicli di sviluppo molto rapidi all’inizio ma, mano a mano che il debito si accumula, i tempi di sviluppo si estenderebbero sempre di più fino ad arrivare al fatidico momento in cui la complessità del software è così alta che non è più possibile sviluppare nuove funzioni in tempi ragionevoli. Quando si arriva in questa situazione, quello che accade solitamente è che si getta la spugna ed è necessario riscrivere da capo il software.

Posso pagare il debito tecnico in stelline?

Una delle principali differenze con i debiti finanziari invece è che, contrariamente ai debiti finanziari in cui l’interesse da pagare è sul totale, sui debiti tecnici il costo da pagare è dipendente dalla porzione di codice. In un software possono esistere parti di codice da incubo con un debito tecnico altissimo ma che non tocca nessuno e quindi un interesse bassissimo e parti di codice che invece sono modificate frequentemente e che quindi pur avendo dei piccoli debiti hanno degli interessi stellari.

TIPOLOGIE DI DEBITO

A seconda di come si affronta il debito tecnico è possibile individuare due classificazioni del debito. Una basata sul rischio (prudente/imprudente) e una basata sulla coscienziosità con cui si protrae il debito (volontario/involontario). Vediamo di seguito come si combinano le due classi:

  • DEBITO VOLONTARIO E PRUDENTE: nello sviluppo di un progetto è ammissibile accettare di fare del debito per concentrarsi sulle cose urgenti. L’importante è sapere che il debito fatto oggi tornerà a chiederci gli interessi domani.
  • DEBITO VOLONTARIO E IMPRUDENTE: questo forse è il caso peggiore. So di indebitarmi pur di consegnare il software ma faccio finta che stia andando tutto bene trascurando completamente le conseguenze di tale indebitamento.
  • DEBITO INVOLONTARIO E IMPRUDENTE: questo in genere accade agli sviluppatori alle prime armi che non conoscono il concetto di debito tecnico e non si rendono conto che cattive scelte fatte in fase di progetto li perseguiteranno in futuro.
  • DEBITO INVOLONTARIO E PRUDENTE: Molto spesso accade che nonostante si abbiano seguito perfettamente le migliori best-practices ci si rende conto che se si fosse utilizzato quel design pattern o quell’altra architettura il codice sarebbe stato sicuramente migliore (in termini di complessità).

Queste combinazioni possono essere riportate in un grafico fatto nel seguente modo:

Il quadrante del debito tecnico

Il fatto che ogni progetto finisca per avere del debito tecnico però non deve essere preso come scusa per trascurare la qualità del codice. Aggiungere codice di scarsa qualità ad un progetto già indebitato fino al collo o scordarsi di pagare le rate degli interessi non può che peggiorare la situazione arrivando a rendere impossibile lo sviluppo di nuove funzionalità.

D’altro canto, un debito ben ragionato con piccole quote di interesse pagate regolarmente può permettere di accelerare il rilascio di nuove funzionalità.

Conclusioni

Ogni volta che adottiamo una soluzione “quick and dirty” per risolvere un problema stiamo facendo debito. Ogni volta che trascuriamo di aggiornare le libreria del progetto stiamo facendo debito. Ogni volta che ci rendiamo conto che avremmo potuto semplificare il codice e non lo facciamo stiamo facendo debito.

Il debito tecnico quindi è un’ombra che che incombe su ogni sviluppatore. Può sembrare minacciosa ma il solo sapere che esiste può essere sufficiente per tenerla a bada. 

Il debito tecnico di per sé non è malvagio. Avere un debito è normale per qualunque azienda si occupi di software. La cosa fondamentale da fare però è fare in modo che non raggiunga mai soglie troppo elevate e che le quote di interesse non schizzino alle stelle paralizzando completamente il progetto. 

Come per i debiti finanziari la bravura sta nel ripagare il debito in piccole rate includendo sempre nella roadmap dei progetti del tempo da dedicare al refactoring del codice.


Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!

Fonte
Fonte

Firefox disattivare la comparsa della barra dei menù quando si preme alt

Io sono un’amante delle scorciatoie da tastiera, quando posso cerco sempre di utilizzarle al posto del mouse. Utilizzando Firefox su Ubuntu però mi sono accorto di un fastidioso effetto collaterale quando premo il tasto alt (ad esempio quando premo alt + tab per cambiare applicazione aperta).

In pratica quello che succede è che nel momento in cui si preme il tasto alt della tastiera Firefox mostra la barra dei menù (che di solito è nascosta) facendo scorrere di qualche pixel la pagina. Questo, oltre ad essere fastidioso e brutto a vedersi, a volte cattura combinazioni di tasti non desiderate abilitando comportamenti “strani” del browser.

Il fastidioso “balletto” della pagina quando si preme il tasto alt

Intanto mi presento, io sono Lorenzo Millucci e sono un software engineer che ama lavorare con Symfony e a cui piace condividere in questo blog le cose che impara. Iscriviti al mio canale Telegram per non perderti nessuna notizia!

Ma ora torniamo sul pezzo e vediamo subito come risolvere il problema utilizzando due differenti modi.

Modifica della configurazione di Firefox (migliore)

Questo, secondo me, è il metodo migliore da seguire per risolvere il problema alla radice andando a modificare la configurazione interna di Firefox.

La prima cosa da fare è digitare about:config nella barra degli indirizzi di Firefox. Si aprirà una pagina in cui Firefox ti avverte dei rischi collegati alle modifiche che è possibile fare dal pannello delle impostazioni avanzate. Per proseguire bisogna premere il pulsante Accetta il rischio e continua.

A questo punto nella barra in alto bisogna inserire la chiave di ricerca ui.key.menuAccessKeyFocuses e cambiare l’impostazione da true a false.

E il gioco è fatto, d’ora in poi non sarà più visualizzata la barra dei menù quando viene premuto il tasto alt.

Modifica al registro di Firefox per modificare il comportamento del tasto alt
Modifica alla configurazione di Firefox

Rendere sempre visibile la barra dei menù

Questo metodo non richiede di entrare nel pannello delle configurazioni avanzate del browser ma si basa sul rendere sempre visibile la barra dei menù grazie alle infinite possibilità di personalizzazione di Firefox. Tuttavia a parer mio, mostrare sempre una barra che occupa spazio verticale su un monitor 16:9 è proprio uno spreco di spazio per cui preferisco il metodo descritto prima.

Per rendere sempre visibile la barra dei menù devi:

  • premere il bottone con l’icona a forma di hamburger (sarebbe quello con le tre linee orizzontali in alto a destra),
  • clickare sulla voce personalizza
  • selezionare barre degli strumenti e mettere la spunta a barre dei menù
Visualizzare sempre la barra dei menù

Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!

FONTE

Aggiungere un podcast a Google Podcast Manager

Google podcast in esecuzione

Informazioni strategiche per far crescere il tuo podcast

Google Podcast Manager

Qualche tempo fa avevo parlato di come fare per indicizzare un podcast su Google, oggi invece ti voglio spiegare come visualizzare ed analizzare le statistiche degli ascoltatori del podcast provenienti da Google.

I principali dati che Google Podcast Manager raccoglie sono:

  • il numero di ascolti per programma e puntata,
  • il numero di ascolti per segmento di puntata,
  • la percentuale di ascolto per ogni puntata.

Per iniziare a raccogliere questi dati la prima cosa da fare è collegarsi al sito https://podcastsmanager.google.com e rivendicare il possesso del nostro podcast attraverso i 4 passaggi che Google mette a disposizione.

Passaggio 1 – inserire il feed RSS

Come primo passaggio ci viene chiesto l’indirizzo del feed RSS del podcast che vogliamo monitorare.

Ad esempio, se utilizzi Spreaker, per trovare l’indirizzo del feed RSS ti basta aprire la pagina del podcast e copiare l’indirizzo indicato tramite l’icona arancione vicino a quella dei social.

Esempio: ottenere l’indirizzo del feed RSS di un podcast su Spreaker trmite l’icona arancione

Una volta copiato l’indirizzo puoi tornare su Podcast Manager ed inserirlo.

Inserimento del feed RSS su Google Podcast Manager

NOTA: se nel momento in cui invii il feed ricevi il messaggio d’errore Questo programma non è al momento disponibile su Google significa che il tuo podcast non è stato ancora aggiunto a Google Podcast, per farlo ti rimando a questa guida.

Passaggio 2 – Verifica dei dati

Anteprima del feed appena inserito

Passaggio 3 – Verifica della proprietà

Per verificare la proprietà del podcast Google invierà una mail con un codice

Passaggio 4 – Proprietà verificata

Proprietà verificata con successo

Perché questi dati sono importanti?

Il mondo del podcasting sta esplodendo è sempre più content creator annunciano la pubblicazione di un podcast. In un contesto del genere è fondamentale catturare e mantenere l’attenzione del pubblico e per farlo è necessario capire esattamente chi ti ascolta, quando ti ascolta e con quale dispositivo.

Proprio per questo Google ha lanciato Podcast Manager che permette di raccogliere in un unico punto le statistiche sulla fidelizzazione del pubblico tramite il numero di puntate riprodotte, il tempo cumulativo di riproduzione e la percentuale di completamento di ogni singolo episodio. Con questi dati capire in quali punti gli ascoltatori interrompono l’ascolto o quali sono le parti maggiormente apprezzate non sarà un problema.

Inoltre grazie al grafico con il numero di ascolti per giorno ti sarà facile capire qual è il momento migliore per pubblicare l’ultimo episodio del podcast.

Infine, grazie al report che mostra su quale dispositivo il tuo podcast viene riprodotto, potrai individuare subito se ti stai rivolgendo ad un pubblico che ascolta le tue puntate in mobilità utilizzando uno smartphone o se invece i tuoi ascoltatori preferiscono la comodità della casa ascoltandoti da uno smart-speaker.


Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!

Analisi delle performance di Webpack

Tempo di bundling di webpack

Non c’è niente di più noioso che dover aspettare che il compilatore termini il proprio lavoro.

Chiunque programmi per applicazioni per il web con buona probabilità avrà avuto il piacere di imbattersi in Webpack. Webpack, grazie alla sua flessibilità e all’enorme quantità di loader e plugin disponibili, è diventato lo standard per la creazione di bundle di asset JS e CSS.

La creazione dei bundle tipicamente non richiede più di qualche secondo per essere completata ma al crescere del numero di asset il tempo necessario a terminare il processo può crescere notevolmente. Ad esempio, nel caso del backoffice di Slope, la creazione dei bundle era arrivata a superare il minuto. Decisamente troppo.

In questo articolo voglio raccontarti come ho migliorato le performance di Webpack utilizzando vari accorgimenti.

Source: https://xkcd.com/303

Ottimizzazione

Per ottimizzare i tempi di build, la documentazione di Webpack, riporta:

Use the latest webpack version. We are always making performance improvements.  […] Staying up-to-date with Node.js can also help with performance. On top of this, keeping your package manager (e.g. npm or yarn) up-to-date can also help. Newer versions create more efficient module trees and increase resolving speed.

documentazione di Webpack

Sulla base di quanto suggerito dalla documentazione ho deciso di provare, utilizzando il backoffice di Slope come benchmark, quale fosse l’impatto dovuto a:

  • Aggiornamento di Webpack dalla versione 3 alla versione 4
  • Avanzamento di Yarn dalla versione 1.19.0 alla versione 1.22.0
  • Avanzamento della versione di Node dalla 8.16.0 alla 12.11.1

Metodo di prova

La prova è stata eseguita su di un PC con le seguenti caratteristiche tecniche:

ProcessoreIntel(R) Core(TM) i5-7600 CPU @ 3.50GHz × 4
Memoria16384 MB (DDR4)
DiscoSamsung SSD 850 (250GB)
Scheda graficaRadeon RX 580 Series (POLARIS10, DRM 3.33.0, 5.3.0-40-generic, LLVM 9.0.0)
OSUbuntu 18.04.4
Kernel5.3.0-40-generic (x86_64)

Le performance sono state misurate utilizzando il BackOffice di Slope. Il progetto è basato su Symfony 4.2.8 e contiene al suo interno circa 190 file Javascript/Typescript e circa 60 file CSS/SCSS.

Per verificare le performance è stato misurato il tempo necessario alla creazione dei bundle nelle seguenti condizioni:

  • configurazione con Webpack 3, Yarn 1.19.0, Node 8.16.0
  • configurazione con Webpack 4 , Yarn 1.19.0, Node 8.16.0
  • configurazione con Webpack 4 , Yarn 1.22.0, Node 8.16.0
  • configurazione con Webpack 4 , Yarn 1.19.0, Node 12.11.1
  • configurazione con Webpack 4 , Yarn 1.22.0, Node 12.11.1

Per ogni configurazione è stata eseguita una prima prova per fare il warm-up della cache (prova 0) e una serie di 10 build consecutive.

Build di development

Come prima prova ho analizzato il tempo necessario ad eseguire la build di development. Nella configurazione di Webpack di sviluppo è abilitata la creazione delle sourcemaps e il linting del codice JS/TS mentre è disattivata la minificazione del codice.

Webpack 3Webpack 4Yarn 1.22.0Node 12.11.1Node 12.11.1 + Yarn 1.22.0
Prova 050,1421,7221,8219,5119,35
Prova 150,4418,4618,8015,9715,82
Prova 250,7018,3915,5615,7615,78
Prova 350,1718,9718,7515,8515,68
Prova 449,1218,6817,7815,9515,63
Prova 550,2818,5718,7815,8915,81
Prova 650,5618,4118,4915,7815,70
Prova 749,3719,0619,9515,9515,86
Prova 849,4219,9518,8815,9415,76
Prova 950,3516,6218,8816,0315,95
Prova 1050,5018,6718,8015,8715,68
Esecuzione delle prove di compilazione nelle varie configurazioni. Tempi in secondi.
Tempo di build nelle varie configurazioni (minore è meglio)
Webpack 3Webpack 4Yarn 1.22.0Node 12.11.1Node 12.11.1 + Yarn 1.22.0
Media50,0618,7819,0716,2316,09
Media (esclusa prova 0)50,0918,4818,7715,9015,77
*Tempi in secondi

Dall’analisi dei risultati si nota chiaramente come il solo passaggio da Webpack 3 a Webpack 4 riduca notevolmente il tempo di creazione della build (circa il 60% in meno!).
Analizzando le performance con Webpack 4 invece è possibile notare come l’effetto del singolo avanzamento di versione di Yarn introduca un trascurabile peggioramento delle performance mentre l’effetto dell’aggiornamento di Node da solo introduca una riduzione dei tempi di build di circa il 10%.

Trovo molto interessante notare anche il fatto che, mentre il singolo aggiornamento di Yarn sembri peggiorare le performance, l’utilizzo congiunto delle ultime versioni di Node e Yarn faccia perdere alla build qualche frazione di secondo sul tempo di esecuzione.

Build di produzione

Nella seconda configurazione di prova ho utilizzato la build di produzione di Webpack. In questa configurazione sono disattivati i processi di linting del codice JS/TS e la creazione delle sourcemaps mentre invece risulta attiva la fase di minificazione del codice.

Webpack 3Webpack 4Yarn 1.22.0Node 12.11.1Node 12.11.1 + Yarn 1.22.0
Prova 076,3537,5336,5632,5632,73
Prova 174,6920,8220,7718,3618,21
Prova 275,7820,7820,8618,3618,12
Prova 373,5320,7720,7918,2818,15
Prova 473,6320,6320,5618,1918,08
Prova 572,0020,8420,9118,3018,13
Prova 672,3721,0720,8318,5118,17
Prova 773,4020,9720,8018,2518,15
Prova 874,2321,0220,9618,6918,16
Prova 973,9520,8720,8218,8018,12
Prova 1073,0821,0921,0018,3718,14
Esecuzione delle prove di compilazione nelle varie configurazioni. Tempi in secondi.
Tempo di build nelle varie configurazioni (minore è meglio)
Webpack 3Webpack 4Yarn 1.22.0Node 12.11.1Node 12.11.1 + Yarn 1.22.0
Media73,9922,5322,3919,7119,47
Media (esclusa prova 0)73,6720,8920,8318,4118,14
*Tempi in secondi

Anche in questo caso il passaggio da Webpack 3 a Webpack 4 si conferma come il miglior investimento per abbattere i tempi di esecuzione della build (circa il 70% in meno).
Contrariamente alla build di development l’accoppiata Webpack 4 + Yarn 1.22.0 non peggiora le performance ma il guadagno di tempo risulta essere praticamente trascurabile (-0,27% escludendo la prova 0). Anche in questo caso l’avanzamento di versione di Node invece permette di migliorare le performance di un ulteriore 10% rispetto ai tempi di Webpack 4.

Anche in questo caso l’aggiornamento combinato di Webapack 4, Node 12.11.1 e Yarn 1.22.0 permette di guadagnare una manciata di secondi sul tempo di build.

Conclusioni

Le prove eseguite sembrano confermare esattamente quanto riportato dalla guida di Webpack. Il miglior investimento possibile per migliorare le performance della build di Webpack è quello di utilizzare sempre la versione più recente del tool.

Una volta aggiornato Webpack all’ultima versione, dovendo scegliere se aggiornare Node o Yarn non c’è dubbio che la scelta migliore sia quella di investire tempo nell’aggiornamento di Node (guadagnando circa un 10% di tempo in meno).

Solo in ultima istanza conviene aggiornare Yarn il cui effetto sui tempi di build risulta essere praticamente trascurabile.

Come ultima nota c’è da considerare che lo sforzo necessario ad ogni aggiornamento è direttamente proporzionale al guadagno ottenuto. Mentre aggiornare Yarn non richiede più di qualche minuto, aggiornare Node e soprattutto Webpack può richiedere più di qualche ora.


Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!

Millewin: estrarre i pazienti con indirizzo email in anagrafica

Time Needed : 5 minutes

Recentemente mi è stato chiesto se fosse possibile estrarre dal database di Millewin tutti i pazienti che avessero un indirizzo email salvato nell'anagrafica. Visto che la query può essere utile a tutti, di seguito ho riportato i passaggi necessari ad effettuare l'estrazione:

  1. Aprire Mille Utilità

    Per poter estrarre i dati dei pazienti con indirizzo email tramite una query SQL la prima cosa da fare è avviare Mille Utilità

  2. Aprire dal menù Statistiche, Impostazione Estrazioni SQL Personali

    Aprire Estrazioni SQL Personali

  3. Aggiungere il codice SQL

    Premendo il pulsante Nuovo creare una nuova estrazione chiamata contatti pazienti e incollare nel campo Comando SQL il codice riportato sotto. Una volta fatto salvare il tutto con il bottone Salva
    Creazione del nuovo comando SQL

  4. Eseguire l'estrazione

    Premere il tasto Applica per eseguire l'estrazione. Il programma chiederà su quali dati eseguire l'estrazione. Selezionare l'intervallo di date di interesse e proseguire con il comando Avanti.
    Si aprirà una nuova schermata da cui è possibile eseguire l'estrazione mediante il pulsante Esegui posto in alto a destra.Confermare l'esecuzione del comando SQL con il pulsante esegui

  5. Salvare i dati in formato Excel

    A questo punto si aprirà una schermata contente i dati dei pazienti che hanno un indirizzo email associato.
    Da questa schermata è anche possibile esportare i dati mediante il pulsante Salva in alto a sinistra. Pulsante di salvataggio su file

Tools
  • Millewin

Di seguito è riportato il codice da inserire nel campo Comando SQL descritto al punto 3:

select
	paz.cognome,
	paz.nome,
	paz.codice_fiscale,
	nos.pa_tel as tel,
	nos.tel_cell as cell,
	nos.email 
from
	pazienti paz left join nos_002 nos on paz.codice = nos.codice
	left join v_utenti med on nos.pa_medi = med.userid 
where 
	med.codice_regionale ilike '%'
	and paz.pa_convenzione = 'S'
	and nos.pa_drevoca IS NULL
	and paz.decesso IS NULL
	and nos.email IS NOT NULL 
order by
	paz.cognome,
	paz.nome;

Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!

Ubuntu 20.04 disponibile al download! 🎉

La mia scrivania

Ubuntu 20.04 Focal Fossa è stato appena rilasciato! Questa è l’ultima versione LTS del famoso sistema operativo open source con supporto fino al 2025.

Bando alle ciance, se non vuoi perdere tempo procedi subito con il download dell’ultima versione tramite il link sottostante:

Novità

Sebbene il rilascio ufficiale sia oggi io è già da un mesetto che lo utilizzo quotidianamente sul mio PC del lavoro senza alcun problema. Per cui di seguito ti mostro le novità dell’ultima fatica di Canonical con qualche commento personale sul mio utilizzo.

NOTA: i miei commenti fanno riferimento al passaggio dalla versione 18.04 alla 20.04. Se hai aggiornato di volta in volta alla 18.10, 19.04 e 19.10 probabilmente avrai già notato alcuni dei cambiamenti che ho riportato.

Iniziamo a parlare dei miglioramenti sotto il cofano. L’ultima versione di Ubuntu utilizza il Kernel 5.4 che, oltre ai soliti miglioramenti alle performance e a migliorare il supporto all’hardware più recente, introduce il supporto nativo ai file system exFAT. Finalmente non sarà più necessario installare pacchetti aggiuntivi per leggere chiavette e memory card.
La mia vecchia guida su come montare i volumi exFat potrà finalmente andare in pensione.

Nonostante il Kernel 5.6 non fosse pronto per il rilascio di Ubuntu, gli sviluppatori di Canonical si sono comunque adoperati per fare il backport di WireGuard anche su Ubuntu 20.04. Per chi non lo conoscesse, WireGuard è un software che permette di connettersi a tunnel VPN senza bisogno di utilizzare tool esterni.

Passiamo ora all’avvio del sistema. Fin dalla pressione del tasto di avvio è possibile accorgersi dei miglioramenti fatti dagli sviluppatori. Infatti è stato introdotto un nuovo splash screen che mostra all’avvio il logo del produttore del computer. Inoltre la velocità di avvio del sistema è stata ulteriormente migliorata grazie all’introduzione di un nuovo algoritmo di compressione (lz4) del kernel e di intramfs.
Sul mio PC Ubuntu ora si avvia veramente in un lampo!

Arrivati alla schermata di accesso del sistema operativo è possibile accorgersi anche di altri piccoli miglioramenti all’usabilità. Innanzitutto non esiste più la “tendina” da trascinare verso l’alto per inserire la password. Gli sviluppatori hanno anche lavorato alla rifinitura della grafica. Ora è possibile vedere dalla schermata di blocco le notifiche arrivate e come background viene utilizzata un versione sfocata dello sfondo del desktop dell’utente.

Inserita la password di accesso, GNOME 3.36 ci accoglie in tutto il suo splendore. Chi proviene da Ubuntu 18.04 apprezzerà fin da subito la maggiore pulizia e la migliore cura dei dettagli nella UI.
Tra i miglioramenti più utili all’usabilità del sistema operativo c’è l’introduzione della modalità non disturbare. Attivando questa modalità tutte le notifiche verranno silenziate. Veramente utilissimo durante le presentazioni e durante le videochiamate di lavoro.

La nuova modalità non disturbare nel centro notifiche

Anche l’app switcher (alt+tab) è stato migliorato. Nella versione precedente di Ubuntu, aprendo due finestre di FireFox queste venivano raggruppate in un unico elemento. Ora invece ogni finestra ha la sua icona nello switcher.
Per me che utilizzo quasi esclusivamente alt-tab per cambiare finestra questa è veramente una manna dal cielo!

Sopra: Il vecchio task switcher che raggruppava i software; Sotto: il nuovo task switcher con un icona per ogni applicazione

Un altro cambiamento è stato fatto all’applicazione Ubuntu Store che è stata rimpiazzato con il più moderno Snap Store. A prima vista potrebbe sembrare quasi la stessa cosa ma a parte il lavoro di bug-fix e di miglioramento generale, il nuovo Snap Store permette di avere delle funzionalità più avanzate (ad esempio è possibile selezionare quale versione del pacchetto installare).

Il nuovo Snap Store permette di selezionare la versione del software installare.

Un altro cambiamento che farà la gioia di chi utilizza monitor 4K è il supporto al fractional scaling. Da ora non sarà più necessario scegliere tra un fattore di scala del 100% o del 200% ma sarà possibile selezionare dei valori intermedi come ad esempio 125% o 150%.

Ma la cosa più bella dell’ultima release di Ubuntu è l’introduzione del tema scuro! Finalmente è possibile modificare con un solo click l’aspetto complessivo del sistema. Da nautilus (per esplorare i file) a gedit (il text editor), dal pannello delle impostazioni a firefox ora tutto il sistema utilizzerà consistentemente i colori scuri.
L’ultima release di Ubuntu è un piacere per gli occhi per me che adoro il tema scuro.

Qualche bug

L’ultima versione di Ubuntu però non è perfetta e nel corso di questo mese ho notato anche qualche bug minore durante il mio utilizzo giornaliero.

Partiamo dal più fastidioso, il tema scuro di gedit rende praticamente illeggibile il testo in quanto, nel momento in cui viene selezionata una riga, questa viene evidenziata di bianco con il testo bianco. L’unica soluzione per aggirare il problema e leggere il testo è selezionare tutto il testo. Speriamo in una patch a breve.

Testo bianco con evidenziazione bianca. Decisamente poco leggibile.

Un’altra piccolezza piuttosto fastidiosa è il fatto che da nautilus non è possibile trascinare con il mouse i file sul desktop. Non capisco se è una scelta di progetto o un bug ma spero che gli sviluppatori di Canonical riescano a risolvere anche questo problema.

Ma il problema più fastidioso è che a volte, quando a fine giornata arresto il sistema, il processo di chiusura del sistema operativo si inchioda ed è necessario attendere diversi minuti prima che si spenga completamente. Sospetto che possa essere un bug legato ai driver proprietari di nvidia ma nulla che non possa essere risolto con una patch.

Ma quindi devo aggiornare?

Secondo me se non fai uso di software particolari puoi aggiornare senza troppi pensieri all’ultima versione per godere di una versione che non rivoluziona il modo di lavoro ma rifinisce vari aspetti del sistema operativo che lo rendono più efficiente e più piacevole da utilizzare.

Se utilizzi un sistema a 32bit tuttavia non potrai aggiornare direttamente ad Ubuntu 20.04 visto che gli sviluppatori hanno deciso di abbandonare questa vecchia architettura per concentrarsi unicamente nello sviluppo del sistema a 64bit.

In ogni caso Ubuntu 18.04 è ancora supportato fino al 2023 per cui se non vuoi rischiare l’aggiornamento o se non sei sicuro che il tuo hardware sia compatibile puoi posporre l’aggiornamento e farlo tranquillamente più avanti nel tempo.


Se questo post ti è stato utile puoi farmelo sapere lasciando un commento qui sotto oppure scrivendomi direttamente a t.me/lorenzomillucci.
Inoltre ti invito ad iscriverti al mio canale Telegram e a seguirmi su Twitter per non perderti nemmeno un post del mio blog. A presto!