Cara kami menggunakan pemisahan kode, penyisipan kode, dan rendering sisi server di PROXX.
Di Google I/O 2019, Mariko, Jake, dan saya meluncurkan PROXX, tiruan Minesweeper modern untuk web. Sesuatu yang membedakan PROXX adalah fokus pada aksesibilitas (Anda dapat memainkannya dengan pembaca layar) dan kemampuan untuk berjalan dengan baik di ponsel menengah maupun di perangkat desktop kelas atas. Ponsel menengah memiliki beberapa keterbatasan:
- CPU Lemah
- GPU yang lemah atau tidak ada
- Layar kecil tanpa input sentuh
- Jumlah memori yang sangat terbatas
Namun, Chromebook menjalankan browser modern dan sangat terjangkau. Oleh karena itu, ponsel menengah kembali populer di pasar negara berkembang. Titik harganya memungkinkan audiens baru, yang sebelumnya tidak mampu membelinya, untuk online dan memanfaatkan web modern. Untuk tahun 2019, diperkirakan sekitar 400 juta ponsel menengah akan terjual di India saja, sehingga pengguna ponsel menengah mungkin akan menjadi bagian yang signifikan dari audiens Anda. Selain itu, kecepatan koneksi yang mirip dengan 2G adalah hal yang biasa di pasar negara berkembang. Bagaimana cara kami membuat PROXX berfungsi dengan baik dalam kondisi ponsel menengah?
Performa itu penting, dan hal ini mencakup performa pemuatan dan performa runtime. Telah terbukti bahwa performa yang baik berkorelasi dengan peningkatan retensi pengguna, peningkatan konversi, dan—yang terpenting—peningkatan inklusivitas. Jeremy Wagner memiliki lebih banyak data dan insight tentang alasan performa itu penting.
Artikel ini adalah bagian 1 dari rangkaian yang terdiri atas dua bagian. Bagian 1 berfokus pada performa pemuatan, dan bagian 2 akan berfokus pada performa runtime.
Merekam status quo
Menguji performa pemuatan di perangkat sungguhan sangatlah penting. Jika Anda tidak memiliki perangkat sungguhan, sebaiknya gunakan WebPageTest, khususnya penyiapan "sederhana". WPT menjalankan serangkaian pengujian pemuatan di perangkat sungguhan dengan koneksi 3G yang diemulasikan.
3G adalah kecepatan yang baik untuk diukur. Meskipun Anda mungkin terbiasa dengan 4G, LTE, atau bahkan 5G, kenyataan internet seluler terlihat sangat berbeda. Mungkin Anda sedang berada di kereta, konferensi, konser, atau penerbangan. Yang akan Anda alami di sana kemungkinan besar lebih dekat ke 3G, dan terkadang bahkan lebih buruk.
Meskipun demikian, kita akan berfokus pada 2G dalam artikel ini karena PROXX secara eksplisit menargetkan ponsel menengah dan pasar negara berkembang dalam audiens targetnya. Setelah WebPageTest menjalankan pengujiannya, Anda akan mendapatkan waterfall (mirip dengan yang Anda lihat di DevTools) serta filmstrip di bagian atas. Strip film menunjukkan apa yang dilihat pengguna saat aplikasi Anda dimuat. Pada 2G, pengalaman pemuatan versi PROXX yang tidak dioptimalkan cukup buruk:
Saat dimuat melalui 3G, pengguna akan melihat layar putih kosong selama 4 detik. Melalui 2G, pengguna tidak melihat apa pun selama lebih dari 8 detik. Jika Anda membaca alasan performa penting, Anda akan tahu bahwa kita telah kehilangan sebagian besar calon pengguna karena ketidaksabaran. Pengguna harus mendownload semua JavaScript sebesar 62 KB agar konten dapat muncul di layar. Sisi positifnya, dalam skenario ini, apa pun yang muncul di layar juga bersifat interaktif. Tapi, apa benar begitu?
Setelah sekitar 62 KB JS gzip didownload dan DOM dibuat, pengguna dapat melihat aplikasi kita. Aplikasi ini secara teknis interaktif. Namun, melihat visualnya menunjukkan realitas yang berbeda. Font web masih dimuat di latar belakang dan hingga font tersebut siap, pengguna tidak dapat melihat teks. Meskipun status ini memenuhi syarat sebagai First Meaningful Paint (FMP), status ini tentu tidak memenuhi syarat sebagai interaktif yang tepat, karena pengguna tidak dapat mengetahui apa yang dimaksud dengan input apa pun. Perlu waktu satu detik lagi di 3G dan 3 detik di 2G hingga aplikasi siap digunakan. Secara keseluruhan, aplikasi memerlukan waktu 6 detik di 3G dan 11 detik di 2G untuk menjadi interaktif.
Analisis waterfall
Setelah mengetahui apa yang dilihat pengguna, kita perlu mencari tahu alasannya. Untuk itu, kita dapat melihat waterfall dan menganalisis alasan resource dimuat terlalu lambat. Dalam rekaman aktivitas 2G untuk PROXX, kita dapat melihat dua tanda bahaya utama:
- Ada beberapa garis tipis berwarna-warni.
- File JavaScript membentuk rantai. Misalnya, resource kedua hanya mulai dimuat setelah resource pertama selesai, dan resource ketiga hanya dimulai setelah resource kedua selesai.
Mengurangi jumlah koneksi
Setiap garis tipis (dns, connect, ssl) menunjukkan pembuatan koneksi HTTP baru. Menyiapkan koneksi baru memerlukan biaya yang besar karena memerlukan waktu sekitar 1 detik di 3G dan sekitar 2,5 detik di 2G. Dalam waterfall, kita melihat koneksi baru untuk:
- Permintaan #1:
index.htmlkami - Permintaan #5: Gaya font dari
fonts.googleapis.com - Permintaan #8: Google Analytics
- Permintaan #9: File font dari
fonts.gstatic.com - Permintaan #14: Manifes aplikasi web
Koneksi baru untuk index.html tidak dapat dihindari. Browser harus membuat koneksi ke server kami untuk mendapatkan konten. Koneksi baru untuk Google Analytics dapat dihindari dengan menyisipkan sesuatu seperti Minimal Analytics, tetapi Google Analytics tidak memblokir aplikasi kami agar tidak dirender atau menjadi interaktif, jadi kami tidak terlalu peduli dengan seberapa cepat aplikasi tersebut dimuat. Idealnya, Google Analytics harus dimuat dalam waktu tidak ada aktivitas, saat semua hal lain telah dimuat. Dengan begitu, gambar tidak akan menggunakan bandwidth atau daya pemrosesan selama pemuatan awal. Koneksi baru untuk manifes aplikasi web ditentukan oleh spesifikasi pengambilan, karena manifes harus dimuat melalui koneksi tanpa kredensial. Sekali lagi, manifes aplikasi web tidak memblokir aplikasi kita agar tidak dirender atau menjadi interaktif, jadi kita tidak perlu terlalu peduli.
Namun, kedua font dan gayanya menjadi masalah karena memblokir rendering dan juga interaktivitas. Jika kita melihat CSS yang dikirimkan oleh fonts.googleapis.com, hanya ada dua aturan @font-face, satu untuk setiap font. Gaya font sangat kecil, sehingga kami memutuskan untuk menyisipkannya ke dalam HTML, sehingga menghapus satu koneksi yang tidak diperlukan. Untuk menghindari biaya penyiapan koneksi untuk file font, kita dapat menyalinnya ke server kita sendiri.
Memparalelkan pemuatan
Dengan melihat waterfall, kita dapat melihat bahwa setelah file JavaScript pertama selesai dimuat, file baru akan segera mulai dimuat. Hal ini umum terjadi pada dependensi modul. Modul utama kita mungkin memiliki impor statis, sehingga JavaScript tidak dapat berjalan hingga impor tersebut dimuat. Hal penting yang perlu disadari di sini adalah bahwa jenis dependensi ini diketahui pada waktu build. Kita dapat menggunakan tag <link rel="preload"> untuk memastikan semua dependensi mulai dimuat begitu kita menerima HTML.
Hasil
Mari kita lihat hasil dari perubahan yang kita lakukan. Penting untuk tidak mengubah variabel lain dalam penyiapan pengujian yang dapat memengaruhi hasil, jadi kita akan menggunakan penyiapan sederhana WebPageTest untuk bagian selanjutnya dari artikel ini dan melihat filmstrip:
Perubahan ini mengurangi TTI kami dari 11 menjadi 8,5, yang kira-kira merupakan waktu penyiapan koneksi 2,5 detik yang ingin kami hapus. Kerja bagus.
Pra-rendering
Meskipun baru saja mengurangi TTI, kita belum benar-benar memengaruhi layar putih yang sangat lama yang harus dialami pengguna selama 8,5 detik. Bisa dibilang peningkatan terbesar untuk FMP dapat dicapai dengan mengirimkan markup bergaya di index.html Anda. Teknik umum untuk mencapai hal ini adalah pra-rendering dan rendering sisi server, yang terkait erat dan dijelaskan dalam Rendering di Web. Kedua teknik ini menjalankan aplikasi web di Node dan melakukan serialisasi DOM yang dihasilkan ke HTML. Rendering sisi server melakukan hal ini per permintaan di, ya, sisi server, sedangkan pra-rendering melakukan hal ini pada waktu build dan menyimpan output sebagai index.html baru Anda. Karena PROXX adalah aplikasi JAMStack dan tidak memiliki sisi server, kami memutuskan untuk menerapkan pra-rendering.
Ada banyak cara untuk menerapkan pra-perender. Di PROXX, kami memilih untuk menggunakan Puppeteer, yang memulai Chrome tanpa UI apa pun dan memungkinkan Anda mengontrol instance tersebut dari jarak jauh dengan Node API. Kami menggunakannya untuk memasukkan markup dan JavaScript, lalu membaca kembali DOM sebagai string HTML. Karena kita menggunakan Modul CSS, kita mendapatkan penyisipan CSS untuk gaya yang kita perlukan secara gratis.
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);
Dengan begitu, kita dapat mengharapkan peningkatan untuk FMP. Kita masih perlu memuat dan mengeksekusi jumlah JavaScript yang sama seperti sebelumnya, jadi kita tidak boleh mengharapkan TTI berubah banyak. Jika ada, index.html kita telah bertambah besar dan mungkin akan sedikit memperlambat TTI kita. Hanya ada satu cara untuk mengetahuinya: menjalankan WebPageTest.
First Meaningful Paint kami telah meningkat dari 8,5 detik menjadi 4,9 detik, peningkatan yang sangat besar. TTI kami masih terjadi sekitar 8,5 detik, sehingga sebagian besar tidak terpengaruh oleh perubahan ini. Yang kami lakukan di sini adalah perubahan persepsi. Beberapa orang bahkan mungkin menyebutnya sebagai trik sulap. Dengan merender visual perantara game, kami mengubah performa pemuatan yang dirasakan menjadi lebih baik.
Inlining
Metrik lain yang diberikan oleh DevTools dan WebPageTest adalah Time To First Byte (TTFB). Ini adalah waktu yang diperlukan dari byte pertama permintaan yang dikirim hingga byte pertama respons yang diterima. Waktu ini juga sering disebut Waktu Round Trip (RTT), meskipun secara teknis ada perbedaan antara kedua angka ini: RTT tidak mencakup waktu pemrosesan permintaan di sisi server. DevTools dan WebPageTest memvisualisasikan TTFB dengan warna terang dalam blok permintaan/respons.
Dengan melihat waterfall, kita dapat melihat bahwa semua permintaan menghabiskan sebagian besar waktunya untuk menunggu byte pertama respons tiba.
Masalah inilah yang menjadi alasan awal dibuatnya HTTP/2 Push. Developer aplikasi mengetahui bahwa resource tertentu diperlukan dan dapat mendorongnya ke bawah. Saat klien menyadari bahwa ia perlu mengambil resource tambahan, resource tersebut sudah ada di cache browser. HTTP/2 Push ternyata terlalu sulit untuk diterapkan dengan benar dan dianggap tidak disarankan. Ruang masalah ini akan ditinjau kembali selama standardisasi HTTP/3. Untuk saat ini, solusi termudah adalah menyisipkan semua resource penting dengan mengorbankan efisiensi caching.
CSS penting kami sudah disisipkan berkat Modul CSS dan pra-perender berbasis Puppeteer. Untuk JavaScript, kita perlu menyisipkan modul penting dan dependensinya. Tugas ini memiliki tingkat kesulitan yang bervariasi, berdasarkan pemaket yang Anda gunakan.
Tindakan ini mengurangi 1 detik dari TTI kami. Sekarang kita telah mencapai titik di mana index.html berisi semua yang diperlukan untuk render awal dan menjadi interaktif. HTML dapat dirender saat masih didownload, sehingga membuat FMP kita. Saat HTML selesai diuraikan dan dieksekusi, aplikasi akan menjadi interaktif.
Pemisahan kode agresif
Ya, index.html kami berisi semua yang diperlukan untuk menjadi interaktif. Namun, setelah diperiksa lebih lanjut, ternyata file tersebut juga berisi semua hal lainnya. index.html kami berukuran sekitar 43 KB. Mari kita hubungkan hal itu dengan apa yang dapat digunakan pengguna untuk berinteraksi di awal: Kita memiliki formulir untuk mengonfigurasi game yang berisi beberapa komponen, tombol mulai, dan mungkin beberapa kode untuk mempertahankan dan memuat setelan pengguna. Cukup begitu saja. 43 KB tampaknya terlalu besar.
Untuk memahami asal ukuran paket, kita dapat menggunakan penjelajah peta sumber atau alat serupa untuk menguraikan isi paket. Seperti yang diperkirakan, paket kita berisi logika game, mesin rendering, layar menang, layar kalah, dan sejumlah utilitas. Hanya sebagian kecil dari modul ini yang diperlukan untuk halaman landing. Memindahkan semua hal yang tidak benar-benar diperlukan untuk interaktivitas ke dalam modul yang dimuat lambat akan mengurangi TTI secara signifikan.
Yang perlu kita lakukan adalah pemisahan kode. Pemisahan kode memecah paket monolitik Anda menjadi bagian-bagian yang lebih kecil yang dapat dimuat lambat sesuai permintaan. Pemaket populer seperti Webpack, Rollup, dan Parcel mendukung pemisahan kode menggunakan import() dinamis. Bundler akan menganalisis kode Anda dan menyisipkan semua modul yang diimpor secara statis. Semua yang Anda impor secara dinamis akan dimasukkan ke dalam filenya sendiri dan hanya akan diambil dari jaringan setelah panggilan import() dijalankan. Tentu saja, mengakses jaringan memerlukan biaya dan hanya boleh dilakukan jika Anda memiliki waktu luang. Prinsipnya di sini adalah mengimpor secara statis modul yang sangat diperlukan pada waktu pemuatan dan memuat semua modul lainnya secara dinamis. Namun, Anda tidak boleh menunggu hingga saat-saat terakhir untuk memuat lambat modul yang pasti akan digunakan. Idle Until Urgent dari Phil Walton adalah pola yang bagus untuk titik tengah yang sehat antara pemuatan lambat dan pemuatan cepat.
Di PROXX, kami membuat file lazy.js yang mengimpor secara statis semua yang tidak kami perlukan. Dalam file utama, kita dapat mengimpor lazy.js secara dinamis. Namun, beberapa komponen Preact kami berakhir di lazy.js, yang ternyata agak rumit karena Preact tidak dapat menangani komponen yang dimuat lambat secara langsung. Oleh karena itu, kami menulis wrapper komponen deferred kecil yang memungkinkan kami merender placeholder hingga komponen sebenarnya dimuat.
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();
}
};
}
Dengan demikian, kita dapat menggunakan Promise komponen dalam fungsi render(). Misalnya, komponen <Nebula>, yang merender gambar latar animasi, akan diganti dengan <div> kosong saat komponen dimuat. Setelah komponen dimuat dan siap digunakan, <div> akan diganti dengan komponen yang sebenarnya.
const NebulaDeferred = deferred(
import("/components/nebula").then(m => m.default)
);
return (
// ...
<NebulaDeferred
loading={() => <div />}
loaded={Nebula => <Nebula />}
/>
);
Dengan semua ini, kami mengurangi index.html menjadi hanya 20 KB, kurang dari setengah ukuran aslinya. Apa pengaruhnya terhadap FMP dan TTI? WebPageTest akan memberi tahu Anda.
FMP dan TTI kami hanya berjarak 100 md, karena ini hanya masalah penguraian dan eksekusi JavaScript inline. Hanya setelah 5,4 detik di 2G, aplikasi sepenuhnya interaktif. Semua modul lain yang kurang penting dimuat di latar belakang.
Lebih banyak trik sulap
Jika Anda melihat daftar modul penting di atas, Anda akan melihat bahwa mesin rendering bukan bagian dari modul penting. Tentu saja, game tidak dapat dimulai sebelum kita memiliki mesin rendering untuk merender game. Kita dapat menonaktifkan tombol "Start" hingga mesin rendering siap memulai game, tetapi berdasarkan pengalaman kami, pengguna biasanya memerlukan waktu yang cukup lama untuk mengonfigurasi setelan game sehingga hal ini tidak diperlukan. Sering kali, mesin rendering dan modul lainnya yang tersisa selesai dimuat saat pengguna menekan "Mulai". Dalam kasus yang jarang terjadi, jika pengguna lebih cepat daripada koneksi jaringannya, kami akan menampilkan layar pemuatan sederhana yang menunggu modul yang tersisa selesai.
Kesimpulan
Pengukuran itu penting. Agar tidak menghabiskan waktu untuk masalah yang tidak nyata, sebaiknya selalu lakukan pengukuran terlebih dahulu sebelum menerapkan pengoptimalan. Selain itu, pengukuran harus dilakukan di perangkat sungguhan dengan koneksi 3G atau di WebPageTest jika tidak ada perangkat sungguhan.
Filmstrip dapat memberikan insight tentang bagaimana pemuatan aplikasi Anda dirasakan oleh pengguna. Waterfall dapat memberi tahu Anda resource apa yang mungkin menyebabkan waktu pemuatan yang lama. Berikut adalah checklist hal-hal yang dapat Anda lakukan untuk meningkatkan performa pemuatan:
- Mengirimkan aset sebanyak mungkin melalui satu koneksi.
- Pramuat atau bahkan sisipkan resource yang diperlukan untuk render pertama dan interaktivitas.
- Lakukan pra-rendering aplikasi Anda untuk meningkatkan performa pemuatan yang terlihat.
- Gunakan pemisahan kode yang agresif untuk mengurangi jumlah kode yang diperlukan untuk interaktivitas.
Nantikan bagian 2, tempat kami membahas cara mengoptimalkan performa runtime di perangkat yang sangat terbatas.