מה זה Zero? שפת התכנות לסוכני AI

שפה שעוצבה סביב הקוראים שלה

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

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

Zero נבנית על ידי Vercel Labs, האתר שלה הוא zerolang.ai, והקוד הפתוח שלה נמצא ב-github.com/vercel-labs/zero. קובצי מקור מסתיימים ב-.0.

pub fun main(world: World) -> Void raises {
    check world.out.write("hello from zero\n")
}

חמישה דברים בקטע הזה, pub, World, raises, check וה-world.out.write המפורש, כבר אומרים לכם הרבה על הדרך שבה Zero חושבת. נפרק כל אחד מהם בהמשך.

"הכול מפורש"

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

• אין garbage collector חובה.
• אין מקצה זיכרון נסתר.
• אין סביבת ריצה אסינכרונית מרומזת.
• אין משתנים גלובליים קסומים: אין stdout סביבתי, אין process.env, אין מערכת קבצים מרומזת.

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

יכולות, לא משתנים גלובליים

הדרך שבה Zero מטפלת בקלט/פלט היא הדוגמה הברורה ביותר לפילוסופיה. אין פונקציית print גלובלית. הפלט עובר דרך ערך World שסביבת הריצה מעבירה ל-main:

pub fun main(world: World) -> Void raises {
    check world.out.write("hello\n")
}

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

היכולת World מעמיקה ברעיון הזה.

כישלון מפורש עם raises ו-check

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

fun validate(ok: Bool) -> i32 raises { InvalidInput } {
    if ok == false {
        raise InvalidInput
    }
    return 42
}

pub fun main(world: World) -> Void raises {
    check validate(true)
    check world.out.write("ok\n")
}

raises { InvalidInput } על validate פירושו "הפונקציה הזו עלולה להיכשל עם InvalidInput". check במקום הקריאה פירושו "אם זה נכשל, העבר את השגיאה למעלה". אי אפשר לזרוק שגיאה לפח בטעות: היא מופיעה בחתימת הפונקציה שלכם, או שהקומפיילר עוצר אתכם. ראו Raises ו-Check לתמונה המלאה.

קומפיילר שמדבר עם סוכנים

החלק הייחודי ביותר של Zero הוא לא פיצ'ר תחבירי, אלא הפלט של הקומפיילר. הריצו zero check --json על תוכנית שבורה ותקבלו בחזרה משהו כזה:

{
    "ok": false,
    "diagnostics": [
        {
            "code": "NAM003",
            "message": "unknown identifier",
            "line": 3,
            "repair": { "id": "declare-missing-symbol" }
        }
    ]
}

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

1. קודי שגיאה יציבים. NAM003 פירושו "unknown identifier" היום, ויהיה פירושו בדיוק את זה בגרסת הקומפיילר הבאה. סוכנים יכולים להתאים לפי הקוד בלי לנתח אנגלית.
2. מטא-דאטה מובנה לתיקון. השדה repair מציין סוג תיקון שהקומפיילר חושב שיפתור את השגיאה. סוכן יכול לשלוף את התוכנית עם zero fix --plan --json ולהחיל אותה.
3. לא צריך לנתח טקסט חופשי. כל העניין הוא שסוכן לא יצטרך לפרש הודעה ידידותית לבני אדם כדי להחליט מה לעשות הלאה.

דיאגנוסטיקות JSON עובר על הפורמט בפירוט.

משטח קטן בכוונה

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

המשמעות היא שתמצאו:

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

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

מה Zero לא

כדי לתאם ציפיות:

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

מתי כדאי לנסות את Zero כבר היום

כדאי לנסות את Zero היום אם מעניין אתכם:

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

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

הבא בתור: התקנת Zero

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