Methoden, um das Laden einer Webanwendung auch auf einem einfachen Smartphone zu beschleunigen

Wie wir Codeaufteilung, Code-Inlining und serverseitiges Rendering in PROXX verwendet haben.

Auf der Google I/O 2019 haben Mariko, Jake und ich PROXX veröffentlicht, einen modernen Minesweeper-Klon für das Web. PROXX zeichnet sich durch die Berücksichtigung von Bedienungshilfen aus (es kann mit einem Screenreader gespielt werden) und läuft auf einem Feature-Phone genauso gut wie auf einem High-End-Desktop-Gerät. Feature-Phones sind in mehrfacher Hinsicht eingeschränkt:

  • Schwache CPUs
  • Schwache oder nicht vorhandene GPUs
  • Kleine Bildschirme ohne Eingabe per Berührung
  • Sehr begrenzte Arbeitsspeichermenge

Sie haben jedoch einen modernen Browser und sind sehr erschwinglich. Aus diesem Grund erleben Feature-Phones in Schwellenmärkten ein Comeback. Der Preispunkt ermöglicht es einer ganz neuen Zielgruppe, die sich das vorher nicht leisten konnte, online zu gehen und das moderne Web zu nutzen. Für 2019 wird prognostiziert, dass allein in Indien rund 400 Millionen Feature-Phones verkauft werden. Nutzer von Feature-Phones könnten also einen erheblichen Teil Ihrer Zielgruppe ausmachen. Außerdem sind in Schwellenmärkten Verbindungsgeschwindigkeiten wie bei 2G die Norm. Wie haben wir es geschafft, dass PROXX auf Feature-Phones gut funktioniert?

PROXX-Gameplay.

Die Leistung ist wichtig, und das gilt sowohl für die Ladeleistung als auch für die Laufzeitleistung. Es hat sich gezeigt, dass eine gute Leistung mit einer höheren Nutzerbindung, besseren Conversions und vor allem einer höheren Inklusivität korreliert. Jeremy Wagner hat viele weitere Daten und Informationen dazu, warum die Leistung wichtig ist.

Dies ist Teil 1 einer zweiteiligen Serie. In Teil 1 geht es um die Ladeleistung und in Teil 2 um die Laufzeitleistung.

Status quo erfassen

Es ist wichtig, die Ladeleistung auf einem echten Gerät zu testen. Wenn Sie kein echtes Gerät zur Hand haben, empfehle ich WebPageTest, insbesondere die einfache Einrichtung. WPT führt eine Reihe von Ladetests auf einem echten Gerät mit einer emulierten 3G-Verbindung durch.

3G ist eine gute Geschwindigkeit für die Messung. Auch wenn Sie vielleicht an 4G, LTE oder bald sogar 5G gewöhnt sind, sieht die Realität des mobilen Internets ganz anders aus. Vielleicht sind Sie im Zug, auf einer Konferenz, bei einem Konzert oder im Flugzeug. Dort ist die Verbindung wahrscheinlich eher mit 3G vergleichbar und manchmal sogar noch schlechter.

In diesem Artikel konzentrieren wir uns jedoch auf 2G, da PROXX explizit auf Feature-Phones und Schwellenmärkte in seiner Zielgruppe ausgerichtet ist. Nachdem WebPageTest den Test ausgeführt hat, erhalten Sie ein Wasserfalldiagramm (ähnlich dem, das Sie in den DevTools sehen) sowie einen Filmstreifen oben. Der Filmstreifen zeigt, was der Nutzer sieht, während die App geladen wird. Bei 2G ist das Laden der nicht optimierten Version von PROXX ziemlich schlecht:

Das Filmstreifenvideo zeigt, was der Nutzer sieht, wenn PROXX auf einem echten Low-End-Gerät über eine emulierte 2G-Verbindung geladen wird.

Wenn die Seite über 3G geladen wird, sieht der Nutzer 4 Sekunden lang nur eine weiße Fläche. Bei 2G sieht der Nutzer über 8 Sekunden lang überhaupt nichts. Wenn Sie den Artikel Warum die Leistung wichtig ist gelesen haben, wissen Sie, dass wir jetzt einen großen Teil unserer potenziellen Nutzer aufgrund von Ungeduld verloren haben. Der Nutzer muss alle 62 KB JavaScript herunterladen, damit etwas auf dem Bildschirm angezeigt wird. Der Vorteil in diesem Szenario ist, dass alles, was auf dem Bildschirm angezeigt wird, auch interaktiv ist. Oder vielleicht doch?

Der [First Meaningful Paint][FMP] in der nicht optimierten Version von PROXX ist _technisch_ [interaktiv][TTI], aber für den Nutzer nutzlos.

Nachdem etwa 62 KB gzip-komprimiertes JS heruntergeladen und das DOM generiert wurde, wird die App angezeigt. Sie ist technisch interaktiv. Die Grafik zeigt jedoch ein anderes Bild. Die Webschriftarten werden noch im Hintergrund geladen und bis sie bereit sind, kann der Nutzer keinen Text sehen. Dieser Zustand gilt zwar als Inhalte weitgehend gezeichnet (FMP), aber sicherlich nicht als interaktiv, da der Nutzer nicht erkennen kann, worum es bei den Eingaben geht. Bei 3G dauert es eine weitere Sekunde und bei 2G drei Sekunden, bis die App einsatzbereit ist. Insgesamt dauert es bei 3G sechs Sekunden und bei 2G elf Sekunden, bis die App interaktiv wird.

Wasserfallanalyse

Nachdem wir nun wissen, was die Nutzer sehen, müssen wir das Warum herausfinden. Dazu können wir uns das Wasserfalldiagramm ansehen und analysieren, warum Ressourcen zu spät geladen werden. In unserem 2G-Trace für PROXX sehen wir zwei wichtige Warnsignale:

  1. Es gibt mehrere dünne, bunte Linien.
  2. JavaScript-Dateien bilden eine Kette. Beispielsweise wird die zweite Ressource erst geladen, wenn die erste Ressource fertig ist, und die dritte Ressource erst, wenn die zweite Ressource fertig ist.
Das Wasserfalldiagramm zeigt, welche Ressourcen wann geladen werden und wie lange das dauert.

Anzahl der Verbindungen reduzieren

Jede dünne Linie (dns, connect, ssl) steht für die Erstellung einer neuen HTTP-Verbindung. Das Einrichten einer neuen Verbindung ist kostspielig, da es bei 3G etwa 1 Sekunde und bei 2G etwa 2,5 Sekunden dauert. In unserem Wasserfalldiagramm sehen wir eine neue Verbindung für:

  • Anfrage 1: Unsere index.html
  • Anfrage 5: Die Schriftarten von fonts.googleapis.com
  • Anfrage 8: Google Analytics
  • Anfrage 9: Eine Schriftartdatei von fonts.gstatic.com
  • Anfrage 14: Das Web-App-Manifest

Die neue Verbindung für index.html ist unvermeidlich. Der Browser muss eine Verbindung zu unserem Server herstellen, um die Inhalte abzurufen. Die neue Verbindung für Google Analytics könnte vermieden werden, indem etwas wie Minimal Analytics inline eingebunden wird. Google Analytics verhindert jedoch nicht, dass unsere App gerendert oder interaktiv wird. Daher ist es uns nicht so wichtig, wie schnell sie geladen wird. Idealerweise sollte Google Analytics in der Leerlaufzeit geladen werden, wenn alles andere bereits geladen wurde. So werden beim ersten Laden keine Bandbreite oder Rechenleistung beansprucht. Die neue Verbindung für das Web-App-Manifest wird durch die Fetch-Spezifikation vorgeschrieben, da das Manifest über eine Verbindung ohne Anmeldedaten geladen werden muss. Auch hier gilt: Das Web-App-Manifest verhindert nicht, dass unsere App gerendert oder interaktiv wird. Wir müssen uns also nicht allzu viele Gedanken machen.

Die beiden Schriftarten und ihre Stile sind jedoch ein Problem, da sie das Rendering und die Interaktivität blockieren. Wenn wir uns das von fonts.googleapis.com bereitgestellte CSS ansehen, sehen wir nur zwei @font-face-Regeln, eine für jede Schriftart. Die Schriftstile sind so klein, dass wir uns entschieden haben, sie in unseren HTML-Code einzufügen und so eine unnötige Verbindung zu entfernen. Um die Kosten für den Verbindungsaufbau für die Schriftartdateien zu vermeiden, können wir sie auf unseren eigenen Server kopieren.

Ladevorgänge parallelisieren

Im Wasserfalldiagramm sehen wir, dass nach dem Laden der ersten JavaScript-Datei sofort neue Dateien geladen werden. Dies ist typisch für Modulabhängigkeiten. Unser Hauptmodul hat wahrscheinlich statische Importe, sodass das JavaScript erst ausgeführt werden kann, wenn diese Importe geladen sind. Wichtig ist hierbei, dass diese Arten von Abhängigkeiten zur Build-Zeit bekannt sind. Wir können <link rel="preload">-Tags verwenden, um dafür zu sorgen, dass alle Abhängigkeiten geladen werden, sobald wir unser HTML erhalten.

Ergebnisse

Sehen wir uns an, was wir mit unseren Änderungen erreicht haben. Es ist wichtig, keine anderen Variablen in unserem Test-Setup zu ändern, die die Ergebnisse verfälschen könnten. Daher verwenden wir für den Rest dieses Artikels das einfache Setup von WebPageTest und sehen uns den Filmstreifen an:

Wir verwenden den Filmstreifen von WebPageTest, um zu sehen, was unsere Änderungen bewirkt haben.

Durch diese Änderungen wurde die TTI von 11 auf 8,5 reduziert, was in etwa den 2,5 Sekunden Verbindungsaufbauzeit entspricht, die wir entfernen wollten. Gut gemacht.

Pre-Rendering

Wir haben zwar die TTI reduziert, aber den ewig langen weißen Bildschirm, den der Nutzer 8,5 Sekunden lang ertragen muss, haben wir nicht wirklich beeinflusst. Die wohl größten Verbesserungen für den FMP lassen sich erzielen, indem Sie formatiertes Markup in Ihrem index.html senden. Gängige Techniken hierfür sind Prerendering und serverseitiges Rendering, die eng miteinander verwandt sind und unter Rendering im Web erläutert werden. Bei beiden Techniken wird die Web-App in Node ausgeführt und das resultierende DOM in HTML serialisiert. Beim serverseitigen Rendering geschieht dies pro Anfrage auf der Serverseite, während beim Prerendering dies zur Build-Zeit geschieht und die Ausgabe als neue index.html gespeichert wird. Da PROXX eine JAMStack-App ist und keine Serverseite hat, haben wir uns für das Prerendering entschieden.

Es gibt viele Möglichkeiten, einen Prerenderer zu implementieren. Für PROXX haben wir uns für Puppeteer entschieden. Damit wird Chrome ohne Benutzeroberfläche gestartet und die Instanz kann über eine Node API ferngesteuert werden. Wir verwenden es, um unser Markup und JavaScript einzufügen und dann das DOM als HTML-String zurückzulesen. Da wir CSS-Module verwenden, werden die benötigten Stile automatisch inline eingebunden.

  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.setContent(rawIndexHTML);
  await page.evaluate(codeToRun);
  const renderedHTML = await page.content();
  browser.close();
  await writeFile("index.html", renderedHTML);

Dadurch können wir eine Verbesserung unseres FMP erwarten. Wir müssen immer noch dieselbe Menge an JavaScript wie zuvor laden und ausführen, daher sollten wir nicht erwarten, dass sich die TTI stark ändert. Wenn überhaupt, ist unser index.html größer geworden und könnte die TTI etwas verzögern. Es gibt nur eine Möglichkeit, das herauszufinden: WebPageTest ausführen.

Der Filmstreifen zeigt eine deutliche Verbesserung unseres FMP-Messwerts. Die TTI ist weitgehend unbeeinflusst.

Die Zeit bis zum ersten sinnvollen Zeichnen hat sich von 8,5 Sekunden auf 4,9 Sekunden verkürzt – eine enorme Verbesserung. Die TTI liegt immer noch bei etwa 8,5 Sekunden und ist von dieser Änderung weitgehend unberührt geblieben. Wir haben hier eine wahrnehmungsbezogene Änderung vorgenommen. Manche würden es sogar als Zaubertrick bezeichnen. Durch das Rendern einer Zwischenansicht des Spiels wird die wahrgenommene Ladeleistung verbessert.

Inlining

Ein weiterer Messwert, den sowohl DevTools als auch WebPageTest liefern, ist Time To First Byte (TTFB). Dies ist die Zeit, die vom Senden des ersten Bytes der Anfrage bis zum Empfang des ersten Bytes der Antwort vergeht. Diese Zeit wird auch oft als Umlaufzeit (Round Trip Time, RTT) bezeichnet, obwohl es technisch gesehen einen Unterschied zwischen diesen beiden Zahlen gibt: Die RTT umfasst nicht die Verarbeitungszeit der Anfrage auf der Serverseite. DevTools und WebPageTest visualisieren die TTFB mit einer hellen Farbe im Anfrage-/Antwortblock.

Der helle Abschnitt einer Anfrage bedeutet, dass die Anfrage auf das erste Byte der Antwort wartet.

Wenn wir uns das Wasserfalldiagramm ansehen, stellen wir fest, dass alle Anfragen die meiste Zeit damit verbringen, auf das erste Byte der Antwort zu warten.

Dieses Problem war der Grund, warum HTTP/2-Push ursprünglich entwickelt wurde. Der App-Entwickler weiß, dass bestimmte Ressourcen benötigt werden, und kann sie übertragen. Wenn der Client feststellt, dass er zusätzliche Ressourcen abrufen muss, befinden sich diese bereits im Cache des Browsers. HTTP/2-Push hat sich als zu schwierig erwiesen und wird nicht empfohlen. Dieses Problem wird bei der Standardisierung von HTTP/3 noch einmal aufgegriffen. Derzeit ist die einfachste Lösung, alle kritischen Ressourcen inline einzufügen, was jedoch die Caching-Effizienz beeinträchtigt.

Unser kritisches CSS ist dank CSS-Modulen und unserem Puppeteer-basierten Prerenderer bereits inline eingebunden. Für JavaScript müssen wir unsere kritischen Module und ihre Abhängigkeiten inline einbinden. Der Schwierigkeitsgrad dieser Aufgabe hängt vom verwendeten Bundler ab.

Durch das Inlining unseres JavaScript-Codes haben wir die TTI von 8,5 Sekunden auf 7,2 Sekunden reduziert.

Dadurch wurde die TTI um 1 Sekunde verkürzt. Wir haben jetzt den Punkt erreicht, an dem unser index.html alles enthält, was für das erste Rendern und die Interaktivität erforderlich ist. Das HTML kann gerendert werden, während es noch heruntergeladen wird, wodurch der FMP erstellt wird. Sobald das HTML geparst und ausgeführt wurde, ist die App interaktiv.

Aggressive Codeaufteilung

Ja, unser index.html enthält alles, was für die Interaktivität erforderlich ist. Bei genauerem Hinsehen stellt sich jedoch heraus, dass es auch alles andere enthält. Unsere index.html ist etwa 43 KB groß. Setzen wir das in Beziehung zu dem, womit der Nutzer zu Beginn interagieren kann: Wir haben ein Formular zum Konfigurieren des Spiels mit einigen Komponenten, eine Startschaltfläche und wahrscheinlich etwas Code zum Speichern und Laden von Nutzereinstellungen. Das ist im Grunde alles. 43 KB scheinen viel zu sein.

Die Landingpage von PROXX. Hier werden nur kritische Komponenten verwendet.

Um herauszufinden, woher die Bundle-Größe kommt, können wir einen Source Map Explorer oder ein ähnliches Tool verwenden, um das Bundle aufzuschlüsseln. Wie erwartet enthält unser Bundle die Spiellogik, die Rendering-Engine, den Gewinnbildschirm, den Verlustbildschirm und eine Reihe von Dienstprogrammen. Für die Landingpage wird nur ein kleiner Teil dieser Module benötigt. Wenn Sie alles, was nicht unbedingt für die Interaktivität erforderlich ist, in ein verzögert geladenes Modul verschieben, wird die TTI erheblich verringert.

Eine Analyse des Inhalts der Datei „index.html“ von PROXX zeigt, dass sie viele nicht benötigte Ressourcen enthält. Kritische Ressourcen werden hervorgehoben.

Wir müssen den Code aufteilen. Beim Code-Splitting wird das monolithische Bundle in kleinere Teile aufgeteilt, die bei Bedarf per Lazy Loading geladen werden können. Beliebte Bundler wie Webpack, Rollup und Parcel unterstützen die Codeaufteilung mithilfe von dynamischen import(). Der Bundler analysiert Ihren Code und fügt alle Module, die statisch importiert werden, inline ein. Alles, was Sie dynamisch importieren, wird in einer eigenen Datei abgelegt und erst dann aus dem Netzwerk abgerufen, wenn der import()-Aufruf ausgeführt wird. Natürlich ist der Zugriff auf das Netzwerk mit Kosten verbunden und sollte nur erfolgen, wenn Sie die Zeit dafür haben. Die Devise lautet: Importieren Sie die Module statisch, die beim Laden unbedingt erforderlich sind, und laden Sie alles andere dynamisch. Sie sollten jedoch nicht bis zum allerletzten Moment warten, um Module per Lazy Loading zu laden, die definitiv verwendet werden. Idle Until Urgent von Phil Walton ist ein hervorragendes Muster für einen gesunden Mittelweg zwischen Lazy Loading und Eager Loading.

In PROXX haben wir eine lazy.js-Datei erstellt, die alles statisch importiert, was wir nicht benötigen. In unserer Hauptdatei können wir dann lazy.js dynamisch importieren. Einige unserer Preact-Komponenten landeten jedoch in lazy.js, was sich als etwas kompliziert herausstellte, da Preact nicht standardmäßig mit verzögert geladenen Komponenten umgehen kann. Aus diesem Grund haben wir einen kleinen deferred-Komponenten-Wrapper geschrieben, mit dem wir einen Platzhalter rendern können, bis die eigentliche Komponente geladen ist.

export default function deferred(componentPromise) {
  return class Deferred extends Component {
    constructor(props) {
      super(props);
      this.state = {
        LoadedComponent: undefined
      };
      componentPromise.then(component => {
        this.setState({ LoadedComponent: component });
      });
    }

    render({ loaded, loading }, { LoadedComponent }) {
      if (LoadedComponent) {
        return loaded(LoadedComponent);
      }
      return loading();
    }
  };
}

Anschließend können wir ein Promise einer Komponente in unseren render()-Funktionen verwenden. Beispielsweise wird die Komponente <Nebula>, die das animierte Hintergrundbild rendert, während des Ladens durch ein leeres <div> ersetzt. Sobald die Komponente geladen und einsatzbereit ist, wird der <div> durch die tatsächliche Komponente ersetzt.

const NebulaDeferred = deferred(
  import("/components/nebula").then(m => m.default)
);

return (
  // ...
  <NebulaDeferred
    loading={() => <div />}
    loaded={Nebula => <Nebula />}
  />
);

Mit all diesen Maßnahmen konnten wir die Größe unserer index.html auf nur 20 KB reduzieren, also auf weniger als die Hälfte der ursprünglichen Größe. Welche Auswirkungen hat das auf FMP und TTI? WebPageTest verrät es Ihnen.

Der Filmstreifen bestätigt: Die TTI liegt jetzt bei 5,4 Sekunden. Eine drastische Verbesserung gegenüber den ursprünglichen 11 Sekunden.

Der FMP und die TTI liegen nur 100 ms auseinander, da nur das Inline-JavaScript geparst und ausgeführt werden muss. Nach nur 5, 4 Sekunden im 2G-Netz ist die App vollständig interaktiv. Alle anderen, weniger wichtigen Module werden im Hintergrund geladen.

Mehr Taschenspielertricks

Wenn Sie sich die Liste der kritischen Module oben ansehen, werden Sie feststellen, dass die Rendering-Engine nicht zu den kritischen Modulen gehört. Natürlich kann das Spiel erst starten, wenn die Rendering-Engine das Spiel rendert. Wir könnten die Schaltfläche „Start“ deaktivieren, bis unsere Rendering-Engine bereit ist, das Spiel zu starten. Unserer Erfahrung nach dauert es jedoch in der Regel so lange, bis der Nutzer seine Spieleinstellungen konfiguriert hat, dass dies nicht erforderlich ist. Meistens sind die Rendering-Engine und die anderen verbleibenden Module fertig geladen, wenn der Nutzer auf „Start“ klickt. In dem seltenen Fall, dass der Nutzer schneller ist als seine Netzwerkverbindung, wird ein einfacher Ladebildschirm angezeigt, der auf den Abschluss der verbleibenden Module wartet.

Fazit

Messungen sind wichtig. Damit Sie keine Zeit mit Problemen verschwenden, die gar nicht existieren, sollten Sie immer zuerst Messungen durchführen, bevor Sie Optimierungen vornehmen. Außerdem sollten die Messungen auf echten Geräten mit einer 3G-Verbindung oder auf WebPageTest durchgeführt werden, wenn kein echtes Gerät zur Hand ist.

Der Filmstreifen kann Aufschluss darüber geben, wie sich das Laden Ihrer App für den Nutzer anfühlt. Anhand des Wasserfalldiagramms können Sie erkennen, welche Ressourcen für potenziell lange Ladezeiten verantwortlich sind. Hier ist eine Checkliste mit Maßnahmen, die Sie ergreifen können, um die Ladeleistung zu verbessern:

  • Stelle so viele Assets wie möglich über eine Verbindung bereit.
  • Vorabladen oder sogar Inline-Ressourcen, die für das erste Rendering und die Interaktivität erforderlich sind.
  • Rendern Sie Ihre App vor, um die wahrgenommene Ladeleistung zu verbessern.
  • Nutzen Sie die aggressive Codeaufteilung, um die für die Interaktivität erforderliche Codemenge zu reduzieren.

In Teil 2 geht es dann um die Optimierung der Laufzeitleistung auf Geräten mit sehr eingeschränkten Ressourcen.