רווחים:
- יכולת לכתוב פונקציות, מחלקות ומודולים ל-AI עם הגדרות קלט-פלט ואילוץ ברורות
- יכולת להשתמש בבינה מלאכותית כשותף לתכנות זוג ולהתקדם צעד אחר צעד, בנתחים קטנים ניתנים לאימות
- יכולת לתפוס שגיאות לוגיקה ושגיאות קצה על ידי קומפילציה של הקוד שנוצר על ידי AI והפעלתו עם דוגמאות קטנות
תכנות זוגי הוא כאשר שני מפתחים עובדים על אותה בעיה, כאשר אחד כותב והשני מתקן. קידוד עם AI הוא הגרסה הדיגיטלית של מערכת היחסים הזו בדיוק: אתה קובע את הכיוון, האילוצים וקריטריוני הקבלה; AI מייצר טיוטה מהירה; אתה מאמת כל שלב על ידי קומפילציה ובדיקה שלו. המלכודת הגדולה ביותר כאן היא לומר לבינה מלאכותית "כתוב לי את היישום הזה מתחילתו ועד סופו" ולקבל באופן עיוור בלוק של 200 שורות. תכנות זוגיות טוב מתקדם בצעדים קטנים: כל שלב צריך להיות מובן, ניתן לבדיקה והפיך.
ביחידה זו תלמדו כיצד להדפיס פונקציות, מחלקות ומודולים עם חוזה קלט-פלט ברור; כיצד להדריך AI צעד אחר צעד; ונראה כיצד לתפוס שגיאות לוגיקה ו-Edge Case על ידי הפעלת הקוד שהוא מייצר עם דוגמאות קטנות. המטרה היא לא מהירות, אלא מהירות מאומתת.
מושגים: חוזה קלט-פלט: הגדרה ברורה של איזה קלט לוקחת פונקציה ואיזו התנהגות פלט ושגיאה היא מבטיחה. מקרה קצה: קלט שאינו רגיל אך יכול להתרחש בפועל (ריק, אפס, שלילי, גדול מאוד, ריק). פיתוח מצטבר: ממשיכים עם חלקים קטנים ועובדים ואימות כל שלב.
הדפסת קוד עם חוזה נטו
הבסיס של קוד איכות הוא להגדיר בדיוק "מה אתה רוצה" לפני תחילת העבודה. בעת כתיבת פונקציה ל-AI, תן לה חמישה דברים: שפה וגרסה, סוגי קלט ומשמעויות, פלט, תנאי שגיאה ואילוצים (ביצועים, איסור ספרייה חיצונית, סגנון). זה מונע מה-AI לנחש.
- כתוב את החוזה. קלט, פלט, שגיאה, אילוץ.
- בקשו יחידה קטנה. פונקציה עם אחריות אחת; זה לא מודול ענק.
- בקש חסימת בדיקה. הוסף כמה ריצות/בדיקות לדוגמה ליד הקוד.
- קומפיל והרץ. נסה את זה עם מקרים קצה, ודא את הפלט בעין.
- עבור לשלב הבא. ברגע שיצירה מאושרת, בנה עליה.
שורת פונקציה חוזה: "כתוב פונקציה עבור TypeScript 5. מטרה: לחשב את הכמות הכוללת של פריטים בעגלת קניות. קלט: { מחיר: מספר, כמות: מספר }[] מערך. פלט: מספר (סה"כ). כללים: זרוק שגיאה אם הכמות או המחיר שליליים; החזר 0 עבור מערך ריק; הוסף כמות שגיאה עגולה ל-2. 5 מקרי בדיקה מתחת לפונקציה (רגיל, ריק, כמות שלילית, מחיר עשרוני, פריט בודד).
מנחה AI כזוג
התקדמות טובה בתכנות זוגיות היא דיאלוג ולא בקשה אחת גדולה. ראשית, בקש את השלד והפעל אותו; לאחר מכן הוסף מצב קצה; ואז לתקן באג. גישה זו שומרת על הקוד מובן ומעניקה לך שליטה בכל שלב.
הנחית התקדמות מצטברת: "נכתוב קורא שקורא קובץ CSV וממיר את השורות לאובייקט. בוא נעבור שלב אחר שלב, נמשיך לשלב הבא מבלי שאאשר כל שלב. שלב 1: פשוט כתוב את השלד שמפצל את הקובץ לשורות ומפריד את שורת הכותרת. אל תוסיף המרת טקסט או טיפול בשגיאות קצר עדיין."
הסבר ונמק את הנחיית הקוד: "הסבר את הפונקציה שכתבת זה עתה, לא שורה אחר שורה, אלא החלטה אחר החלטה: איזו החלטה עיצובית קיבלת ולמה, באיזה מקרה קצה טיפלת ואיך, אילו מקרים החרגת בכוונה? רשום בקוד 3 הנחות שאסור לי לפספס".
טיפ: אל תקבל את הקוד שנוצר בינה מלאכותית מבלי להבין אותו. "תסביר לי את זה, אילו הנחות הנחת?" השאלה גם חושפת שגיאות נסתרות וגם מאפשרת לך להגן על הקוד הזה, מכיוון שהקוד נשאר באחריותך. הכנסת קוד שאתה לא מבין לייצור זה כמו לשלוח חוזה בלי לחתום עליו.
הנחיה חלשה / הנחיה חזקה
WEAK:"כתוב פונקציית מיון."(תוצאה: איזו שפה, מה ממוין, האם היא יציבה, מהי אילוץ הביצועים, קוד מעורפל וכנראה לא מתאים לדרישה.)STRONG:"עבור Java 17, כתוב שיטה שממיינת אובייקט List<Employee> תחילה לפי מחלקה (אלפביתית), ואז לפי שכר (DO NOT REPLACE the new department). אחרון הסבר את מורכבות השיטה בשורת ההערה ציין הוסף בלוק בדיקה ראשי עם 4 דוגמאות.
הנחיה עוצמתית; כולל קריטריון מיון (שתי רמות), כלל תופעת הלוואי (החלפת מקור), התנהגות אפס וציפייה לבדיקה. ללא הפרטים הללו, AI מייצרת פתרון סביר אך לא נכון; למשל זה עלול להשחית את הרשימה המקורית וזה יוביל לשגיאה שקטה במקום אחר.
אימות עם מארזי אדג' ודוגמאות קטנות
הקוד שעובד בתרחיש המאושר אינו הקוד הנכון. הכריח במודע כל פונקציה שנוצרת:
סוג מארז קצה
קלט לדוגמה
התנהגות צפויה
קלט ריק
מערך/מחרוזת ריק
לא שגיאה, תוצאה ריקה לוגית
אפס/שלילי
0, -1
התנהגות מוגדרת ונכונה
ערך רב
מיליוני שיאים
בקרת הצפה/ביצועים
null/לא מוגדר
חסר מקום
שגיאה מבוקרת או ברירת מחדל
שכפול/חריג
חוזר על עצמו, סדר הפוך
תוצאה נכונה
מיני מארזים
מקרה 1 - שגיאת עיגול שקטה. בינה מלאכותית כותבת פונקציה שאוספת כסף עם סוגים עשרוניים (צפים); 0.1 + 0.2 נותן 0.300000000000000004. השגיאה נפתרת כאשר המהנדס מוסיף את הכלל "עגל ל-2 ספרות והשתמש בפרוטות שלמות". כלל של 3 שורות מונע אלפי אגורות של שונות בהתאמה החודשית.
מקרה 2 - מלכודת תופעות לוואי. ה-AI כותב שיטה ש"ממיין" רשימה, אך משנה את הרשימה המקורית במקום. התנהגות בלתי צפויה מתרחשת מכיוון שמודול אחר משתמש באותה רשימה. אם אילוץ "שנה מקורי" היה בהנחיה, השגיאה לעולם לא תתרחש; נקלע לבדיקת קוד ומונע שעתיים של איתור באגים.
מקרה 3 - רווחים צעד אחר צעד. מפתח מדפיס מודול ייבוא של 150 שורות בבת אחת; כשהוא מוצא טעות, הוא לא יכול למצוא מאיפה היא באה. מפתח אחר מחלק את אותה עבודה ל-5 שלבים קטנים, בודק כל שלב ב-2 דקות ותופס את השגיאה מיד בשלב ה-3.
טעויות נפוצות
- הדפסת בלוקים גדולים בבקשה אחת. קוד מסוכן שקשה להבין וניפוי באגים נולד.
- מבקש קוד מבלי לתת חוזה. אם שגיאת קלט-פלט היא מעורפלת, בינה מלאכותית תנחש וטועה.
- רק בוחן את התרחיש המאושר. אם לא מנסים קלט ריק, null, שלילי וגדול, השגיאה נשארת לייצור.
- מקבל בלי להבין. הקוד שאתה לא חושף הוא חוב שאתה לא יכול להגן עליו.
- התעלמות מסוגים רגישים כמו תופעות לוואי וכסף/תאריך. כסף צף עם היסטוריה נצחית הוא מקור קלאסי לטעות.
לסיכום
כתיבת קוד עם AI היא תכנות זוגיות ממושמע: חוזה ברור, צעדים קטנים, בנייה ובדיקה בכל שלב. מתן רביעיית הקלט-פלט-שגיאה-אילוץ מההתחלה קובע את איכות הקוד. הסבר הקוד שהוא מייצר והכריחתו עם מקרי קצה מעלה על פני השטח את השגיאות המוסתרות תחת התרחיש המאושר. מקור המהירות אינו קבלה עיוורת; הוא טיוטה מהירה בתוספת אימות מהיר.
משימת יישום
בחר פונקציה קטנה אך אמיתית (למשל סה"כ סל, הפרש תאריכים, ניתוח טקסט). הדפס באמצעות שורת הפונקציה החוזה; הוסף לידו לפחות 5 תרחישי בדיקה. הפעל את הקוד ונסה 5 מקרים קצה במודע, תוך שימוש בטבלה כמדריך. מצא באג לפחות במקרה קצה אחד (אם לא, תכנן קלט חדש כדי לאלץ את הפונקציה), תקן אותו עם AI, וודא על ידי בדיקה חוזרת שהתיקון עבד.
רשימת בדיקה
- [ ] כתבתי חוזה שכולל קלט, פלט, שגיאות ואילוצים.
- [ ] יצרתי את הקוד בצעדים קטנים במקום בלוק אחד גדול.
- [ ] הוספתי בלוק בדיקה/הרצה לדוגמה ליד הקוד.
- [ ] בדקתי במודע לפחות 5 מקרי קצה.
- [ ] הסברתי את הקוד ל-AI ובדקתי את ההנחות שלו.
- [ ] תיקנתי את השגיאה שנמצאה ואישרתי את התיקון על ידי בדיקה חוזרת.