איך יצרנו PDF עם 100,000 עמודים - ומה למדנו בדרך

בהתחלה הכול היה קטן ופשוט.

כמה שאלות, כמה מבחנים, כמה תלמידים.

המערכת מייצרת מבחן, מערבבת את השאלות והתשובות, יוצרת PDF - והכול עובד.

יופי.

ואז, כמו שקורה להרבה מפתחים, הגיעה המחשבה:

"רגע... אבל מה יקרה אם נעשה את זה באמת?"

לא 30 מבחנים.

לא 100.

אפילו לא 1,000.

100,000.

למה?

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

אז החלטתי לעשות ניסוי.

וניסוי כזה, כידוע, מתחיל בדרך כלל במילים:

"נו, מה כבר יכול לקרות?"

---

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

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

כדי שהניסוי יהיה אמיתי, לא רציתי להשתמש בטקסט סתמי.

בחרתי את הפרק הראשון בספר בראשית.

עברית אמיתית.

טקסט ארוך.

והכי חשוב - עם ניקוד.

כי אם כבר לעשות ניסוי, למה לעשות לעצמנו חיים קלים?

---

ואז גיליתי שעברית היא לא בדיוק "טקסט"

מי שעובד עם עברית ביום־יום לא חושב על זה יותר מדי.

אנחנו כותבים מימין לשמאל.

יש לנו ניקוד.

יש מספרים.

יש סוגריים.

יש לפעמים מילים באנגלית בתוך משפט בעברית.

והכול פשוט... עובד.

לפחות מבחינתנו.

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

לדוגמה, ניקוד.

מבחינתנו:

שָׁלוֹם

מבחינת המחשב, זה לא בהכרח "סימן אחד".

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

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

אחרת אפשר לקבל עברית שנראית כאילו המחשב החליט שהוא רוצה להיות יצירתי.

---

ואז הגיע ה־RTL

עברית הולכת מימין לשמאל.

אנגלית הולכת משמאל לימין.

מספרים? הם אוהבים לעשות מה שבא להם.

ועכשיו תכניסו את שלושתם לאותו משפט.

ברוכים הבאים לעולם של טקסט דו־כיווני.

או בשם המקצועי שלו: BiDi.

זה אחד הדברים שאנחנו, כבני אדם, פשוט עושים באופן טבעי.

המוח שלנו רואה:

המבחן כולל 25 שאלות.

ולא מתרגש מזה בכלל.

המחשב, לעומת זאת, צריך להבין מה הולך לאן.

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

---

אבל החלק המעניין באמת הגיע בסוף

אחרי כל העבודה, הגענו לרגע המיוחל.

ה־PDF נוצר.

100,000 עותקים.

קובץ אחד.

גדול.

מאוד.

פתחתי את קורא ה־PDF.

חיכיתי.

וחיכיתי עוד קצת.

ואז הבנתי:

הוא לא הולך להיפתח.

לא "קצת איטי".

לא "תנו לו דקה".

פשוט לא.

וזה היה דווקא שיעור מצוין.

כי יש הבדל גדול בין:

"הצלחתי לייצר קובץ."

לבין:

"הצלחתי לייצר קובץ שמישהו באמת יכול להשתמש בו."

---

כאן מתחילים ללמוד באמת

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

מייצרים PDF - הוא נפתח.

מייצרים עוד אחד - גם הוא נפתח.

מייצרים מאה - עדיין בסדר.

ואז מגיעים ל־100,000 ומגלים שהמחשב אומר:

"חמוד, זה כבר מוגזם."

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

לא רק איך ליצור את הקובץ.

אלא איך ליצור אותו בצורה יעילה.

איך לשמור על איכות הטקסט.

איך להתמודד עם עברית וניקוד.

איך לא להפוך את הקובץ למפלצת שאף תוכנה לא רוצה לפתוח.

ואיך לעשות את כל זה בלי שהמערכת תתמוטט באמצע.

---

למה בכלל לעשות ניסוי כזה?

האמת?

אין סיבה שבית ספר יצטרך להדפיס 100,000 מבחנים במכה אחת.

וזו בדיוק הנקודה.

100,000 לא היה מספר שאנחנו צריכים. הוא היה מספר שאנחנו רוצים שהמערכת תוכל להתמודד איתו.

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

אבל זה לא אומר שהיא באמת מוכנה לעולם האמיתי.

רציתי לדעת מה יקרה כשהמספרים יתחילו להיות גדולים.

כמה מהר המערכת תעבוד?

כמה גדול יהיה הקובץ?

איפה הדברים יתחילו להשתבש?

מה יקרה לעברית?

ומה יקרה כשכל הדברים האלה קורים ביחד?

---

ולפעמים צריך פשוט לשבור את המערכת

זה אולי אחד הדברים הכי חשובים שלמדתי מהניסוי הזה.

אם אתה רוצה לדעת אם משהו באמת עובד, אל תיתן לו תנאים מושלמים.

תן לו עבודה.

תן לו הרבה עבודה.

ואז עוד קצת.

ואם אפשר - תן לו עבודה מוגזמת לחלוטין.

במקרה שלנו, זה היה ספר בראשית, עם ניקוד, בעברית, מימין לשמאל, בתוך 100,000 עותקים של PDF.

כי אם כבר לבדוק...

אז עד הסוף.

---

ומה יצא לנו מזה?

בסופו של דבר, לא היינו צריכים 100,000 מבחנים.

היינו צריכים את הניסוי.

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

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

ובעיקר, הוא הזכיר לנו משהו חשוב:

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

היא נמדדת גם במה שקורה כשאומרים לה:

"יאללה, בואי נראה מה קורה עם 100,000."

ואז לוחצים Enter.