עיצוב Agent-First: למה Zero קיימת ועל מה היא מוותרת

השאלה ש-Zero שואלת

ההנחה שמאחורי Zero פשוטה: כשסוכן AI, ולא רק אדם, קורא, כותב ומתקן קוד, איך השפה עצמה רוצה להיראות?

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

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

עיקרון 1: משטח קטן וסדיר

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

Zero שומרת בכוונה על משטח זעיר:

• צורת קישור אחת (let).
• צורת פונקציה אחת (fun, ואופציונלית pub).
• לולאה אחת כרגע (while).
• דרך אחת למדל טיפוסי מכפלה (shape).
• דרך אחת למדל טיפוסי סכום עם מטען (choice).
• דרך אחת למדל סכומים עם תוויות (enum).
• מבנה אחד להתאמת תבניות (match).

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

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

עיקרון 2: אפקטים מפורשים

רוב השפות מאפשרות לכל פונקציה, בכל מקום, לבצע קלט/פלט. console.log ב-JavaScript, printf ב-C, print ב-Python. החתימה של הפונקציה לא נותנת שום רמז אם היא עשויה לכתוב לקובץ או לפנות לרשת. הדרך היחידה לדעת היא לקרוא את הגוף שלה, ברקורסיה.

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

• קלט/פלט מוגבל על ידי היכולת World. פונקציה שלא מקבלת World לא יכולה לבצע קלט/פלט. מערכת הטיפוסים אוכפת את זה.
• כישלון מוגבל על ידי raises ו-check. פונקציה שעלולה להיכשל מצהירה על כך בחתימה שלה. כל קורא מכיר בכך עם check או מבנה מפורש אחר.

מהחתימה של פונקציה בלבד אפשר לענות על שתי שאלות שחשובות מאוד לסוכן (או לכלי ניתוח סטטי, או לבודק אנושי):

• "האם זה עלול לגעת בעולם החיצון?": כן, אם ורק אם מופיע World.
• "האם זה עלול להיכשל?": כן, אם ורק אם מופיע raises.

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

המחיר הוא העברת פרמטרים. את הערך World מעבירים לכל מקום שצריך בו קלט/פלט; פסוקית raises חוזרת בכל מקום שבו שגיאות זורמות. Zero מקבלת את זה כמחיר של התכונה.

עיקרון 3: כלים דטרמיניסטיים

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

דיאגנוסטיקות JSON הן הדוגמה המרכזית:

{
    "code": "NAM003",
    "message": "unknown identifier",
    "line": 3,
    "repair": { "id": "declare-missing-symbol" }
}

שלוש תכונות הופכות את זה לשונה משגיאת קומפיילר רגילה:

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

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

עיקרון 4: ספרייה שחיה בתוך השפה

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

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

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

על מה Zero מוותרת

לכל החלטת עיצוב יש מחיר. הנה הפשרות הכנות ש-Zero עושה:

• מלל על פני תמציתיות. פונקציות טהורות לא צריכות World. פונקציות שמבצעות קלט/פלט כן. שגיאות מופיעות בחתימות. התוצאה היא יותר הערות מאשר בקוד מקביל ב-JavaScript או ב-Python.
• מפורש על פני קסם. אין מטא-תכנות רפלקטיבי, אין decorators שעוטפים התנהגות בשקט, אין משתנים גלובליים מרומזים. דברים שנראים כאילו הם "פשוט עובדים" בשפות דינמיות צריך לחבר ידנית.
• סטטי על פני דינמי. טיפוסים נדרשים על פרמטרים, על ערכי החזרה ועל שדות של shape. הקומפיילר עושה הרבה עבודה; המחיר הוא שכל חתימה היא משהו שמחבר (או מחולל) צריך לכתוב.
• יציבות על פני קצב שינוי. השפה נמצאת לפני גרסה 1.0 ומשתנה מהר, אבל כוונת העיצוב היא לנעול את המשטח ברגע שהוא מתייצב. המחיר הוא שהוספת פיצ'ר נוחות חכם בהמשך תהיה קשה יותר, כי הרף לתוספות הוא "האם זה עוזר לסוכן יותר ממה שזה עולה לו?"

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

מה Zero לא מנסה להיות

כמה טענות שליליות שכדאי לומר במפורש:

• לא "העתיד של כל התכנות". Zero היא השערה, לא מניפסט. ההשערה היא שמגבלות agent-first מייצרות שפה שימושית. השאלה אם שפות מרכזיות צריכות לאמץ את המגבלות האלה היא שיחה נפרדת וארוכה יותר.
• לא פיצ'ר של פלטפורמת הפריסה של Vercel. למרות שהיא מגיעה מ-Vercel Labs, Zero לא קשורה ל-Next.js או לאירוח ב-Vercel. זו שפת מערכות עצמאית.
• לא תחליף ל-Rust, Go או Zig בסביבת ייצור. לפני גרסה 1.0. ניסיונית. השתמשו בה כדי ללמוד ולתת משוב; אל תשלחו איתה עדיין תוכנה ללקוחות.
• לא גמורה. חלקים מהספרייה הסטנדרטית, התחביר לשינוי ערכים, צורות הטיפול בשגיאות והמגבלות על generics עשויים כולם להשתנות לפני 1.0.

מה מעניין גם אם לא משתמשים בה

גם אם לא תכתבו אף שורת Zero, הניסוי מלמד הרבה:

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

מה לקרוא בהמשך

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

• המאגר של Zero בכתובת github.com/vercel-labs/zero: דוגמאות, קוד מקור ו-AGENTS.md עם הצהרת הכוונות של המתחזקים עצמם.
• האתר הרשמי בכתובת zerolang.ai: הוראות התחלה וההיכרות הקנונית.

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