שאלות על Object Oriented Desgin

לפני כשבוע נתקלתי בוויכוח הבא:

במערכת כלשהי, באזור לו נקרא "Sub-Project 3", מחלקה A (בג'אווה) קראה למתודה במחלקה B, אשר דרשה כפרמטר איזה ערך. הערך יכול להיות אחד מ 3 ערכים קבועים - ועל כן המפתחים יצרו enum (נקרא לו ENUM_X). עד כאן - יפה וטוב.

מפתח אחר גילה שבדיוק אותו enum (נקרא לו 'ENUM_X) מוגדר במקום אחר בפרויקט, ודרש שמחלקות A ו B ישתמשו ב enum המקורי - כך שלא יתוחזק "קוד כפול".

המפתח אשר כתב את הקוד במקור טען: "חבל לייצר reference לעוד תת פרויקט ב Build בשביל כזה דבר קטן. שיהיו שני enums זהים - לא יקרה שום דבר."

- "אבל אם תשנה אחד ותשכח את השני?! - מה אז?"

הוויכוח התלהט והגיע לראש הקבוצה (!).

מה דעתכם? במי אתם הייתם מצדדים?

כיצד לסיים את הוויכוח?

לפני שאספר לכם מה הייתה הצעתי (שנדחתה פה-אחד ע"י 2 הצדדים, כדרך אגב) ארחיב את הדילמה:

מי שקצת בקיא ב"תיאוריה" של הנדסת תוכנה או Object Oriented Design (בקיצור OOD) - יכול לטעון:
"שכפול קוד הוא אם כל רוע". "יש עיקרון חשוב שאומר שאין לשכפל קוד: כל שינוי קונספטואלי צריך להתרגם בדיוק לנקודה אחת בקוד בה עושים שינוי". "עקרון זה נקרא Don't Repeat Yourself Principle (בקיצור DRY) - וזהו עיקרון ידוע."
קל להתחבר לטיעון הזה: אותו מכירים אותו, כנראה, מקורס התכנות הראשון שלנו.

האם זהו הטיעון המנצח שיפתור את הדיון?



הממ... לא בטוח.
הנה טיעון מלומד אחר:

"אסור למודול להיות תלוי בחלקי-ממשק שאין לו בהם שימוש". במקרה שלנו יצרנו תלות לא רצויה בכל "Sub-Project 7" - כלומר בהרבה מחלקות וממשקים שאין לנו בהם שימוש. הממ... נשמע חמור!
עיקרון זה נקרא The Interface Segregation Principle.


האם ייתכן שעקרונות ה OOD סותרים זה את זה?

כמה שאלות

• האם יכול אדם, המכיר את 2 העקרונות והוא בעל כושר שכנוע, להחליט באופן רגשי במי הוא מצדד וכל פעם לשלוף את "הטיעון התאורטי המתאים" בכדי להנחית "טיעון מנצח"? האם הוא יכול לעשות זאת מבלי להיות מודע לכך ולהאמין שהוא "רק פועל ע''פ התאוריה"?
• בהינתן שחוקי ה OOD סותרים לעתים אחד-את-משנהו, האם ישנם חוקים "חזקים יותר" שיש להעדיף?
• נניח ונוותר על אחד החוקים או שניהם - איזה "נזק" יתרחש? מה ההשלכות של "לא לציית לחוקים"? האם המאמץ הנוסף שבציות לחוקי ה OOD - משתלם?
• האם OOD היא מתודולוגיה מוצלחת? האם, לאחר כל השינויים בשיטות העבודה שחלו בעשור האחרון - היא עדיין יעילה או רלוונטית?

עסקתי הרבה בחיי ב Object Oriented Design: למדתי, למדתי עוד, ניסיתי, יישמתי, שאפתי ליישום "מושלם", הנחיתי אחרים במתודולוגיה וכו'.

עדיין, ברגע זה, כשאני עומד ושואל את עצמי את השאלות הנ"ל - אין לי תשובה ברורה.

במשך שנים, פעלתי ע"פ כללי הנדסת-תוכנה שלמדתי. פעלתי? - נלחמתי בחירוף נפש, אפשר לומר.

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

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

• "על המתכנת צריך להגן על התוכנה בפני המפתחים - כולל הוא עצמו".
• עשה כל מה שתוכל כדי להפחית סיכונים לבאגים. 

גישה זו יצרה הרבה משמעת (discipline), אך גם הובילה להמלצות כגון כתיבת מחלקה singleton בג'אווה בתוך enum על מנת להבטיח singleton "שפשוט אי אפשר לקלקל" [א].

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

עקרונות ה OOD - למבחן!

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

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

חלוקה הקוד למחלקות או מודולים

• (The Single Responsibility Principle (SRP
• (Don't Repeat Yourself Principle (DRY
• Encapsulation
• High-Cohesion / Low-coupling Principle
• The Common Closure / Reuse Principle

הגדרת הפשטות (abstactions) / אינטראקציה בין מחלקות

• The Open-Closed Principle
• The Liskov Substitution Principle
• The Release-Reuse Equivalency Principle
• The Stable Abstraction Principle

ניהול תלויות (מחלקות עד מודולים במערכות)

• The Interface Segregation Principle + גרסת הקוד שלו
• (Single Layer Of Abstraction Principle (SLAP
• The Dependency Inversion Principle
• The Acyclic Dependencies Principle
• The Stable Dependencies Principle

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

• Principle of Least Surprise (לא ממש OOD, בעצם עיקרון בתכנון של יוניקס)
• Fail Fast
• Units of Work
• Separation of Concerns
• Law of Demeter / Principle of Least Knowledgable

עדכון 2: הנה איזו רשימה דומה של בחור אחר.

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

נראה לי שאבחר כמה מהעקרונות הנ"ל - ואתחיל לנתח אותם יותר לעומק.
הערות ומחשבות יתקבלו בשמחה.


ליאור


נ.ב: האא כן - איזה פתרון אני הצעתי לדילמה שהצגתי בתחילת הפוסט? אני הצעתי פשוט להשתמש במחרוזת (string) במקום enum וכך להימנע בכלל מתלויות. מה הייתרון של ENUM על מחרוזת פשוטה? Type Safety? ובכן... ה speller ב IDE ימצא את רוב שגיאות הכתיב. בדיקות-היחידה אמורות לתפוס את השאר...


----

[א] בספר Effective Java 2nd Edition, פריט מס' 3, ע"מ 18. אפשר להתייחס לכל סדרת ספרי ה ... Effective - כספרים של זרם ה "Defensive Programming".