שיטות לטעינת אפליקציית אינטרנט במהירות, גם בטלפון פשוט

איך השתמשנו בפיצול קוד, בהטמעת קוד וברינדור בצד השרת ב-PROXX.

ב-Google I/O 2019, מריקו, ג'ייק ואני השקנו את PROXX, שיבוט מודרני של שולה המוקשים לאינטרנט. מה שמייחד את PROXX הוא ההתמקדות בנגישות (אפשר לשחק בו עם קורא מסך!) והיכולת לפעול גם בטלפון נייד פשוט וגם במחשב מתקדם. לטלפונים ניידים פשוטים יש כמה מגבלות:

  • מעבדים חלשים
  • מעבדי GPU חלשים או לא קיימים
  • מסכים קטנים בלי קלט מגע
  • נפח זיכרון מוגבל מאוד

אבל הם מריצים דפדפן מודרני והם זולים מאוד. לכן, טלפונים ניידים פשוטים חוזרים להיות פופולריים בשווקים מתעוררים. המחיר שלהם מאפשר לקהל חדש לגמרי, שבעבר לא יכול היה להרשות לעצמו, להתחבר לאינטרנט ולהשתמש באינטרנט המודרני. לפי התחזיות, בשנת 2019 יימכרו כ-400 מיליון טלפונים ניידים פשוטים בהודו בלבד, כך שמשתמשים בטלפונים ניידים פשוטים עשויים להפוך לחלק משמעותי מהקהל שלכם. בנוסף, מהירויות חיבור שדומות ל-2G הן הנורמה בשווקים מתעוררים. איך הצלחנו לגרום ל-PROXX לפעול היטב בתנאים של טלפון נייד פשוט?

גיימפליי של PROXX.

הביצועים חשובים, וזה כולל גם את ביצועי הטעינה וגם את ביצועי זמן הריצה. הוכח שביצועים טובים קשורים לשימור משתמשים גבוה יותר, להמרות משופרות וחשוב מכול – להכללה מוגברת. ג'רמי וגנר מספק הרבה יותר נתונים ותובנות לגבי חשיבות הביצועים.

זה החלק הראשון מתוך סדרה שכוללת שני חלקים. חלק 1 מתמקד בביצועי הטעינה, וחלק 2 יתמקד בביצועים בזמן ריצה.

תיעוד הסטטוס קוו

חשוב מאוד לבדוק את ביצועי הטעינה במכשיר אמיתי. אם אין לכם מכשיר אמיתי, מומלץ להשתמש ב-WebPageTest, ובמיוחד בהגדרה הפשוטה. WPT מריץ סדרה של בדיקות טעינה במכשיר אמיתי עם חיבור מדומה לדור שלישי.

דור 3 הוא מהירות טובה למדידה. יכול להיות שאתם רגילים ל-4G, ל-LTE או בקרוב אפילו ל-5G, אבל המציאות של האינטרנט לנייד נראית אחרת לגמרי. למשל, אם אתם ברכבת, בכנס, בהופעה או בטיסה. סביר להניח שחוויית השימוש שלכם תהיה קרובה יותר ל-3G, ולפעמים אפילו פחות.

עם זאת, במאמר הזה נתמקד ב-2G כי PROXX מטרגט באופן מפורש טלפונים ניידים פשוטים ושווקים מתעוררים בקהל היעד שלו. אחרי ש-WebPageTest מריץ את הבדיקה, מקבלים תרשים מפל (דומה למה שרואים ב-DevTools) וגם רצועת תמונות בחלק העליון. רצועת הסרט מראה מה המשתמש רואה בזמן שהאפליקציה נטענת. ב-2G, חוויית הטעינה של הגרסה הלא אופטימלית של PROXX די גרועה:

הסרטון של רצועת התמונות מראה מה המשתמש רואה כש-PROXX נטען במכשיר אמיתי עם מפרט נמוך בחיבור 2G מדומה.

כשהדף נטען בחיבור 3G, המשתמש רואה מסך לבן ריק במשך 4 שניות. בחיבור 2G, המשתמש לא רואה כלום במשך יותר מ-8 שניות. אם קראתם את המאמר למה הביצועים חשובים, אתם יודעים שעכשיו איבדנו חלק גדול מהמשתמשים הפוטנציאליים שלנו בגלל חוסר סבלנות. המשתמש צריך להוריד את כל 62KB של JavaScript כדי שמשהו יופיע במסך. היתרון בתרחיש הזה הוא שברגע שמופיע משהו במסך, הוא גם אינטראקטיבי. או שכן?

[הצגת התוכן העיקרי (FMP)][FMP] בגרסה הלא אופטימלית של PROXX היא _טכנית_ [אינטראקטיבית][TTI] אבל לא שימושית למשתמש.

אחרי שהורדנו כ-62KB של קובץ JS מכווץ ב-gzip ונוצר ה-DOM, המשתמש יכול לראות את האפליקציה שלנו. האפליקציה אינטראקטיבית מבחינה טכנית. אבל כשמסתכלים על התמונה, רואים מציאות אחרת. הגופנים לאינטרנט עדיין נטענים ברקע, ועד שהם מוכנים המשתמש לא יכול לראות טקסט. המצב הזה נחשב להצגת התוכן העיקרי (FMP), אבל הוא בטוח לא נחשב לאינטראקטיבי כמו שצריך, כי המשתמש לא יכול לדעת מה המשמעות של כל אחד מהקלטות. בחיבור 3G נדרשת עוד שנייה אחת ובחיבור 2G נדרשות עוד 3 שניות עד שהאפליקציה מוכנה לפעולה. בסך הכול, נדרשות 6 שניות בחיבור 3G ו-11 שניות בחיבור 2G עד שהאפליקציה הופכת לאינטראקטיבית.

ניתוח מפל

עכשיו, כשאנחנו יודעים מה המשתמש רואה, אנחנו צריכים להבין למה. כדי לעשות את זה, אפשר להסתכל על תרשים ה-Waterfall ולנתח למה המשאבים נטענים מאוחר מדי. במעקב 2G של PROXX אפשר לראות שתי נורות אדומות עיקריות:

  1. יש כמה קווים דקים בצבעים שונים.
  2. קובצי JavaScript יוצרים שרשרת. לדוגמה, המשאב השני מתחיל להיטען רק אחרי שהמשאב הראשון נטען, והמשאב השלישי מתחיל להיטען רק אחרי שהמשאב השני נטען.
תרשים ה-Waterfall מספק תובנות לגבי המשאבים שנטענים, מתי הם נטענים וכמה זמן נמשכת הטעינה.

הפחתת מספר החיבורים

כל קו דק (dns, connect, ssl) מייצג יצירה של חיבור HTTP חדש. הגדרה של חיבור חדש היא יקרה, כי היא נמשכת כשנייה אחת ב-3G וכ-2.5 שניות ב-2G. ב-Waterfall שלנו אנחנו רואים חיבור חדש עבור:

  • בקשה מס' 1: index.html שלנו
  • בקשה מספר 5: סגנונות הגופנים של fonts.googleapis.com
  • בקשה מס' 8: Google Analytics
  • בקשה מספר 9: קובץ גופן מ-fonts.gstatic.com
  • בקשה מספר 14: קובץ המניפסט של אפליקציית האינטרנט

החיבור החדש של index.html הוא בלתי נמנע. הדפדפן חייב ליצור חיבור לשרת שלנו כדי לקבל את התוכן. אפשר להימנע מהחיבור החדש ל-Google Analytics על ידי הוספה של משהו כמו Minimal Analytics, אבל Google Analytics לא מונע מהאפליקציה שלנו לעבד או להפוך לאינטראקטיבית, כך שלא ממש אכפת לנו כמה מהר היא נטענת. באופן אידיאלי, Google Analytics צריך להיטען בזמן חוסר פעילות, אחרי שכל שאר הדברים כבר נטענו. כך הוא לא יתפוס רוחב פס או כוח עיבוד במהלך הטעינה הראשונית. החיבור החדש לקובץ מניפסט של אפליקציית האינטרנט נקבע לפי מפרט האחזור, כי צריך לטעון את המניפסט דרך חיבור ללא פרטי כניסה. שוב, המניפסט של אפליקציית האינטרנט לא מונע מהאפליקציה שלנו לעבד או להפוך לאינטראקטיבית, אז אנחנו לא צריכים לדאוג יותר מדי.

עם זאת, שני הגופנים והסגנונות שלהם הם בעיה כי הם חוסמים את העיבוד וגם את האינטראקטיביות. אם נסתכל על ה-CSS שמועבר על ידי fonts.googleapis.com, נראה שיש רק שני כללי @font-face, אחד לכל גופן. למעשה, סגנונות הגופן כל כך קטנים שהחלטנו להטמיע אותם ב-HTML שלנו, וכך להסיר חיבור אחד מיותר. כדי להימנע מהעלות של הגדרת החיבור לקובצי הגופנים, אנחנו יכולים להעתיק אותם לשרת שלנו.

העלאות מקבילות

בתרשים ה-Waterfall אפשר לראות שברגע שקובץ ה-JavaScript הראשון נטען, קבצים חדשים מתחילים להיטען מיד. זה קורה בדרך כלל ביחסי תלות של מודולים. המודול הראשי שלנו כנראה כולל ייבוא סטטי, ולכן ה-JavaScript לא יכול לפעול עד שהייבוא הזה נטען. הדבר החשוב שצריך להבין כאן הוא שסוגי התלות האלה ידועים בזמן ה-build. אנחנו יכולים להשתמש בתגי <link rel="preload"> כדי לוודא שכל יחסי התלות מתחילים להיטען ברגע שאנחנו מקבלים את ה-HTML.

תוצאות

בואו נראה מה השינויים שלנו השיגו. חשוב לא לשנות משתנים אחרים בהגדרת הבדיקה שלנו שעלולים להטות את התוצאות, לכן נשתמש בהגדרה הפשוטה של WebPageTest בשאר המאמר הזה ונבחן את רצועת התמונות:

אנחנו משתמשים ברצועת התמונות של WebPageTest כדי לראות מה השינויים שלנו השיגו.

השינויים האלה הפחיתו את ה-TTI שלנו מ-11 ל-8.5, שזה בערך 2.5 שניות של זמן הגדרת החיבור שרצינו להסיר. כל הכבוד לנו.

רינדור מראש

למרות שהפחתנו את ה-TTI, לא ממש השפענו על המסך הלבן הארוך שהמשתמש צריך לסבול במשך 8.5 שניות. אפשר לומר שהשיפורים המשמעותיים ביותר ב-FMP מושגים על ידי שליחת תגי עיצוב ב-index.html. שיטות נפוצות להשגת המטרה הזו הן רינדור מראש ורינדור בצד השרת, שקשורות זו לזו ומוסברות במאמר רינדור באינטרנט. שתי השיטות מריצות את אפליקציית האינטרנט ב-Node ומבצעות סריאליזציה של ה-DOM שנוצר ל-HTML. עיבוד בצד השרת מבצע את הפעולה הזו לכל בקשה בצד השרת, ואילו רינדור מראש מבצע את הפעולה הזו בזמן ה-build ושומר את הפלט בתור index.html החדש. מכיוון ש-PROXX היא אפליקציית JAMStack ואין לה צד שרת, החלטנו להטמיע רינדור מראש.

יש הרבה דרכים להטמיע רינדור מראש. ב-PROXX בחרנו להשתמש ב-Puppeteer, שמפעיל את Chrome בלי ממשק משתמש ומאפשר לשלוט מרחוק במכונה הזו באמצעות Node API. אנחנו משתמשים בזה כדי להוסיף את תגי העיצוב ואת ה-JavaScript שלנו, ואז לקרוא בחזרה את ה-DOM כמחרוזת של HTML. מכיוון שאנחנו משתמשים במודולים של CSS, אנחנו מקבלים הטבעה של סגנונות ה-CSS שאנחנו צריכים בחינם.

  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);

כשהוא מוגדר, אפשר לצפות לשיפור ב-FMP. אנחנו עדיין צריכים לטעון ולהריץ את אותה כמות של JavaScript כמו קודם, אז אנחנו לא צריכים לצפות לשינוי משמעותי ב-TTI. למעשה, ה-index.html שלנו גדל ויכול להיות שהוא ידחה קצת את ה-TTI. יש רק דרך אחת לגלות: להריץ את WebPageTest.

רצועת התמונות מראה שיפור ברור במדד ה-FMP. ה-TTI כמעט לא מושפע.

הצגת התוכן העיקרי (FMP) השתפרה מ-8.5 שניות ל-4.9 שניות, שיפור משמעותי. ה-TTI שלנו עדיין מתרחש בסביבות 8.5 שניות, כך שהוא לא הושפע במידה רבה מהשינוי הזה. מה שעשינו כאן הוא שינוי תפיסתי. יש אנשים שאפילו יקראו לזה זריזות ידיים. העיבוד של תצוגה מקדימה של המשחק משפר את חוויית הטעינה של המשתמשים.

הטמעה

מדד נוסף שכלי הפיתוח ו-WebPageTest מספקים הוא המהירות שבה מגיע בייט התגובה הראשון (TTFB). זה הזמן שעובר מרגע שליחת הבייט הראשון של הבקשה ועד לקבלת הבייט הראשון של התגובה. הזמן הזה נקרא גם Round Trip Time‏ (RTT), למרות שמבחינה טכנית יש הבדל בין שני המספרים האלה: RTT לא כולל את זמן העיבוד של הבקשה בצד השרת. בDevTools וב-WebPageTest, ה-TTFB מוצג בצבע בהיר בתוך הבלוק של הבקשה/התגובה.

החלק הבהיר של הבקשה מציין שהבקשה ממתינה לקבלת הבייט הראשון של התגובה.

אם נסתכל על תרשים ה-Waterfall, נראה שבכל הבקשות, רוב הזמן מוקדש להמתנה עד שהבייט הראשון של התגובה מגיע.

הבעיה הזו היא הסיבה שבגללה פותח במקור HTTP/2 Push. מפתח האפליקציה יודע שמשאבים מסוימים נדרשים ויכול לדחוף אותם דרך החיבור. עד שהלקוח מבין שהוא צריך לאחזר משאבים נוספים, הם כבר נמצאים במטמון של הדפדפן. התברר שקשה מדי להשתמש ב-HTTP/2 Push בצורה נכונה, ולכן לא מומלץ להשתמש בו. הבעיה הזו תיבדק שוב במהלך התקינה של HTTP/3. בינתיים, הפתרון הכי פשוט הוא להטמיע את כל המשאבים הקריטיים על חשבון יעילות השמירה במטמון.

ה-CSS הקריטי שלנו כבר מוטבע הודות למודולים של CSS ולרינדור מראש שמבוסס על Puppeteer. ב-JavaScript, צריך להטביע את המודולים הקריטיים ואת יחסי התלות שלהם. רמת הקושי של המשימה הזו משתנה בהתאם לכלי ה-bundler שבו אתם משתמשים.

בעזרת הטמעת JavaScript בשורה, הפחתנו את ה-TTI מ-8.5 שניות ל-7.2 שניות.

זה קיצר את ה-TTI בשנייה אחת. עכשיו הגענו לנקודה שבה ה-index.html מכיל את כל מה שצריך בשביל הרינדור הראשוני והפיכה לאינטראקטיבי. ה-HTML יכול לעבור עיבוד בזמן שהוא עדיין יורד, וכך נוצר ה-FMP שלנו. ברגע שהניתוח וההרצה של ה-HTML מסתיימים, האפליקציה הופכת לאינטראקטיבית.

פיצול קוד אגרסיבי

כן, index.html שלנו מכיל את כל מה שצריך כדי להפוך לאינטראקטיבי. אבל אם מסתכלים מקרוב, מגלים שהוא מכיל גם את כל השאר. הקובץ index.html שלנו הוא בגודל של כ-43KB. בואו נשווה את זה למה שהמשתמש יכול לעשות בהתחלה: יש לנו טופס להגדרת המשחק שמכיל כמה רכיבים, כפתור התחלה וכנראה קוד כלשהו לשמירה וטעינה של הגדרות המשתמש. זה פחות או יותר הכול. ‫43KB נשמע הרבה.

דף הנחיתה של PROXX. כאן נעשה שימוש רק ברכיבים קריטיים.

כדי להבין מה המקור של גודל החבילה, אפשר להשתמש בסייר מפות מקור או בכלי דומה כדי לפרק את החבילה לרכיבים שלה. כמו שציפינו, החבילה שלנו מכילה את הלוגיקה של המשחק, את מנוע הרינדור, את מסך הניצחון, את מסך ההפסד וכמה כלי עזר. רק קבוצת משנה קטנה של המודולים האלה נדרשת לדף הנחיתה. אם תעבירו את כל מה שלא נדרש באופן מפורש לאינטראקטיביות למודול בטעינה מדורגת, ערך ה-TTI יקטן באופן משמעותי.

ניתוח התוכן של הקובץ index.html של PROXX מראה הרבה משאבים מיותרים. המשאבים החיוניים מודגשים.

מה שצריך לעשות הוא פיצול קוד. פיצול קוד מפרק את החבילה המונוליתית לחלקים קטנים יותר, שאפשר לטעון בטעינה מדורגת לפי דרישה. כלי אריזה פופולריים כמו Webpack,‏ Rollup ו-Parcel תומכים בפיצול קוד באמצעות import() דינמי. ה-bundler ינתח את הקוד ויבצע הטמעה של כל המודולים שיובאו באופן סטטי. כל מה שאתם מייבאים באופן דינמי יוכנס לקובץ משלו ויישלף מהרשת רק אחרי שהקריאה ל-import() תבוצע. כמובן שפנייה לרשת כרוכה בעלות, וצריך לעשות זאת רק אם יש לכם זמן פנוי. העיקרון המנחה הוא לייבא באופן סטטי את המודולים שחיוניים בזמן הטעינה, ולטעון את כל השאר באופן דינמי. אבל לא כדאי לחכות לרגע האחרון כדי לטעון בטעינה מדורגת מודולים שבוודאות יהיה בהם שימוש. המאמר Idle Until Urgent (לא פעיל עד שדחוף) של פיל וולטון הוא דפוס מצוין לשמירה על איזון בריא בין טעינה מדורגת לטעינה מיידית.

ב-PROXX יצרנו קובץ lazy.js שמייבא באופן סטטי את כל מה שלא צריך. בקובץ הראשי, אנחנו יכולים לייבא את lazy.js באופן דינמי. עם זאת, חלק מרכיבי Preact שלנו הגיעו אל lazy.js, וזה קצת סיבך את העניינים כי Preact לא יכול לטפל ברכיבים בטעינה מדורגת (lazy loading) באופן מיידי. לכן כתבנו רכיב wrapper קטן של deferred שמאפשר לנו להציג פלייסהולדר עד שהרכיב עצמו נטען.

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();
    }
  };
}

עכשיו אנחנו יכולים להשתמש ב-Promise של רכיב בפונקציות render() שלנו. לדוגמה, הרכיב <Nebula>, שמעבד את תמונת הרקע המונפשת, יוחלף ב-<div> ריק בזמן שהרכיב נטען. אחרי שהרכיב נטען ומוכן לשימוש, הצ'יפ <div> יוחלף ברכיב עצמו.

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

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

אחרי כל השינויים האלה, הקטנו את ה-index.html שלנו ל-20KB בלבד, פחות מחצי מהגודל המקורי. איך זה משפיע על FMP ו-TTI? אפשר לבדוק את זה ב-WebPageTest.

רצועת התמונות מאשרת: ה-TTI שלנו הוא עכשיו 5.4 שניות. זה שיפור משמעותי לעומת 11 השניות המקוריות.

ההפרש בין ה-FMP ל-TTI הוא רק 100 אלפיות השנייה, כי זה רק עניין של ניתוח והפעלה של ה-JavaScript המוטמע. אחרי 5.4 שניות בלבד ב-2G, האפליקציה אינטראקטיבית לחלוטין. כל שאר המודולים, הפחות חיוניים, נטענים ברקע.

עוד זריזות ידיים

אם תסתכלו על רשימת המודולים הקריטיים שלמעלה, תראו שמנוע העיבוד לא נכלל בהם. כמובן שהמשחק לא יכול להתחיל עד שמנוע הרינדור שלנו ירנדר את המשחק. אנחנו יכולים להשבית את הלחצן "התחלה" עד שמנוע הרינדור שלנו יהיה מוכן להתחיל את המשחק, אבל מניסיוננו, בדרך כלל לוקח למשתמש מספיק זמן לקבוע את הגדרות המשחק, כך שזה לא הכרחי. ברוב המקרים, מנוע הרינדור ושאר המודולים מסיימים להיטען עד שהמשתמש לוחץ על "התחלה". במקרים הנדירים שבהם המשתמש מהיר יותר מהחיבור שלו לרשת, אנחנו מציגים מסך טעינה פשוט עד שהמודולים הנותרים מסיימים להיטען.

סיכום

חשוב למדוד. כדי לא לבזבז זמן על בעיות שלא קיימות, מומלץ תמיד למדוד לפני שמיישמים אופטימיזציות. בנוסף, צריך לבצע את המדידות במכשירים אמיתיים בחיבור 3G או ב-WebPageTest אם אין מכשיר אמיתי זמין.

רצועת התמונות יכולה לתת תובנות לגבי התחושה של המשתמש בזמן טעינת האפליקציה. התרשים יכול להראות לכם אילו משאבים אחראים לזמני טעינה ארוכים. הכנו לכם רשימת משימות שיעזרו לכם לשפר את ביצועי הטעינה:

  • העבירו כמה שיותר נכסים בחיבור אחד.
  • טעינה מראש או אפילו משאבים מוטבעים שנדרשים לעיבוד הראשוני ולאינטראקטיביות.
  • כדי לשפר את ביצועי הטעינה הנתפסים, כדאי לרנדר מראש את האפליקציה.
  • כדאי להשתמש בפיצול קוד אגרסיבי כדי לצמצם את כמות הקוד שנדרשת לאינטראקטיביות.

בחלק השני נדון בדרכים לשיפור הביצועים בזמן הריצה במכשירים עם מגבלות משמעותיות.