למה קוד נקי יכול להסתיר מערכת לא ברורה

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

וזה טוב. אבל חשוב להבין דבר אחד בסיסי:

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

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

אפשר לקרוא פונקציה ולחשוב: “זה פשוט. היא עושה דבר אחד קטן”.

ובמציאות:

• היא מחכה לרכיב אחר
• היא נתקעת לפעמים
• והיא מגיבה אחרת כשיש עומס

הקוד נראה רגוע. ההתנהגות - פחות.

הסיבה העיקרית לכך היא abstraction

abstraction נועדה לפשט. להסתיר פרטים כדי שיהיה נעים לעבוד.

אבל לפעמים היא מסתירה גם דברים חשובים:

• כמה זמן זה באמת לוקח
• האם יש תלות חיצונית
• ומה קורה כשזה לא מצליח מיד

הקוד נראה “נקי”. המחיר - לא נראה.

הטעות הנפוצה

וכאן נוצרת הטעות הנפוצה:

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

אבל מערכת יכולה להיות:

• עם קוד מסודר מאוד
• עם שמות מצוינים
• ועם מבנה ברור

ובכל זאת:

• להיות רגישה לעומס
• להתנהג אחרת ממה שמצפים
• ולהפתיע דווקא ברגעים חשובים

לא כי הקוד רע, אלא כי ההתנהגות לא גלויה.

המשל

כפתור עם כיתוב ברור: “הפעל”.

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

הכפתור ברור. מה שקורה מאחוריו - לא.

מה חוץ מקוד נקי צריך

קוד נקי הוא יתרון גדול. אבל הוא רק נקודת התחלה.

כדי להבין מערכת באמת צריך גם:

• לדעת איפה היא מחכה
• מתי היא מאטה
• ומה קורה כשיש עומס

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

כי בסוף, לא הקוד רץ בפרודקשן - המערכת היא זו שרצה.