הקדמה: מדוע עקרונות SOLID ו- Modular Programming Matter

פיתוח תוכנה מודרני דורש מערכות שאינן רק פונקציונליות, אלא גם שמירה, דרוגנות, וכדאי לשנות.שני גישות יסוד המסייעות להשיג מטרות אלה הן FLT:0SOLID עקרונות SOLID bilFLT:1 ו-FLT:2modular ProgrammingFLT 3: בעוד שלעתים קרובות דנו בנפרד, שני מושגים אלה קשורים עמוק, כל אחד מהם מחדש את היחסים שלהם מאפשר לבנות קודים יעילים, להישאר בכושר ארוך, ותקופות ארוכות טווח, אך ורקמות.

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

מה הם עקרונות SOLID?

SOLID הוא ראשי התיבות של רוברט C. Martin (Uncle Bob) המייצג חמישה עקרונות עיצוב לתכנות ממוקדת אובייקטים.עקרונות אלה מנחים מפתחים ביצירת כיתות, מודולים ורכיבים קלים להבנה, בדיקה ושמירה.

  • (ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • (ב) ,0) פתח/ה את ⁇ 1 (OCP)
  • (ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • (ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • (ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

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

עקרון האחריות היחיד (SRP)

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

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

עקרון פתוח / סגור (OCP)

OCP אומר כי ישויות תוכנה (מחלקות, מודולים, פונקציות) צריך להיות (FLT:0open for הרחבה אך סגור עבור שינוי FLT:1 ).זה אומר שאתה צריך להיות מסוגל להוסיף פונקציונליות חדשה ללא שינוי קוד קיים, נבדק.זה מושג בדרך כלל באמצעות מופשט (למשל, ממשקים, כיתות מופשטות) ופולימורפיזם.

לדוגמה, לשקול מערכת חישוב עלויות המשלוח במקום לשנות מונוליטית (FLT:1 מחלקה בכל פעם שנושא חדש נוסף, אתה מגדיר ממשק FLT:2 ומאפשר לכל נושא ליישם אותו.

ה-LSkov Substitution Principle (LSP)

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

עיקרון זה הוא חיוני עבור עיצובים מודולריים אשר מסתמכים על ממשקים וירושה.כאשר מודולים משתמשים ממשק משותף, כל יישום חייב להתנהג באופן שלקוחות מצפים לו.הפרת LSP לעתים קרובות גורמת ללוגיקה מותנית (למשל, FLT:5) אשר שוברת את המודולריות ומגדילה את ההפיכה.

עקרון ה- Interface Segregation Principle (ISP)

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

במערכת מודולרית, ISP מסייע לשמור על גבולות מודול נקי.לדוגמה, ממשק 6 (FLT) יכול לכלול סריקת 7, FLT:8, ו-FLT:9 שיטות, אבל מודול מדפסת פשוט כי רק הדפסים לא צריך ליישם סריקה ופקסינג.

הכדאיות של ⁇ Principle (DIP)

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

בפועל, DIP הוא לעתים קרובות מיושם באמצעות הזרקת התלות (DI) או מאתרי שירות.לדוגמה, מודול ברמה גבוהה לא צריך ישירות מיידית את הזרקת התלות (DI) או לאתרי שירות.לדוגמה, ממשק FLT:15, ואת יישום קונקרטי מסופק במודולים החלים, זה מאפשר להחליף, לבדוק, או מורחב ללא שינוי לוגיקה הליבה.

הבנה של Modular Programming

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

מאפיינים מרכזיים של מערכת מודולרית כוללים:

  • (ב) ⁇ :0) ⁇ : 1 ⁇ בתוך מודול קשורים זה לזה ולשרת מטרה אחת.
  • (ב) ל"התק": ל"החלים" (ב"ב) יש שרידים מינימליים אחד על השני, צמצום ההשפעה של שינויים.
  • (ב) ⁇ :0) ⁇ : ⁇ (ב) ⁇ פרטים פנימיים של יישום פנימי: רק ממשקים ציבוריים נחשפים.
  • (ב) ניתן להשתמש במודולים שונים (בשיתוף) בין פרויקטים שונים או בהקשרים שונים.

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

הקשר בין SOLID ו- Modular Programming

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

כיצד מעבד SRP Enforces

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

OCP ומודולים בלתי אפשריים

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

LSP ו- Reliableמודול החלפת

Liskov Substitution מבטיח כי מודולים שנועדו כתחליף Plug-in להתנהג כראוי. במערכת מודולרית, לעתים קרובות להחליף מודול אחד עבור אחר (למשל, מסד נתונים אחר backends, מעבדי תשלום, או מסגרות כניסה). LSP מבטיח כי מודול חלופי תואם החוזה כי הלקוחות לצפות.ללא LSP, מודול עשוי להיראות כתחליף תקף אבל מציג התנגשויות, מודולים השבבים.

ISP ו-Minimalמודולs

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

DIP ו- Modular Decoupling

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

היתרונות של שילוב SOLID ועיצוב מודולרי

שילוב עקרונות SOLID עם אדריכלות מודולרית מניב מגוון של יתרונות מעשיים:

  • (FLT:0) שמירה על יכולת:FLT:1 שינויים מבודדים למודולים ספציפיים. כי כל מודול עוקב אחר SRP, שינויים יש השפעות קרוע מינימלי. DIP מבטיח כי מודול ברמה נמוכה אינו cascade למודולים ברמה גבוהה.
  • (FLT:0) חידושים משוחררים: מודולים 1FIRLT 1 , שעוצבו עם SOLID בראש הם זוגיים וממוקדים, מה שהופך אותם קלים למיצוי ולשימוש מחדש בפרויקטים אחרים.לדוגמה, A-FLT:25 מתוכנן היטב, אשר עומד על DIP ו- ISP ניתן להוריד לתוך יישום חדש עם הסתגלות קטנה.
  • (FLT:0) עדיף בדיקת אחריות: 1FLT) מודולים מפוכחים עם ממשקים מוגדרים הם פשוטים למבחן יחידה. DIP מאפשר לך להזריק תלויות לעג, ו-SRP מבטיח את היקף הבדיקה הוא צר.בדיקה הופכת מהירה ואמינה יותר.
  • (FLT:0) calScalability:FLT:1 ככל שהדרישות גדלות, באפשרותך להוסיף מודולים חדשים שמילאים ממשקים קיימים (OCP) ללא נגיעה בקוד יציב.זה תומך גם בדרגות האופקיות (התתתתתת מקרים נוספים) ורמת קיבולת תפקודית (תכונות קידוד).
  • צוותים שונים יכולים להחזיק ולפיתוח מודולים נפרדים באופן עצמאי, כל עוד הממשקים נותרו יציבים.

יישום מעשי: מדריך צעד-בי-צעד

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

זיהוי מודול Boundaries מבוסס על התחייבויות עסקיות

החל ממיפוי של תפקודי הליבה של המערכת (למשל, ניהול משתמשים, תשלום, מלאי, הודעות) כל יכולת יכולה להפוך מודול.וודא שלכל מודול יש אחריות אחת, ברורה (SRP) למשל, מודול ה-FLT:26 צריך לטפל בכל הקשור לעיבוד תשלום, בעוד מודול FLT:27 פועל מלאי.

מיפוי של תקשורת בין-Module

כל מודול צריך לחשוף קבוצה של ממשקים כי מודולים אחרים יכולים להיות קטנים ופרטים (ISP) להימנע ממשקי שומן אשר מכריחים את הלקוחות ליישם שיטות מיותרות.

3.השתמש בזריקת התלות

במקום מודולים ישירות מיידיים את התלויות שלהם, מזרקת אותם מבחוץ (DIP) ניתן לעשות זאת באמצעות הזרקת בנייה, זריקת רכוש, או באמצעות מיכל הזרקת התלות.לדוגמה, מודול AFLT:31 עשוי לקבל התפלגות (FLT:32 ו-FLT:33) במבנה שלה.

4.שימוש בביטול ליעילות

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

5.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A.A. Enforce LSP באמצעות חוזים

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

מבנה בסיס הקוד שלך בהתאם

ארגן מודולים לתיקיות נפרדות, חבילות, או אפילו שרידים נפרדים (במקרה של מיקרו-שירותים) לכל מודול צריך להיות שם משלו, מבחנים ותצורה. השתמש בכלים אשר לאכוף גבולות מודול (למשל, Javaמודולים ב- Java 9+, חבילות npm, חבילות Python עם FLT:34).

מלכודות נפוצות וטעויות

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

  • (FLT:0) Over-engineering:FLT:1euring כל עיקרון SOLID נוקשה מההתחלה יכול לגרום מופשט יתר ו עקיפין.התחל עם מבנה מודולרי פשוט וחדד כפי שאתה מבין את התחום.
  • (FLT:0) אבחון SRP ברמת המודול: ההרחבה 1 (בקיצור: ⁇ ) לפעמים מודול שנראה ממוקד ברמה גבוהה מכיל למעשה מספר רב של אחריות חבויה בתוך . השתמש במבחן "הreason to Change": שאל את עצמך, "האם מודול זה ישתנה מסיבות שונות?", אם כן, פיצול זה.
  • (FLT:0) יצירת מופשטים דליפים: FLT:1ir אם ממשק מודול מגלה יותר מדי על היישום הפנימי שלו, אתה מאבד את היתרונות של מודולריות.תמיד ממשקי עיצוב המבוססים על מה שלקוחות צריכים, לא מה שהמודול עושה בפנים.
  • (FLT:0) ,Negting גרסאות ויציבות החוזה: אנדרל 1 למערכות מודולריות, ממשקים הם חוזים.שינוי אותם יכול לשבור מודולים אחרים.ייסד אסטרטגיה גרסה (למשל, גרסה סימנטטית) ולתקשר שינויים בבירור.
  • (FLT:0) אכילת DIP כיצירה ממשק בלבד: ההרחבה 1 (יצירת ממשק אינה מונעת באופן אוטומטי את התלויות. True DIP דורש כי מודולים ברמה גבוהה אינם מכילים ידע כלשהו של יישום ברמה נמוכה.

דוגמאות אמיתיות בעולם

מסגרות ופלטפורמות מוצלחות רבות נבנות על סינרגיה של SOLID ועיצוב מודולרי:

  • (FLT:0)ASP.NET Core:FLT:1 מערכת ההזרקה התלות שלה מאמצת DIP, בעוד צינורות המודעות האמצעי שלה עוקב אחר OCP - אתה יכול להוסיף מודולים מתווך מותאם אישית מבלי לשנות את המסגרת.
  • (FLT:0)Spring Framework:FLT:1 מודולים כמו נתוני האביב, אבטחת האביב וענן האביב בנויים סביב ממשקים ברורים ומפתחי SRP יכולים לבחור ולבחר מודולים לפי הצורך.
  • (FLT:0)wordPress Plugin Architecture: FLT:1hil, למרות שלא מוכוונת לחלוטין, מערכת התוסף של וורדפרס מאפשרת להרחיב את הפונקציונליות (OCP) ללא שינויים מרכזיים, ו- קובצים (פעולות / מטיפים) מספקים צורה של הפרדה בין ממשק.
  • (FLT:0Microservices: FLT:1 כל מיקרו-שירות הוא מודול שעוקב אחר SRP (ממוקד על תחום אחד), תקשורת באמצעות APIs (interfaces), וניתן להחליף אותו ללא השפעה על אחרים (LSP).

מסקנה

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

הדרך לשלוט בשילוב זה דורש תרגול, אבל התגמול הוא עצום.התחל על ידי ניתוח המודולים הנוכחיים שלך: האם הם cohesive? האם הם יכולים להיות מוחלפים?האם הם תלויים בהפשטות? Gradually להציג מושגים SOLID לגבולות מודולרי שלך, ואתה תראה שיפור דרמטי באיכות התוכנה שלך.

(ב) קרא עוד, בדוק את המאמר המקורי של רוברט ק.מר מרטין על שורת התפוצה:0 (סעיפים ו-ד) ו-Andrew Floler's article on FLT:2Dependencyזרקה (FLT 3: 3GLT) ניתן למצוא גם את ה-FLT:4Wikipedia כניסה ל-SOLIDFLT5:5 ו-FishiGLT 7Gl ל-T.