Prestazioni web semplificate: edizione Google I/O 2018

Al Google I/O 2018, abbiamo presentato una rassegna di strumenti, librerie e tecniche di ottimizzazione che semplificano il miglioramento delle prestazioni web. Qui li spieghiamo utilizzando l'app The Oodles Theater. Parliamo anche dei nostri esperimenti con il caricamento predittivo e della nuova iniziativa Guess.js.

Ewa Gasperowicz

Nell'ultimo anno ci siamo impegnati molto per capire come rendere il web più veloce e più efficiente. Questo ha portato a nuovi strumenti, approcci e librerie che vorremmo condividere con te in questo articolo. Nella prima parte, ti mostreremo alcune tecniche di ottimizzazione che abbiamo utilizzato in pratica durante lo sviluppo dell'app Oodles Theater. Nella seconda parte, parleremo dei nostri esperimenti con il caricamento predittivo e della nuova iniziativa Guess.js.

La necessità di prestazioni

Internet diventa sempre più pesante ogni anno. Se controlliamo lo stato del web, possiamo vedere che una pagina media su mobile pesa circa 1,5 MB, la maggior parte dei quali è costituita da JavaScript e immagini.

Le dimensioni crescenti dei siti web, insieme ad altri fattori, come la latenza di rete, le limitazioni della CPU, i pattern di blocco del rendering o il codice di terze parti superfluo, contribuiscono a complicare il puzzle delle prestazioni.

La maggior parte degli utenti considera la velocità come l'aspetto più importante della UX. Questo non è troppo sorprendente, perché non puoi fare molto finché una pagina non ha terminato il caricamento. Non puoi trarre valore dalla pagina, non puoi ammirarne l'estetica.

Piramide della gerarchia UX
Fig. 1. Quanto è importante la velocità per gli utenti? (Speed Matters, Vol. 3)

Sappiamo che le prestazioni sono importanti per gli utenti, ma può sembrare un segreto scoprire da dove iniziare l'ottimizzazione. Fortunatamente, esistono strumenti che possono aiutarti in questo percorso.

Lighthouse: una base per il workflow delle prestazioni

Lighthouse fa parte di Chrome DevTools e ti consente di eseguire un controllo del tuo sito web, fornendoti suggerimenti su come migliorarlo.

Di recente abbiamo lanciato una serie di nuovi controlli delle prestazioni che sono davvero utili nel flusso di lavoro di sviluppo quotidiano.

Nuovi controlli Lighthouse
Fig. 2. Nuovi controlli Lighthouse

Vediamo come puoi sfruttarli con un esempio pratico: l'app Oodles Theater. Si tratta di una piccola app web demo, dove puoi provare alcuni dei nostri doodle di Google interattivi preferiti e persino giocare a un paio di giochi.

Durante la creazione dell'app, volevamo assicurarci che fosse il più efficiente possibile. Il punto di partenza per l'ottimizzazione è stato un report Lighthouse.

Report Lighthouse per l'app Oodles
Fig. 3. Report Lighthouse per l'app Oodles

Le prestazioni iniziali della nostra app, come mostrato nel report di Lighthouse, erano piuttosto scarse. Su una rete 3G, l'utente doveva attendere 15 secondi per il First Meaningful Paint o per l'interattività dell'app. Lighthouse ha evidenziato un sacco di problemi con il nostro sito e il punteggio complessivo delle prestazioni di 23 lo rispecchiava esattamente.

La pagina pesava circa 3,4 MB, quindi dovevamo assolutamente ridurre le dimensioni.

È iniziata così la nostra prima sfida di rendimento: trovare elementi che possiamo rimuovere facilmente senza influire sull'esperienza complessiva.

Opportunità di ottimizzazione del rendimento

Rimuovi le risorse non necessarie

Ci sono alcuni elementi ovvi che possono essere rimossi in sicurezza: spazi vuoti e commenti.

Vantaggi della minimizzazione
Fig. 4. Minimizza e comprimi JavaScript e CSS

Lighthouse evidenzia questa opportunità nel controllo CSS e JavaScript non minimizzati. Utilizzavamo webpack per il nostro processo di build, quindi per ottenere la minimizzazione abbiamo semplicemente utilizzato il plug-in Uglify JS.

La minimizzazione è un'attività comune, quindi dovresti essere in grado di trovare una soluzione pronta per qualsiasi processo di build che utilizzi.

Un altro controllo utile in questo ambito è Attiva la compressione del testo. Non c'è motivo di inviare file non compressi e la maggior parte delle CDN supporta questa funzionalità in modo nativo.

Utilizzavamo Firebase Hosting per ospitare il nostro codice e Firebase attiva la compressione gzip per impostazione predefinita, quindi, per il semplice fatto di ospitare il nostro codice su una CDN ragionevole, abbiamo ottenuto questa funzionalità senza costi.

Sebbene gzip sia un modo molto popolare di compressione, anche altri meccanismi come Zopfli e Brotli stanno guadagnando terreno. Brotli è supportato dalla maggior parte dei browser e puoi utilizzare un file binario per precomprimere gli asset prima di inviarli al server.

Utilizza policy relative alla cache efficienti

Il passaggio successivo è stato quello di assicurarci di non inviare risorse due volte se non necessario.

Il controllo Criterio di memorizzazione nella cache inefficiente di Lighthouse ci ha aiutato a capire che potevamo ottimizzare le nostre strategie di memorizzazione nella cache per raggiungere esattamente questo obiettivo. Impostando un'intestazione di scadenza max-age nel nostro server, ci siamo assicurati che, in caso di visite ripetute, l'utente possa riutilizzare le risorse scaricate in precedenza.

Idealmente, dovresti puntare a memorizzare nella cache il maggior numero possibile di risorse nel modo più sicuro possibile per il periodo di tempo più lungo possibile e fornire token di convalida per una riconvalida efficiente delle risorse che sono state aggiornate.

Rimuovi il codice inutilizzato

Finora abbiamo rimosso le parti più ovvie del download non necessario, ma che dire di quelle meno ovvie? Ad esempio, il codice inutilizzato.

Copertura del codice in DevTools
Fig. 5. Controlla la copertura del codice

A volte includiamo nelle nostre app codice che non è realmente necessario. Questo accade soprattutto se lavori alla tua app per un periodo di tempo più lungo, se il tuo team o le tue dipendenze cambiano e, a volte, se una libreria orfana viene lasciata indietro. È esattamente quello che è successo a noi.

All'inizio utilizzavamo la libreria Material Components per creare rapidamente un prototipo della nostra app. Con il tempo siamo passati a un aspetto più personalizzato e ci siamo dimenticati completamente di quella libreria. Fortunatamente, il controllo della copertura del codice ci ha aiutato a ritrovarlo nel nostro bundle.

Puoi controllare le statistiche sulla copertura del codice in DevTools, sia per il runtime che per il tempo di caricamento della tua applicazione. Puoi vedere le due grandi strisce rosse nello screenshot in basso: oltre il 95% del nostro CSS non era utilizzato, così come una grande quantità di JavaScript.

Lighthouse ha rilevato questo problema anche nel controllo delle regole CSS inutilizzate. Mostrava un potenziale risparmio di oltre 400 kB. Quindi siamo tornati al nostro codice e abbiamo rimosso sia la parte JavaScript che quella CSS di quella libreria.

Se eliminiamo l'adattatore MVC, i nostri stili scendono a 10 kB
Fig. 6. Se eliminiamo l'adattatore MVC, i nostri stili scendono a 10 kB.

In questo modo, il nostro bundle CSS è stato ridotto di 20 volte, il che è un ottimo risultato per un commit di due righe.

Ovviamente, il nostro punteggio delle prestazioni è aumentato e anche il Time to Interactive è migliorato molto.

Tuttavia, con modifiche di questo tipo, non è sufficiente controllare solo le metriche e i punteggi. La rimozione del codice effettivo non è mai priva di rischi, quindi devi sempre prestare attenzione a potenziali regressioni.

Il nostro codice non è stato utilizzato nel 95% dei casi, ma c'è ancora questo 5% da qualche parte. A quanto pare, uno dei nostri componenti utilizzava ancora gli stili di quella libreria: le piccole frecce nel dispositivo di scorrimento del doodle. Tuttavia, poiché era così piccolo, abbiamo potuto semplicemente incorporare manualmente questi stili nei pulsanti.

I pulsanti sono stati danneggiati dalla libreria mancante
Fig. 7. Un componente utilizzava ancora la libreria rimossa

Quindi, se rimuovi il codice, assicurati di avere un workflow di test adeguato per proteggerti da potenziali regressioni visive.

Evita payload di rete enormi

Sappiamo che le risorse di grandi dimensioni possono rallentare il caricamento delle pagine web. Possono costare denaro ai nostri utenti e possono avere un grande impatto sui loro piani dati, quindi è molto importante tenerlo presente.

Lighthouse è stato in grado di rilevare un problema con alcuni dei nostri payload di rete utilizzando l'audit Payload di rete enorme.

Rileva payload di rete enormi
Fig. 8. Rileva payload di rete enormi

Qui abbiamo visto che avevamo più di 3 MB di codice da inviare, il che è un bel po', soprattutto sui dispositivi mobili.

In cima a questo elenco, Lighthouse ha evidenziato che avevamo un bundle di fornitori JavaScript con 2 MB di codice non compresso. Questo è anche un problema evidenziato da webpack.

Come si suol dire, la richiesta più veloce è quella che non viene effettuata.

Idealmente, dovresti misurare il valore di ogni singolo asset che fornisci agli utenti, misurare il rendimento di questi asset e decidere se vale la pena includerli nell'esperienza iniziale. perché a volte questi asset possono essere differiti, caricati in modalità lazy o elaborati durante il tempo di inattività.

Nel nostro caso, poiché abbiamo a che fare con molti bundle JavaScript, siamo stati fortunati perché la community JavaScript dispone di un ricco set di strumenti di controllo dei bundle JavaScript.

Controllo dei bundle JavaScript
Fig. 9. Controllo del bundle JavaScript

Abbiamo iniziato con Webpack Bundle Analyzer, che ci ha informato che stavamo includendo una dipendenza chiamata unicode, che era di 1,6 MB di JavaScript analizzato, quindi piuttosto grande.

Siamo poi passati al nostro editor e, utilizzando il plug-in Import Cost per Visual Studio Code, siamo stati in grado di visualizzare il costo di ogni modulo che stavamo importando. In questo modo abbiamo potuto scoprire quale componente includeva il codice che faceva riferimento a questo modulo.

Siamo poi passati a un altro strumento, BundlePhobia. Questo è uno strumento che ti consente di inserire il nome di qualsiasi pacchetto NPM e di vedere effettivamente quali sono le dimensioni stimate della versione minimizzata e compressa con gzip. Abbiamo trovato una buona alternativa per il modulo slug che stavamo utilizzando, che pesava solo 2,2 kB, quindi l'abbiamo sostituito.

Questo ha avuto un grande impatto sul nostro rendimento. Tra questa modifica e la scoperta di altre opportunità per ridurre le dimensioni del nostro bundle JavaScript, abbiamo risparmiato 2,1 MB di codice.

Abbiamo riscontrato un miglioramento complessivo del 65%, una volta prese in considerazione le dimensioni compresse con gzip e minimizzate di questi bundle. Abbiamo scoperto che questo processo era davvero utile.

In generale, quindi, cerca di eliminare i download non necessari nei tuoi siti e nelle tue app. Fare un inventario degli asset e misurare il loro impatto sul rendimento può fare una grande differenza, quindi assicurati di controllare gli asset con una certa regolarità.

Riduci il tempo di avvio di JavaScript con la suddivisione del codice

Sebbene i payload di rete di grandi dimensioni possano avere un impatto significativo sulla nostra app, c'è un altro elemento che può avere un impatto davvero notevole: JavaScript.

JavaScript è la tua risorsa più costosa. Sui dispositivi mobili, se invii bundle di JavaScript di grandi dimensioni, l'interazione degli utenti con i componenti dell'interfaccia utente potrebbe essere ritardata. Ciò significa che potrebbero toccare la UI senza che accada nulla di significativo. Per questo motivo, è importante capire perché JavaScript è così costoso.

Ecco come un browser elabora JavaScript.

Elaborazione di JavaScript
Fig. 10. Elaborazione di JavaScript

Innanzitutto dobbiamo scaricare lo script, abbiamo un motore JavaScript che deve analizzare il codice, compilarlo ed eseguirlo.

Queste fasi non richiedono molto tempo su un dispositivo di fascia alta come un computer desktop o un laptop, forse nemmeno su uno smartphone di fascia alta. Ma su uno smartphone di fascia media questo processo può richiedere da cinque a dieci volte più tempo. Questo è ciò che ritarda l'interattività, quindi è importante cercare di ridurlo.

Per aiutarti a scoprire questi problemi con la tua app, abbiamo introdotto un nuovo controllo del tempo di avvio di JavaScript in Lighthouse.

Tempo di avvio di JavaScript
Fig. 11. Controllo del tempo di avvio di JavaScript

Nel caso dell'app Oodle, ci ha detto che abbiamo impiegato 1,8 secondi per l'avvio di JavaScript. Ciò che accadeva era che importavamo staticamente tutte le nostre route e i nostri componenti in un unico bundle JavaScript monolitico.

Una tecnica per aggirare questo problema è l'utilizzo della suddivisione del codice.

La suddivisione del codice è come la pizza

La suddivisione del codice è questo concetto: invece di dare ai tuoi utenti un'intera pizza di JavaScript, perché non dare loro solo una fetta alla volta quando ne hanno bisogno?

La suddivisione del codice può essere applicata a livello di route o di componente. Funziona perfettamente con React e React Loadable, Vue.js, Angular, Polymer, Preact e molte altre librerie.

Abbiamo incorporato la suddivisione del codice nella nostra applicazione, siamo passati dalle importazioni statiche alle importazioni dinamiche, il che ci ha permesso di caricare il codice in modo asincrono e lento quando ne avevamo bisogno.

Suddivisione del codice con importazioni dinamiche
Fig. 13. Suddivisione del codice con importazioni dinamiche

L'impatto di questa operazione è stato sia la riduzione delle dimensioni dei nostri bundle, sia la riduzione del tempo di avvio di JavaScript. Il tempo è sceso a 0,78 secondi, rendendo l'app più veloce del 56%.

In generale, se stai creando un'esperienza con un uso intensivo di JavaScript, assicurati di inviare all'utente solo il codice di cui ha bisogno.

Sfrutta concetti come la suddivisione del codice, esplora idee come il tree shaking e dai un'occhiata al repository webpack-libs-optimizations per trovare alcune idee su come ridurre le dimensioni della libreria se utilizzi webpack.

Ottimizza immagini

Battuta sulle prestazioni di caricamento delle immagini

Nell'app Oodle utilizziamo molte immagini. Purtroppo, Lighthouse era molto meno entusiasta di noi. In effetti, non abbiamo superato tutti e tre i controlli relativi alle immagini.

Abbiamo dimenticato di ottimizzare le immagini, non le abbiamo ridimensionate correttamente e potremmo anche trarre vantaggio dall'utilizzo di altri formati dell'immagine.

Controlli delle immagini
Fig. 14. Controlli delle immagini Lighthouse

Abbiamo iniziato ottimizzando le nostre immagini.

Per un ciclo di ottimizzazione una tantum, puoi utilizzare strumenti visivi come ImageOptim o XNConvert.

Un approccio più automatizzato consiste nell'aggiungere un passaggio di ottimizzazione delle immagini al processo di build, con librerie come imagemin.

In questo modo, ti assicuri che le immagini aggiunte in futuro vengano ottimizzate automaticamente. Alcune CDN, ad esempio Akamai o soluzioni di terze parti come Cloudinary, Fastly o Uploadcare, offrono soluzioni complete per l'ottimizzazione delle immagini, quindi puoi anche semplicemente ospitare le tue immagini su questi servizi.

Se non vuoi farlo a causa dei costi o di problemi di latenza, progetti come Thumbor o Imageflow offrono alternative self-hosted.

Prima e dopo l'ottimizzazione
Fig. 15. Prima e dopo l'ottimizzazione

Il nostro PNG di sfondo è stato segnalato in webpack come grande, e giustamente. Dopo averlo ridimensionato correttamente in base alla viewport ed eseguito tramite ImageOptim, siamo scesi a 100 kB, un valore accettabile.

Ripetendo questa operazione per più immagini sul nostro sito, siamo riusciti a ridurre in modo significativo il peso complessivo della pagina.

Utilizza il formato giusto per i contenuti animati

Le GIF possono essere molto costose. Sorprendentemente, il formato GIF non è mai stato concepito come una piattaforma di animazione. Pertanto, il passaggio a un formato video più adatto ti consente di risparmiare molto in termini di dimensioni del file.

Nell'app Oodle, utilizzavamo una GIF come sequenza introduttiva nella home page. Secondo Lighthouse, potremmo risparmiare oltre 7 MB passando a un formato video più efficiente. Il nostro clip pesava circa 7,3 MB, decisamente troppo per qualsiasi sito web ragionevole, quindi lo abbiamo trasformato in un elemento video con due file di origine: un MP4 e un WebM per un supporto più ampio del browser.

Sostituisci le GIF animate con i video
Fig. 16. Sostituisci le GIF animate con i video

Abbiamo utilizzato lo strumento FFmpeg per convertire la nostra GIF animata nel file mp4. Il formato WebM offre un risparmio ancora maggiore: l'API ImageOptim può eseguire questa conversione per te.

ffmpeg -i animation.gif -b:v 0 -crf 40 -vf scale=600:-1 video.mp4

Grazie a questa conversione, siamo riusciti a risparmiare oltre l'80% del nostro peso complessivo. In questo modo, abbiamo ridotto le dimensioni a circa 1 MB.

Tuttavia, 1 MB è una risorsa di grandi dimensioni da inviare, soprattutto per un utente con una larghezza di banda limitata. Fortunatamente, abbiamo potuto utilizzare l'API Effective Type per capire che la larghezza di banda era ridotta e fornire un JPEG molto più piccolo.

Questa interfaccia utilizza i valori effettivi di tempo di round trip e download per stimare il tipo di rete utilizzato dall'utente. Restituisce semplicemente una stringa: 2G lento, 2G, 3G o 4G. Quindi, a seconda di questo valore, se l'utente ha una connessione inferiore al 4G, possiamo sostituire l'elemento video con l'immagine.

if (navigator.connection.effectiveType) { ... }

Questo riduce un po' l'esperienza, ma almeno il sito è utilizzabile su una connessione lenta.

Immagini fuori schermo con caricamento lento

I caroselli, gli slider o le pagine molto lunghe spesso caricano le immagini, anche se l'utente non può vederle immediatamente sulla pagina.

Lighthouse segnalerà questo comportamento nel controllo delle immagini fuori schermo, che puoi anche vedere nel riquadro Rete di DevTools. Se vedi molte immagini in arrivo, ma solo alcune sono visibili sulla pagina, significa che potresti prendere in considerazione l'idea di caricarle con il caricamento lento.

Il caricamento lento non è ancora supportato in modo nativo nel browser, quindi dobbiamo utilizzare JavaScript per aggiungere questa funzionalità. Abbiamo utilizzato la libreria Lazysizes per aggiungere il comportamento di caricamento lento alle nostre copertine Oodle.

<!-- Import library -->
import lazysizes from 'lazysizes'  <!-- or -->
<script src="lazysizes.min.js"></script>

<!-- Use it -->

<img data-src="image.jpg" class="lazyload"/>
<img class="lazyload"
    data-sizes="auto"
    data-src="image2.jpg"
    data-srcset="image1.jpg 300w,
    image2.jpg 600w,
    image3.jpg 900w"/>

Lazysizes è intelligente perché non solo monitora le modifiche alla visibilità dell'elemento, ma precarica anche in modo proattivo gli elementi vicini alla visualizzazione per un'esperienza utente ottimale. Offre inoltre un'integrazione facoltativa di IntersectionObserver, che ti offre ricerche di visibilità molto efficienti.

Dopo questa modifica, le nostre immagini vengono recuperate on demand. Se vuoi approfondire l'argomento, consulta images.guide, una risorsa molto utile e completa.

Aiuta il browser a fornire in anticipo le risorse critiche

Non tutti i byte inviati al browser hanno lo stesso grado di importanza e il browser lo sa. Molti browser utilizzano l'euristica per decidere cosa recuperare per primo. A volte, quindi, recuperano il CSS prima delle immagini o degli script.

Un'opzione utile potrebbe essere quella di informare il browser, in qualità di autori della pagina, su ciò che è effettivamente importante per noi. Fortunatamente, negli ultimi due anni i fornitori di browser hanno aggiunto una serie di funzionalità per aiutarci in questo, ad esempio suggerimenti per le risorse come link rel=preconnect, preload o prefetch.

Queste funzionalità introdotte nella piattaforma web aiutano il browser a recuperare l'elemento giusto al momento giusto e possono essere un po' più efficienti di alcuni approcci basati sulla logica di caricamento personalizzata che vengono eseguiti utilizzando lo script.

Vediamo come Lighthouse ci guida nell'utilizzo efficace di alcune di queste funzionalità.

La prima cosa che Lighthouse ci dice di fare è evitare più andate e ritorno costosi verso qualsiasi origine.

Evita più andate e ritorno costosi verso qualsiasi luogo di partenza
Fig. 17. Evita più viaggi di andata e ritorno costosi verso qualsiasi luogo di partenza

Nel caso dell'app Oodle, utilizziamo molto Google Fonts. Ogni volta che inserisci un foglio di stile di Google Fonts nella tua pagina, questo si connetterà a un massimo di due sottodomini. Lighthouse ci dice che se fossimo in grado di riscaldare la connessione, potremmo risparmiare fino a 300 millisecondi nel tempo di connessione iniziale.

Sfruttando link rel preconnect, possiamo mascherare efficacemente la latenza di connessione.

Questo può avere un impatto molto significativo, soprattutto con un servizio come Google Fonts, in cui il CSS del carattere è ospitato su googleapis.com e le risorse dei caratteri sono ospitate su Gstatic. Abbiamo quindi applicato questa ottimizzazione e abbiamo ridotto il tempo di qualche centinaio di millisecondi.

Il prossimo suggerimento di Lighthouse è di precaricare le richieste chiave.

Precarica le richieste principali
Fig. 18. Precarica le richieste chiave

<link rel=preload> è davvero potente, informa il browser che una risorsa è necessaria nell'ambito della navigazione corrente e tenta di fare in modo che il browser la recuperi il prima possibile.

In questo caso, Lighthouse ci dice che dovremmo precaricare le risorse dei web font principali, perché stiamo caricando due web font.

Il precaricamento di un web font è simile a questo: specificando rel=preload, passi as con il tipo di carattere e poi specifichi il tipo di carattere che stai tentando di caricare, ad esempio woff2.

L'impatto che questo può avere sulla tua pagina è piuttosto evidente.

Impatto del precaricamento delle risorse
Fig. 19. Impatto del precaricamento delle risorse

In genere, senza utilizzare link rel preload, se i web font sono fondamentali per la tua pagina, il browser deve prima recuperare l'HTML, analizzare il CSS e, solo molto più tardi, recuperare i web font.

Utilizzando link rel preload, non appena il browser ha analizzato l'HTML, può iniziare a recuperare i web font molto prima. Nel caso della nostra app, questo ha permesso di ridurre di un secondo il tempo necessario per eseguire il rendering del testo utilizzando i nostri web font.

Non è così semplice se provi a precaricare i caratteri utilizzando Google Fonts, c'è un problema.

Gli URL di Google Fonts che specifichiamo nei font-face dei nostri fogli di stile vengono aggiornati abbastanza regolarmente dal team di Fonts. Questi URL possono scadere o essere aggiornati regolarmente, quindi se vuoi avere il controllo completo sull'esperienza di caricamento dei caratteri, ti consigliamo di ospitare autonomamente i tuoi caratteri web. Questo può essere un vantaggio perché ti dà accesso a elementi come link rel preload.

Nel nostro caso, abbiamo trovato lo strumento Google Web Fonts Helper davvero utile per aiutarci a mettere offline alcuni di questi web font e configurarli localmente, quindi date un'occhiata a questo strumento.

Che tu stia utilizzando i web font come parte delle tue risorse critiche o che si tratti di JavaScript, prova ad aiutare il browser a fornire le risorse critiche il prima possibile.

Sperimentale: Priority Hints

Oggi abbiamo qualcosa di speciale da condividere con te. Oltre a funzionalità come i suggerimenti per le risorse e il precaricamento, abbiamo lavorato a una nuova funzionalità sperimentale del browser che chiamiamo suggerimenti di priorità.

Imposta la priorità per i contenuti inizialmente visibili
Fig. 20. Suggerimenti di priorità

Si tratta di una nuova funzionalità che ti consente di suggerire al browser l'importanza di una risorsa. Espone un nuovo attributo, importance, con i valori low, high o auto.

In questo modo possiamo indicare di abbassare la priorità delle risorse meno importanti, come stili, immagini o chiamate API di recupero non critiche, per ridurre la contesa. Possiamo anche aumentare la priorità di elementi più importanti, come le immagini hero.

Nel caso della nostra app Oodle, questo ci ha portato a un punto pratico in cui potevamo ottimizzare.

Imposta la priorità per i contenuti inizialmente visibili
Fig. 21. Imposta la priorità per i contenuti inizialmente visibili

Prima di aggiungere il caricamento lento alle nostre immagini, il browser eseguiva questa operazione: avevamo questo carosello di immagini con tutti i nostri doodle e il browser recuperava tutte le immagini all'inizio del carosello con una priorità elevata. Purtroppo, le immagini al centro del carosello erano le più importanti per l'utente. Quindi, abbiamo impostato l'importanza di queste immagini di sfondo su un valore molto basso e quella delle immagini in primo piano su un valore molto alto. Questo ha avuto un impatto di due secondi su una connessione 3G lenta e sulla velocità con cui siamo stati in grado di recuperare ed eseguire il rendering di queste immagini. Quindi un'esperienza positiva.

Ci auguriamo di rendere disponibile questa funzionalità in Canary tra qualche settimana, quindi non perderti le prossime novità.

Adotta una strategia di caricamento dei caratteri web

La tipografia è fondamentale per un buon design e, se utilizzi i web font, l'ideale è non bloccare il rendering del testo e, soprattutto, non mostrare testo invisibile.

Ora lo evidenziamo in Lighthouse con il controllo Evita il testo invisibile durante il caricamento dei caratteri web.

Evita il testo invisibile durante il caricamento dei caratteri web
Fig. 22. Evita il testo invisibile durante il caricamento dei caratteri web

Se carichi i web font utilizzando un blocco font-face, lasci che sia il browser a decidere cosa fare se il recupero del web font richiede molto tempo. Alcuni browser attendono fino a tre secondi prima di tornare a un carattere di sistema e, una volta scaricato, lo sostituiscono con il carattere.

Stiamo cercando di evitare questo testo invisibile, quindi in questo caso non saremmo stati in grado di vedere i doodle classici di questa settimana se il web font avesse impiegato troppo tempo. Fortunatamente, con una nuova funzionalità chiamata font-display, hai un controllo molto maggiore su questo processo.

    @font-face {
      font-family: 'Montserrat';
      font-style: normal;
      font-display: swap;
      font-weight: 400;
      src: local('Montserrat Regular'), local('Montserrat-Regular'),
          /* Chrome 26+, Opera 23+, Firefox 39+ */
          url('montserrat-v12-latin-regular.woff2') format('woff2'),
            /* Chrome 6+, Firefox 3.6+, IE 9+, Safari 5.1+ */
          url('montserrat-v12-latin-regular.woff') format('woff');
    }

La visualizzazione dei caratteri ti aiuta a decidere come eseguire il rendering o il fallback dei caratteri web in base al tempo necessario per lo scambio.

In questo caso, utilizziamo font-display: swap. Swap assegna al carattere un periodo di blocco di zero secondi e un periodo di scambio infinito. Ciò significa che il browser disegnerà il testo quasi immediatamente con un carattere di riserva se il carattere impiega un po' di tempo per caricarsi. e lo scambia non appena il carattere è disponibile.

Nel caso della nostra app, questo è stato fantastico perché ci ha permesso di visualizzare un testo significativo molto presto e di passare al web font una volta pronto.

Risultato della visualizzazione del carattere
Fig. 23. Risultato della visualizzazione dei caratteri

In generale, se utilizzi i caratteri web, come fa una grande percentuale del web, adotta una buona strategia di caricamento dei caratteri web.

Esistono molte funzionalità della piattaforma web che puoi utilizzare per ottimizzare l'esperienza di caricamento dei caratteri, ma dai un'occhiata anche al repository Web Font Recipes di Zach Leatherman, perché è davvero fantastico.

Riduci gli script che bloccano la visualizzazione

Ci sono altre parti della nostra applicazione che potremmo spostare prima nella catena di download per fornire almeno un'esperienza utente di base un po' prima.

Nella sequenza temporale di Lighthouse puoi vedere che durante questi primi secondi, quando tutte le risorse vengono caricate, l'utente non può vedere alcun contenuto.

Opportunità di riduzione dei fogli di stile che bloccano la visualizzazione
Fig. 24. Opportunità di riduzione dei fogli di stile che bloccano il rendering

Il download e l'elaborazione dei fogli di stile esterni impediscono al nostro processo di rendering di fare progressi.

Possiamo provare a ottimizzare il nostro percorso di rendering critico fornendo alcuni degli stili un po' prima.

Se estraiamo gli stili responsabili di questo rendering iniziale e li inseriamo nel nostro codice HTML, il browser è in grado di eseguirne il rendering immediatamente senza attendere l'arrivo dei fogli di stile esterni.

Nel nostro caso, abbiamo utilizzato un modulo NPM chiamato Critical per incorporare i contenuti critici in index.html durante un passaggio di build.

Sebbene questo modulo abbia svolto la maggior parte del lavoro per noi, è stato comunque un po' difficile farlo funzionare senza problemi su percorsi diversi.

Se non presti attenzione o se la struttura del tuo sito è molto complessa, potrebbe essere molto difficile introdurre questo tipo di pattern se non hai pianificato l'architettura della shell dell'applicazione fin dall'inizio.

Ecco perché è così importante tenere conto delle prestazioni fin dall'inizio. Se non progetti per le prestazioni fin dall'inizio, è molto probabile che tu riscontri problemi in un secondo momento.

Alla fine il nostro rischio è stato ripagato, siamo riusciti a far funzionare il tutto e l'app ha iniziato a pubblicare i contenuti molto prima, migliorando notevolmente il tempo di First Meaningful Paint.

Il risultato

Abbiamo applicato un lungo elenco di ottimizzazioni delle prestazioni al nostro sito. Diamo un'occhiata al risultato. Ecco come la nostra app è stata caricata su un dispositivo mobile di medie dimensioni su una rete 3G, prima e dopo l'ottimizzazione.

Il punteggio di rendimento di Lighthouse è passato da 23 a 91. Si tratta di un ottimo progresso in termini di velocità. Tutte le modifiche sono state apportate controllando e seguendo continuamente il report di Lighthouse. Se vuoi scoprire come abbiamo implementato tecnicamente tutti i miglioramenti, dai un'occhiata al nostro repository, in particolare alle PR che sono state inserite.

Prestazioni predittive: esperienze utente basate sui dati

Riteniamo che il machine learning rappresenti un'opportunità entusiasmante per il futuro in molti settori. Un'idea che speriamo possa stimolare ulteriori sperimentazioni in futuro è che i dati reali possono davvero guidare le esperienze utente che stiamo creando.

Oggi prendiamo molte decisioni arbitrarie su ciò che l'utente potrebbe volere o di cui potrebbe aver bisogno e, di conseguenza, su ciò che vale la pena precaricare, precaricare o pre-memorizzare nella cache. Se indoviniamo, siamo in grado di dare la priorità a una piccola quantità di risorse, ma è davvero difficile applicare questa strategia all'intero sito web.

In realtà, oggi abbiamo a disposizione dati che ci consentono di ottimizzare meglio le nostre campagne. Utilizzando l'API Analytics Reporting di Google, possiamo esaminare la pagina principale successiva e le percentuali di uscita per qualsiasi URL del nostro sito e, di conseguenza, trarre conclusioni su quali risorse dovremmo dare la priorità.

Se combiniamo questo con un buon modello di probabilità, evitiamo di sprecare i dati dell'utente con un precaricamento eccessivo dei contenuti. Possiamo sfruttare i dati di Google Analytics e utilizzare il machine learning e modelli come le catene di Markov o la rete neurale per implementare questi modelli.

Bundling basato sui dati per le app web
Fig. 25. Data-driven Bundling for Web Apps

Per facilitare questi esperimenti, siamo lieti di annunciare una nuova iniziativa che chiamiamo Guess.js.

Guess.js
Fig. 26. Guess.js

Guess.js è un progetto incentrato sulle esperienze utente basate sui dati per il web. Ci auguriamo che questo vi ispiri a esplorare l'utilizzo dei dati per migliorare le prestazioni web e non solo. È tutto open source e disponibile su GitHub oggi stesso. È stato creato in collaborazione con la community open source da Minko Gechev, Kyle Matthews di Gatsby, Katie Hempenius e molti altri.

Dai un'occhiata a Guess.js e facci sapere cosa ne pensi.

Riepilogo

I punteggi e le metriche sono utili per migliorare la velocità del web, ma sono solo i mezzi, non gli obiettivi stessi.

A tutti è capitato di riscontrare caricamenti lenti delle pagine quando si è in viaggio, ma ora abbiamo l'opportunità di offrire ai nostri utenti esperienze più piacevoli che si caricano molto rapidamente.

Migliorare il rendimento è un percorso. Tante piccole modifiche possono portare a grandi risultati. Utilizzando gli strumenti di ottimizzazione giusti e tenendo d'occhio i report di Lighthouse, puoi offrire un'esperienza migliore e più inclusiva ai tuoi utenti.

Un ringraziamento speciale a: Ward Peeters, Minko Gechev, Kyle Mathews, Katie Hempenius, Dom Farolino, Yoav Weiss, Susie Lu, Yusuke Utsunomiya, Tom Ankers, Lighthouse e doodle di Google.