כיצד עקרונות קוד נקי משנים את חווית התכנות שלך

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

הקונספט גובש על ידי רוברט סי. מרטין, "הדוד בוב", בספרו " קוד נקי: מדריך לאומנות תוכנה זריזה " (2008), שנותר הספר הקנוני בנושא. ספרו של מרטין פאולר, "שיפוץ מחדש: שיפור עיצוב הקוד הקיים", עוסק בבעיה המשלימה: מה לעשות כאשר קוד קיים אינו נקי וצריך להיות נקי. יחד, שתי עבודות אלו מגדירות את הבסיס האינטלקטואלי של תרגול קוד נקי. מדריך זה מכסה את עקרונות המפתח שלהן עם דוגמאות קוד עובדות בשפות הנפוצות ביותר, כולל RPG ו-PL/I עבור מפתחים המתחזקים מערכות מדור קודם ארגוני.

מהו קוד נקי?

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

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

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

עקרונות קוד נקי: מדריך מהיר

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

עיקרון	חוק הליבה	בעיה שזה מונע
שמות בעלי משמעות	שמות צריכים לחשוף כוונה, משתנים, פונקציות, מחלקות	פענוח תקורה קוגניטיבית של מה x, tmp, או obj מייצג בפועל
פונקציות קטנות	פונקציות עושות דבר אחד; מתאימות למסך אחד	מונוליטים בלתי ניתנים לבדיקה ובלתי קריאים שמערבבים תחומי אחריות
אחריות יחידה	לכל קורס/מודול יש סיבה אחת לשינוי	שיעורי אלוהים שנשברים כאשר אחד מתריסר דברים לא קשורים משתנה
יבש (אל תחזור על עצמך)	לכל פיסת ידע יש ייצוג אחד	תיקוני באגים יושמו בעותק אחד אך לא באחרים; סטייה לוגית
נשיקה (תשמור על זה פשוט)	מעדיפים את הפתרון הפשוט ביותר שעובד	קוד מהונדס יתר על המידה שפותר בעיות שאין לאף אחד
יאגני (אתה לא הולך להזדקק לזה)	אל תבנה תכונות עד שהן נחוצות	קוד ספקולטיבי מת שמוסיף מורכבות ללא תועלת
עקרון פתוח/סגור	פתוח להארכה, סגור לשינויים	קוד ששובר התנהגות קיימת בעת הוספת התנהגות חדשה
הפרדת דאגות	אחריות שונה במקומות שונים	קוד סבוך שבו שינוי דבר אחד שובר דברים לא קשורים
הימנעו מתגובות על "מה"; השתמשו בהן על "למה"	הקוד מסביר מה; הערות מסבירות למה	תגובות מיושנות שמטעות יותר מאשר מוסיפות מידע
כלל הצופים	השאירו את הקוד נקי יותר ממה שמצאתם אותו	דעיכה הדרגתית באיכות באמצעות הזנחה הדרגתית

עקרונות הליבה של קוד נקי מוסברים

יבש, אל תחזור על עצמך

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

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

נשיקה, תשמור על זה פשוט

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

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

יאגני, אתה לא תצטרך את זה

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

שמות בעלי משמעות

שמות הם מנגנון התקשורת העיקרי בקוד המקור. פונקציה בשם process() לא מתקשר דבר לגבי מה שהיא מעבדת, מתי, או מה היא מחזירה. פונקציה בשם calculateMonthlyInterest() מתקשר בצורה מדויקת.

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

פונקציות קטנות

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

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

קוד נקי ב-Java

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

תאווה

// Before: unclear names, mixed responsibilities, magic numbers
public double calc(int x, int y) {
    double r = 0;
    if (y > 1000) {
        r = x * y * 0.1;
    } else {
        r = x * y * 0.05;
    }
    return r;
}

// After: meaningful names, single responsibility, named constants
private static final double PREMIUM_DISCOUNT_RATE = 0.10;
private static final double STANDARD_DISCOUNT_RATE = 0.05;
private static final int PREMIUM_THRESHOLD = 1000;

public double calculateDiscount(int quantity, int unitPrice) {
    double subtotal = quantity * unitPrice;
    return isPremiumOrder(unitPrice) 
        ? subtotal * PREMIUM_DISCOUNT_RATE 
        : subtotal * STANDARD_DISCOUNT_RATE;
}

private boolean isPremiumOrder(int unitPrice) {
    return unitPrice > PREMIUM_THRESHOLD;
}

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

תאווה

// Clean Java: streams over imperative loops
List<String> activeUserEmails = users.stream()
    .filter(User::isActive)
    .map(User::getEmail)
    .collect(Collectors.toList());

קוד נקי ב-Python

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

פִּיתוֹן

# Before: vague names, long function, no separation
def do_stuff(d):
    res = []
    for i in d:
        if i['a'] > 18:
            res.append(i['n'].upper())
    return res

# After: meaningful names, separated concerns, Pythonic style
def get_adult_names_uppercase(users: list[dict]) -> list[str]:
    return [
        user["name"].upper()
        for user in users
        if user["age"] > 18
    ]

פִּיתוֹן

# Clean Python: context managers for resource handling
# Before: manual, error-prone
f = open("data.txt")
data = f.read()
f.close()

# After: guaranteed cleanup, self-documenting intent
with open("data.txt") as f:
    data = f.read()

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

קוד נקי ב-JavaScript ו-TypeScript

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

JavaScript

// Before: var, callback hell, no error handling
function getUser(id, cb) {
    db.query('SELECT * FROM users WHERE id = ' + id, function(err, rows) {
        if (err) cb(err);
        cb(null, rows[0]);
    });
}

// After: async/await, parameterized query, proper error handling
async function getUserById(userId: number): Promise<User | null> {
    const [rows] = await db.execute(
        'SELECT * FROM users WHERE id = ?',
        [userId]
    );
    return rows[0] ?? null;
}

כתב כתיבה

// Clean TypeScript: explicit types replace implicit any
// Before
function process(data) {
    return data.map(x => x.v * 2);
}

// After
interface DataPoint {
    value: number;
    label: string;
}

function doubleValues(dataPoints: DataPoint[]): number[] {
    return dataPoints.map(point => point.value * 2);
}

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

קוד נקי ב-C#

C# מציעה תכונות עוצמתיות לכתיבת קוד נקי ואקספרסיבי. התפתחות השפה, LINQ, רשומות, התאמת תבניות, טיפוסי הפניה ניתנים לאפס, נעה בעקביות לעבר תחביר הצהרתי וקריא יותר.

צארפ

// Before: magic numbers, verbose loop, mutable state
public double CalculateTotal(List<OrderItem> items)
{
    double total = 0;
    foreach (var item in items)
    {
        if (item.Quantity > 10)
            total += item.UnitPrice * item.Quantity * 0.9;
        else
            total += item.UnitPrice * item.Quantity;
    }
    return total;
}

// After: named constant, LINQ, single expression
private const double BulkDiscountRate = 0.9;
private const int BulkDiscountThreshold = 10;

public double CalculateTotal(IEnumerable<OrderItem> items) =>
    items.Sum(item => item.Quantity > BulkDiscountThreshold
        ? item.UnitPrice * item.Quantity * BulkDiscountRate
        : item.UnitPrice * item.Quantity);

עקרונות קוד נקי ב-C#: שימוש במאפיינים במקום שדות ציבוריים לצורך אנקפסולציה, מינוף LINQ לפעולות נתונים הצהרתיות, שימוש ברשומות עבור מבני נתונים בלתי ניתנים לשינוי, העדפת ממשקים על פני טיפוסים קונקרטיים בחתימות מתודה, ושימוש בטיפוסי הפניה הניתנים לאפס (nullable reference types).string? vs string) כדי להפוך את בטיחות ה-null למפורשת.

קוד נקי בקוטלין

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

קוטלין

// Before: verbose Java-style Kotlin
class User {
    var name: String = ""
    var email: String = ""
    var age: Int = 0
}

fun processUsers(users: List<User>): List<String> {
    val result = mutableListOf<String>()
    for (user in users) {
        if (user.age >= 18) {
            result.add(user.email)
        }
    }
    return result
}

// After: idiomatic clean Kotlin
data class User(val name: String, val email: String, val age: Int)

fun getAdultEmails(users: List<User>): List<String> =
    users.filter { it.age >= 18 }.map { it.email }

קוטלין'ס data class מספק פונקציות equals, hashCode, copy ו-toString באופן אוטומטי, ובכך מבטל את הסטנדרטים הרגילים שהופכים את מחלקות הנתונים של Java למילוליות ונוטות לשגיאות. פונקציות הרחבה מאפשרות לך להוסיף מתודות שירות נקיות למחלקות קיימות ללא ירושה.

קוד נקי ב-RPG ו-PL/I: שפות מדור קודם, עקרונות מודרניים

עקרונות קוד נקי חלים על כל שפה, כולל שפות ארגוניות המפעילות מערכות פיננסיות, פלטפורמות ביטוח ויישומים ממשלתיים ברחבי העולם. RPG (מחולל תוכניות דוחות) ו-PL/I עדיין מתוחזקים באופן פעיל בארגונים רבים, ואותו תחום שהופך את Java או Python לנקיים הופך את RPG ו-PL/I לבני קיימא.

קוד נקי ב-RPG (ILE RPG) :

RPG

     // Before: cryptic two-character names, magic numbers
     C                   EVAL      D = Q * P * 1.05
     C                   IF        Q > 100
     C                   EVAL      D = Q * P * 0.95
     C                   ENDIF

     // After: meaningful names, named constants, clear intent
      /free
       dcl-c BULK_DISCOUNT_THRESHOLD 100;
       dcl-c BULK_DISCOUNT_RATE      0.95;
       dcl-c STANDARD_RATE          1.05;

       dcl-proc CalculateOrderTotal;
         dcl-pi *N packed(15:2);
           quantity  packed(7:0) value;
           unitPrice packed(9:2) value;
         end-pi;

         if quantity > BULK_DISCOUNT_THRESHOLD;
           return quantity * unitPrice * BULK_DISCOUNT_RATE;
         else;
           return quantity * unitPrice * STANDARD_RATE;
         endif;
       end-proc;
      /end-free

שיטות עבודה נקיות וחשובות של RPG: השתמשו בפורמט החופשי של ILE RPG (/free) תחביר במקום פורמט קבוע לקריאה, מתן שמות לפרוצדורות באופן תיאורי, החלפת ערכים קשיחים בקבועים בעלי שם באמצעות dcl-c, ולפרק תוכניות ארוכות לפרוצדורות ממוקדות באמצעות dcl-proc.

קוד נקי ב-PL/I :

לְקַפֵּל

/* Before: single-letter names, no structure */
CALC: PROC(X, Y) RETURNS(FLOAT);
  DCL (X, Y, R) FLOAT;
  IF Y > 1000 THEN R = X * Y * 0.1;
  ELSE R = X * Y * 0.05;
  RETURN(R);
END CALC;

/* After: meaningful names, named constants, clear intent */
DCL PREMIUM_THRESHOLD  FIXED DECIMAL(7) INIT(1000);
DCL PREMIUM_RATE       FLOAT           INIT(0.10);
DCL STANDARD_RATE      FLOAT           INIT(0.05);

CALCULATE_DISCOUNT: PROC(QUANTITY, UNIT_PRICE) RETURNS(FLOAT);
  DCL (QUANTITY, UNIT_PRICE) FLOAT;
  DCL SUBTOTAL              FLOAT;

  SUBTOTAL = QUANTITY * UNIT_PRICE;

  IF UNIT_PRICE > PREMIUM_THRESHOLD
    THEN RETURN(SUBTOTAL * PREMIUM_RATE);
    ELSE RETURN(SUBTOTAL * STANDARD_RATE);

END CALCULATE_DISCOUNT;

עקרונות קוד נקי של PL/I משקפים את אלה של שפות מודרניות: מזהים משמעותיים (מגבלת 31 התווים של PL/I מספיקה לשמות תיאוריים), קבועים בעלי שם במקום מספרי קסם, פרוצדורות המתמקדות במשימה אחת, וטיפול מפורש בשגיאות באמצעות מערכת התנאים ON.

כלי קוד נקיים וניתוח סטטי

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

כלי	שפות	מה זה אוכף
סונאר קיוב / סונאר קלאוד	30 + שפות	מורכבות, שכפול, ריחות קוד, אבטחה
צ'קסטייל	Java	מוסכמות למתן שמות, עיצוב, מבנה
PMD	ג'אווה, אייפקס	קוד כפול, משתנים שאינם בשימוש, מורכבות
ESLint + typescript-eslint	JavaScript, TypeScript	סגנון, מורכבות, קוד שאינו בשימוש, תבניות אסינכרוניות
פילינט + ראדון	פיתון	PEP 8, מורכבות, מדד תחזוקה
ReSharper	C#	סגנון קוד, קוד עודף, הצעות לעיבוד מחדש
Clippy	חלודה	דפוסים אידיומטיים, טעויות נפוצות
SMART TS XL	COBOL, RPG, PL/I, ג'אווה, פייתון ועוד	מורכבות בין-לשונית, שכפול, קוד מת

מדדי הקוד הנקי הנפוצים ביותר שכלים מודדים: מורכבות ציקלומתית (מספר ענפי החלטה, מעל 10 הוא אזהרה, מעל 20 הוא קריטי), מורכבות קוגניטיבית (כמה קשה להבין את הקוד, מדד ספציפי ל-SonarQube שמשפר את המורכבות הציקלומתית למדידת קריאות), ושיעור שכפול (אחוז הקוד המשוכפל, מעל 3% מצדיק תשומת לב).

איך SMART TS XL אוכף קוד נקי על פני בסיסי קוד ארגוניים

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

SMART TS XL"S ניתוח קוד סטטי מיישמת מדדי קוד נקי על פני כל שפה בסביבה בו זמנית. מדדי מורכבות ציקלומטית, שיעורי שכפול, זיהוי קוד מת וצימוד מבני מחושבים עבור תוכניות COBOL באמצעות אותה מתודולוגיה כמו עבור מחלקות Java, ומייצרים מדידות איכות אחידות וברורות על פני כל תיק היישומים.

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

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

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

קוד נקי הוא תחום קבוצתי, לא פרקטיקה אישית

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

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