על ליגטורות, שפות תכנות וסמיוטיקה טיפוגרפית

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

הפונט המדובר נקרא FiraCode. הוא הרחבה לפונט מוקדם יותר, Fira Mono, ונועד לקריאת וכתיבת קוד בסביבות פיתוח. היחוד שלו הוא בתמיכה בליגטורות – “משלבי אותיות”, כך אומרת לי ויקיפדיה – לסימנים מקובלים בעולם התכנות.

ליגטורות, קורבן ההצלחה של עצמן

ראשית, מה זה ליגטורות? ליגטורה היא שילוב טיפוגרפי של שתי אותיות סמוכות. למשל, הצירוף AE בכתב הלטיני ניתן לכתיבה כליגטורה, Æ, וכך גם ה-ß הגרמני, שניתן לפרק לאותיות ss (או sz).

בעברית הן פחות נפוצות. למען האמת, הייתי בטוח שהן לא קיימות בכלל, אבל גיליתי שבכתבי קודש מסוימים מקובל לחבר “א” ל-“ל” ל-“ﭏ”,שבקושי רואים ולא בטוח שבכלל עובד בכל הפונטים ((לאור הנדירות שלהן בעברית, לא ברור לי למה דווקא השם “ליגטורה” נבחר לתוכנה שהיתה המובילה בארץ, במשך שנים, בזיהוי ממוחשב (OCR) של כתב עברי)). בכל מקרה, ליגטורות נתמכות בימינו, טכנית ע”י מרבית המחשבים. לפונטים יש את האפשרות הטכנית לזהות אוטומטית כי צמד אותיות מסוים נכתב ברצף, ולהכניס, במקום שתי האותיות, את הליגטורה.

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

טיפוגרפיה יצירתית בעולם מוגבל

ועכשיו נחזור לעולם התכנות. רוב שפות התכנות שבשימוש נפוץ בימינו מורכבות ברובן משילוב של פקודות המבוססות על הכתיב הלטיני (if, while, def, class), יחד עם שימוש יצירתי בסימני פיסוק. למה סימני פיסוק? כי שפות תכנות רוצות להביע הרבה רעיונות שהכתיב הלטיני לאו דווקא מאד יעיל בהן, כמו יחסים מתמטיים (שווה, גדול מ-,), פעולות על מידע (השמה למשתנה, חיבור טקסט) או סתם מידע נוסף שהמלל עצמו לא מעביר (סימון חלק מהקוד כהערה שאין לבצע). חלק מהפעולות הללו נראות אותו דבר ברוב שפות התכנות (>= לסימון שווה-או-גדול-מ-, למשל), וחלקם ספציפיים לשפות ספציפיות או למשפחות של שפות דומות (== לפעולת השוואה, => לסימון פונקציית lambda. לא משנה מה זה כרגע).

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

זו הסיבה שהרבה מהפקודות המקובלות היו ניסיון “לצייר”, באמצעות תווי מקלדת רגילים, סימנים מתמטיים מורכבים יותר. למשל הסימון לבדיקת אי-שוויון בשפות רבות הוא != (סימן קריאה+שווה), שמנסה לדמות לסימן אי השוויון המתמטי ≠ (שווה עם קו עליו). וסימן החץ שמשמש בתחום במדמ”ח שנקרא lambda calculus שמייצג פונקציה שפועלת על קלט (כשהחץ מייצג את המעבר מהקלט לפלט) הפך בשפות רבות להיות => (שווה+גדול מ-) או –> (מקף+גדול מ-), שנראים קצת כמו חץ, במגבלות הז’אנר. הם כולם נולדו כפשרה – הרצון להביע רעיונות מורכבים באמצעות סימנים מוסכמים, אבל רק כאלה שאפשר להקליד בקלות.

ליגטורה כפונדמנטליזם – חזרה למקורות

אז בואו נחזור חזרה לפונט החדש שהתקנתי, אם כך. הקוראים הערניים ששמו לב שביליתי כבר כחמש-צמאות מילים בלדבר על שני דברים שונים לחלוטין בטח כבר ינחשו מה עומד לקרות עכשיו: FiraCode (ועוד כמה שדומים לו) משתמשים בליגטורות כדי לבטל את הצורך בפשרה. מעתה, אם אני אכתוב את קוד עם פקודת !=, אני אראה על המסך ≠ – בלי שאצטרך לדעת איך להקליד את זה. אם אני אכתוב פונקציה כזו:

person => person.Name

המקבלת מידע על אדם ומחזירה את השם שלו, אני אראה את הכאילו-חץ הזה כפי שהוא היה רוצה להראות:

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

OMG! Setting @FiraCode to be my monospaced font in Chrome led to a very important discovery: I now understand the bind operator! >>=

— Igal Tabachnik (@hmemcpy) August 23, 2016

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

עם הסימן של החץ שהבאתי למעלה, או עם ה-Bind בהודעה שקישרתי, יש לליגטורות יתרון ברור, והוא שהסימנים הללו הם יחסית חדשים בנוף המיינסטרים של שפות התכנות – הרבה מהם נכנסו לאורך 10-15 השנים האחרונות ((נכנסו למיינסטרים, כן. בבקשה אל תתחילו לאזכר כאן שפות תכנות שהשתמשו ב-bind ו-lambda עוד במאה ה-18. הן קיימות, כן, אני יודע. אבל לא בהיקף של שפות כמו C++ ו-Java בשנות ה-90 וה-2000)) עם שפות כמו scala ו-haskell ועדכונים לשפות ותיקות כמו C# ו-javascript, ולכן המשמעות שלהן הרבה פחות צרובה במוח של רוב המתכנתים. רוב המתכנתים שאני מכיר יצטרכו לבלות שניה או שתיים בלהבין מה המשמעות של >>=, בעוד הליגטורה (למי שמכיר את פעולת ה-bind) תהיה ברורה הרבה יותר.

אבל חוץ מהחסרון הזה, שאולי ליגטורות באות לפתור בעיה שלא באמת קיימת, בעיה שהיתה פותרת את עצמה עם הזמן והנסיון, יש כאן עוד בעיה, והיא שרוב שפות התכנות מאד משתדלות להיות פשוט טקסט, לא פחות ולא יותר. שאם אני אקרא את אותו הקוד גם מדף מודפס, אני אוכל להבין אותן בדיוק כמו אם אקרא אותו על מסך המחשב. What you see is what you get – אם אני רואה תו מסוים בקוד, זה התו שהמחשב גם רואה, ומבצע את הפעולות על פיו. אבל כאן נוצרת לנו שכבת תרגום בין מה שהמחשב רואה (!=) לבין מה שאני רואה (≠). האם זה יפריע לאנשים ללמוד את התחביר האמיתי של השפה, לא זה שמוסתר מאחורי הסימנים היפים? האם זה יוביל לבאגים שנובעים מכך שאני, המתכנת, לא באמת קורא את אותו קוד שהמחשב מבצע? אולי. אני לא יודע. אני בינתיים אשאר עם האמביוולנטיות שלי.