.jpg)
במאמרים הקודמים (מאמר א', מאמר ב'), סקרנו את האבחנה של פרקטיקות בתוכנה לפרדיגמות, סקרנו את הפרדיגמות הבסיסיות - ובחנו כמה פרקטיקות רלוונטיות שהביא לעולם פרדיגמת ה״תכנות המובנה״. בחלק הזה ארצה להמשיך ולסקור פרדיגמות מתקדמות יותר.
התכנות הפרוצדורלי - מה הוא נתן לנו?
אם התכנות המובנה היה קפיצת מדרגה, שקשה מאוד לדמיין את עולם התוכנה בלעדיה, אזי גם התכנות הפרוצדורלי הציג וקידם עוד כמה רעיונות שכיום הם ״מובנים מאליהם״.
אין מה הרבה מה לספר על תהליך התגבשותה של הפרדיגמה הזו, בגדול זה היה עוד צעד בשכלול שפות התכנות - בכדי לאפשר לנהל בסיסי קוד גדולים ומורכבים יותר. השלב הטבעי הבא.
Functional Decomposition
הרעיון החזק ביותר שהציג התכנות הפרוצדורלי [א] נקרא Functional Decomposition. הוא הציל את עולם התוכנה מכבלי הקדמוניות - אבל מאז הפך גם ל-Anti-Pattern מסוכן ונפוץ.
זוהי טכניקה / תהליך / Pattern שמשפר מערכות בגודל בינוני, אך מסוכן עד מזיק - כאשר מנסים להתאים אותו למערכות גדולות ומורכבות.
הרעיון, הולך בערך כך:
איך מתמודדים עם בעיה גדולה ומורכבת? - נכון: Divide & Conquer. מחלקים לבעיות קטנות יותר, שקל יותר לפתור אותן אחת אחת.
אם אצליח למסגר (to frame) בעיה / פיצ׳ר נדרש במערכת כסט בן שלושה חלקים (שאתאר מיד) - אז יש לנו מסגרת לפתרון - כיצד לממש אותו.
החלקים הם:
• תיאור state ראשוני - נתון.
• תיאור state סופי - רצוי.
• סדרה של טרנספורמציות שיהפכו את ה-state הראשוני ל-state הסופי.
את הטרנספורמציות אתאר כפרוצדורות (~= וריאציה מוקדמת יותר של הפונקציות), ואז למרות שאני לא ידוע בדיוק איך לממש כל פונקציה - שברתי את הבעיה הגדולה לבעיות קטנות. עכשיו יהיה עלי להתמודד עם פונקציה בודדת בכל פעם - ולפתור בעיות קטנות יותר, ולכן קלות יותר.
יתרה מכך - הפרוצדורות / פונקציות הללו - הן בסיס טוב ל-code reuse. טרנספורמציה על מחרוזת כגון ()trim או ()replaceAllCaptialsWithNonCapitalLetters - יכולה לשמש אותי במקרים רבים נוספים!
זה רעיון כ״כ בסיסי והגיוני, שגם מי שלא למד את ״התאוריה של תכנות פרוצדורלי״ - מגיע אליו שוב ושוב.
כנושא במשרת ״ארכיטקט״ כבר שנים רבות, מעניין לי לציין שזה היה שלב מוקדם הוא השתלב תיאור תפקיד של ארכיטקט: ״הארכיטקט מחלק את התהליך לפרוצדורות, והמתכנתים ממשים את הפרוצדורות השונות״. גם זו, גישה שכנראה תרמה / הצליחה עד שלב מסוים, אבל מעבר לו - היא כבר נחשבת בעיקר כבעייתית.
מה הבעיות של Functional Decomposition שהפכו אותו ל-Anti-Pattern בעולם ה-OO?
• אי התייחסות / מחסור ב-Information Hiding ו-Encapsulation:
• האם ה-State הראשוני חשוף לכלל המערכת? האם הוא גלובאלי, למשל - כך היה בהתחלה.
• האם כל פונקציה שאפעיל רשאית לעשות כל שינוי ב-state?
• אם ה-state הוא רשימה של מחרוזות - אז אין בעיה. ככל שה-state גדול ומורכב יותר (קיצונות אחרת - לב הנתונים של המערכת) - קל יהיה יותר לאבד שליטה ובקרה: איזה פונקציה עושה מה - על הנתונים הללו.
• סיכויים גוברים לארגון נחות של המערכת:
• כאשר הפונקציות מפוזרות במערכת ללא סדר וללא היגיון - קל להגיע לבלאגן.
• כאשר אין סדר במערכת, סביר יותר שלא אמצא פונקציה קיימת ומספקת - ואכתוב אותה מחדש = קוד כפול.
• סיכויים גדולים למידול נחות של המערכת:
• חשיבה על המערכת בצורה של ״נתונים״ ו״טרנספורמציות״ אינו טובות למערכת גדולה ומורכבת. במערכת מורכבת, חשוב מאוד למצוא הפשטות (abstractions) טובות לפרטי המערכת, כך שיתאפשר לנו לחשוב ברמה גבוהה יותר של הפשטה. ה-Functional Decomposition לא מוביל אותנו לשם, ואולי אפילו מפריע.
• ביטוי של הסיכון הזה עשוי להגיע בדמות מודל אנמי - דפוס עיצוב שלילי.
למרות ש-Functional Decomposition נשמע כמו נאיביות של העבר, השימוש בו צץ שוב ושוב גם היום - גם בשנת 2019. בעשור האחרון נתקלתי בעשרות מקרים של ״נסיגה״ מ-OO ל-Functional Decomposition שלא הועילו למערכת. שווה ללמוד את ה-Anti-Pattern הזה ולהבין אם אתם מיישמים אותו במערכת. אולי ההבנה הזו - תעזור לכם לפשט את המערכת, ולהפוך אותה לקלה יותר לשינויים ותחזוקה.
עוד מסר חשוב: Functional Decomposition עשוי להישמע כמו Functional Programming - אבל הוא לא. בתכנות פונקציונלי, למשל, פונקציות לא משנות state, בטח לא state חיצוני. ניתן, כמובן, ליישם Functional Decomposition (גם) בשפות של תכנות פונקציונלי - אבל שפות של תכונת פונקציונלי מספקות כלים נוספים, בכדי לא להגיע לשם.
Functional Decomposition היא יוריסטיקה טובה לחיפוש פתרון Design לבעיה במערכת: לפרק בעיה גדולה לגורמים ולהבין מהיכן לתקוף אותה. חשוב מאוד לא לסיים שם, ולהפוך את הפתרון הנאיבי הנדסית, שאליו הגענו בעזרת Functional Composition - לפתרון בר-קיימא.
Modules
רעיון החלוקה למודולים, הוא הרעיון שאנו נחלק בחלוקה יזומה של קוד המערכת שלנו לאזורים - ע"פ קריטריונים מסוימים, מה שיאפשר לנהל טוב יותר את בסיס הקוד.
איזה סדר בדיוק? - אין לכך הנחיה ברורה אחת. חשוב שהסדר במערכת יהיה ברור לכולם, ועקבי - אחרת הוא חסר משמעות.
יש דרכים שונות לארגן קוד לאזורים שונים במערכת. בשפות תכנות שונות, יש וריאציות מעט שונות או לפחות שמות שונים לאותם "מודולים": Packages, Namespaces או Modules - הם שלוש צורות / שמות - לאותו הרעיון:
• כל פיסת קוד שנכתבת תהיה ״מקוטלגת״ או ״מיוחסת״ לאזור מסוים בקוד - להלן ״מודול״.
• הקרבה הזו היא קרבה רעיונית, ולא בהכרח פיסות קוד שקוראות אחת לשנייה.
• אין ברירה, קוד ממודול אחד - יקראו לקוד במודול שני. אבל, אנחנו רוצים לחלק את הקוד למודולים כך, שנצמצם את הקריאות בין המודולים, ונמקסם את הקריאות / ההיכרות בתוך אותו המודול.
• הרעיון הזה נקרא גם: ״High Cohesion / Low Coupling״. בעברית: אחידות גבוה (בתוך המודל) / תלות נמוכה (בין המודולים).
למרות שרעיון החלוקה למודלים הוא לא מדויק (לא מדויק בהגדרה, ולא מדויק במימוש) - הוא רעיון רב עוצמה שיש עליו קונצנזוס גדול: רבים ממובילי דעת הקהל בעולם התוכנה מאמינים שאם נחלק את המערכת לחלקים ע״פ סדר משמעותי - יהיה יותר קל להשתלט עליה ולנהל אותה. גם אם אין לכך הוכחה מתמטית ברורה.
בהמשך הדרך, האזורים של הקוד, "המודולים" - צמחו גם להיות יחידות נפרדות של קומפילציה, או linking/loading ואולי גם deployment. הנה, למשל, רעיון ה-Micro-Services - על קצה המזלג.
כל אלו הם רק שיפורים - על הרעיון הבסיסי.
הפרדיגמה מונחית-העצמים (OO)
מי שחי בתקופה בה צמחה הפרדיגמה מונחית העצמים, בעיקר בשנות ה-80 וה-90 - חווה דיון נוקב בהבדלים בין תכנות מונחה-עצמים (OOP), ותכנון מונחה-עצמים, Object-Oriented Design, או בקיצור: OOD.
אפילו לא פעם נשמעה הטענה ש"OOD הצליח - אך OOP נכשל". טענה שנויה במחלוקת, הייתי מוסיף.
אני לא רוצה להשקיע זמן על שחזור הוויכוח, ועל הדקויות הנלוות - ולכן אתייחס בעיקר ל-OO כ-OOD+OOP.
ב-OOP השתרשה ההתייחסות ל-3 עקרונות יסוד מקובלים: הכמסה, ריבוי צורות, והורשה.
הדיון לאורך גיבוש הפרדיגמה, שארך כמה עשורים - היה מורכב בהרבה.
בחרתי כמה עקרונות של OO שהייתי רוצה לשים עליהם דגש, אלו שאני מאמין שיש עוד מה לחדש לגביהם:
Everything is an Object
על העיקרון הזה לא מדברים היום הרבה, אבל הוא עיקרון מרכזי - וזה שנתן לפרדיגמה את שמה. הרעיון הוא בעצם פיתוח ושיפור של רעיון ה-Modules.
לרעיון יש שתי פנים:
• לארוז קוד ביחידות קטנות (יותר) של מודולריזציה - להלן מחלקות.
• למדל את המערכת ליחידות המתארות את העולם האמיתי. זה עיקרון ליבה של ה-OOD, שלעתים לא מודגש מספיק: זה לא מספיק לחלק את הקוד ל״מחלקות״. חשוב מאוד שהחלוקה הזו תתאר את עולם הבעיה (העסקית) - בצורה נאמנה והגיונית. המיפוי / מידול הזה - מקל על הבנת המערכת, ועל התקשורת לגביה - מה שמקל על לקבוצה גדולה של אנשים להיות שותפים אליה ולעבוד בצורה קוהרנטית.
• אם בעולם שאותו המערכת משרתת יש מונחים שלא מתבטאים במערכת כאובייקטים - אז כנראה עשינו מידול לא מוצלח.
• אם הקשר בין האובייקטים לא תואם להיגיון מקובל - אזי כנראה שהמידול שלנו לא מוצלח.
• אחד מכלי המחשבה למידול לאובייקטים הוא המחשבה על ״תחום אחריות״ (להלן: SRP). אם האובייקט היה בן-אדם, מה הוא היה דורש שרק הוא יעשה? שיהיה רק באחריותו?
o טכניקה מעניינת של מידול שצמחה, למשל, היא CRC cards.
האובייקטים תוארו בעזרת המטאפורה של כ״תא ביולוגי עצמאי״. לתא יש מעטפת קשיחה המגנה עליו מהעולם (על כך - בהמשך) והוא מכיל בפנים את מה שהוא זקוק לו לפעולה עצמאית. כלומר: אנו מצמדים את הנתונים (state) לפעולות (functions). זה עוזר לנו גם בכדי להגן על ה-state - אבל גם בכדי ליצור סדר הגיוני וצפוי במערכת.
שפות תכנות מודרניות, המתוארות כ-OO, לרוב מספקות מבנה בשם מחלקה (Class) - שמקל עלינו למדל את המערכת כאובייקטים. האחריות לתוכן, והמידול עצמו - היא כמובן בידנו. שום שפה לא תעשה את זה במקומנו.
אם המערכת שלנו בנויה מ"מחלקות של נתונים", ומנגד, מ"מחלקות של פעולות" - אז פספסנו את הרעיון המרכזי הזה של Everything is an Object. זה לא משנה בכלל אם אנחנו עובדים ב-Enterprise Java או Shell Script. יותר מהכל, OO הוא לא כלי - אלא רעיון.
אל תבטלו את העניין הזה סתם: אנחנו עדיין כותבים הרבה קוד שלא מציית לרעיון של Everything is an object. הרעיון הזה קל אולי להבנה - אבל לא תמיד קל ליישום.
Information Hiding
הרעיון הזה אינו חדש, והתגלגל גם בפרדיגמות מוקדמות יותר.
OO חידשה בכך ששמה את ה-Information Hiding כעקרון ליבה מחייב - ולא עוד כהמלצה ״לפעמים כדאי לצמצם את הידיעה של חלק אחד בקוד על חלקים אחרים״. ב-OO מדגישים: ״בכל מקום במערכת אנחנו נסתיר כל מה שלא נחוץ - לחלקים האחרים״.
Encapsulation הוא השילוב של הרעיון הזה, בשילוב הרעיון של Everything in an Object. ההכמסה היא ״קרום התא הביולוגי״ המגן כל פנים התא הרגיש (ה state הפנימי) - מהשפעות חיצוניות.
• בשפות OO לרוב יש לנו directives הנותנים לנו לשלוט על הנראות: private, package, protected - וכו'.
• אובייקטים הרוצה משהו מאובייקט אחר, שולח לו ״הודעות״. לא עוד אלך ואפשפש לי (ואולי גם אשנה) State של חלק אחר במערכת. יש מעתה Gate Keeper, שלו אני שולח רק את המידע הנדרש ("ההודעה") - ואקבל בחזרה - תשובה.
o אם אתם יוצרים הודעות בין אובייקטים ושולחים את כל ה-State של האובייקט, אז אתם מממשים משהו שקרוב יותר לתכנות פרוצדורלי - מאשר ל-OO.
• יש צורות נוספות של Information Hiding מלבד הכמסה של אובייקטים:
• הפרדה של בסיס הנתונים לסכמות, תוך הגבלת הגישה לסכמות השונות - הוא information hiding
• תכנון המערכת כך שיהיה צורך של פחות אובייקטים להכיר אחד את השני - הוא information hiding מעבר להכמסה של האובייקט הבודד.
• העברה ל-Front-End רק את פיסות המידע הנדרשות (לפעמים נדרש עיבוד נוסף לצורך כך) - הוא information hiding.
• המוטיבציה העיקרית ל-Information Hiding היא היכולת לבצע שינויים בחלקים מסוימים במערכת, בלי שהדבר יגרור צורך לשינויים באזורים נוספים. להגביל את גודל השינוי.
• אם אני לא יודע על חלקים אחרים - שינוי בהם לא אמור לדרוש ממני להתעדכן.
• זה לא תמיד נכון. לפעמים יש השפעות עקיפות - שכן ידרשו ממני להתעדכן. למשל: סדר שונה של פעולות שמרחש במערכת. לא נחשף לי מידע חדש / שונה, אבל עדיין אני צריך להתאים את עצמי.
לרעיון של Information Hiding (או הכמסה: אנו נוטים היום להשתמש במונחים לחליפין) - יש מחיר: הסתרה של נתונים דורשת עבודה נוספת - עוד כתיבת קוד, וחשיבה ותשומת לב - שבעקבותיה עוד כתיבת / שינוי קוד.
ברור שנקודת האופטימום איננה למקסם את ה-Information Hiding עד אינסוף. אין כלל ברור כיצד למצוא את נקודת האופטימום, ורוב אנחנו מוצאים אותה (פחות או יותר) תוך כדי גישוש.
לאורך חיי ראיתי מערכות רבות שחסר בהן Information Hiding, וראיתי גם מערכות שיש בהם עודף של Information Hiding - והתקורה לכל שינוי, הייתה רבה מדי.
הורשה
הורשה היא כלי נחמד, ולעתים מזיק: מזיק להכמסה, ומזיק למידול טוב של המערכת לעולם האמיתי. כלי שנוטה להזיק - לפעמים עדיף להיפטר ממנו, ואכן הרעיון להיפטר מהכלי שנקרא הורשה - עולה מדי פעם.
לפחות הייתי ממליץ להגביל את השימוש בהורשה לאובייקטים קטנים ופשוטים. כן יש משהו קל להבנה בהורשה רדודה ולא-מתוחכמת.
שלא תגידו שלא ידעתם.
non-Objects
אם "Everything is an Object" - אז איך יש דברים שאינם אובייקטים?
את הסתירה הזו ניתן ליישב רק בהסתכלות לאורך זמן: בהתחלה ניסו באמת להגדיר שכל דבר יהיה אובייקט - אבל עם הזמן הבינו שיש חריגים. שמדי פעם עדיף שיוגדרו במערכת גם ישויות - שלא יצייתו לחוקי "האובייקטים".
כש-OO אומץ בצורה יותר ויותר רחבה, עלו עוד ועוד קולות שרצו להבחין בין מחלקות (classes) לבין מבני-נתונים (structs). בניגוד למחלקה, מבני-נתונים רק "מחזיקים" כמה נתונים ביחד - ואין עליהן פעולות (כך טענו בתחילה). יותר מאוחר הסכימו שיכולות להיות גם על מבני-נתונים פעולות (פונקציות) - אבל רק כאלו שעוזרות לגשת לנתונים במבנה, ובוודאי לא Business Logic. ההבחנה הזו לא השתנה - ולא נראה שיש קולות לשנות אותה.
ג׳אווה, שפה מאוד פופולארית ומשפיעה - דילגה על ההבחנה בין מחלקות למבני-נתונים. אם אנחנו רוצים להגדיר בה מבנה-נתונים - אנחנו משתמשים ב-classes. בעצם כך, שפת ג'אווה "מנעה" במידת מה, מההבחנה בין מחלקות למבני-נתונים לחלחל בתעשייה.
• האם Map או List הם מחלקות? לא - אלו הם מבני-נתונים. כל מטרתם היא להחזיק ולחשוף נתונים. הכמסה? זה לא הקטע שלהן [ב].
• האם DTOs או Enum הם מחלקות? לא - אלו מבני-נתונים. בשפת ג׳אווה נממש DTOs כ-Class, אך מבחינה רעיונית הן לא מחלקות: אין להן הכמסה [ב], ואין להם אחריות לתאר פעולות בעולם.
• בג'אווה הרבה פעמים כאשר ממשמשים DTO (לרוב מצוין ע"פ Suffix בשם) - מאפשרים לכל השדות של ה-DTO להיות public - ומדלגים על השימוש ב-getter/setters. הגיוני.
חוסר ההבחנה בין מחלקות ומבני-נתונים לא מאפיין את כל השפות: ב-#C קיימים structs, בקוטלין יש Data Classes, ובפייטון היו named tuples כסוג של ייצוג, ולאחרונה הוסיפו גם Data classes.
אפשר להסתכל על המבנים הללו רק ככלי לאופטימיזציה של קוד/ביצועים בשפה - אבל שימושי הרבה יותר להשתמש בהם ככלי להבחנה סמנטית בין אלמנטים שונים בתוכנה: מחלקות, ומבני-נתונים.
יש כמה סימנים שיעזרו לנו לזהות מבני-נתונים
:
• על מבני-נתונים אין פעולות, לפחות לא כאלו שמבצעות Business Logic.
• מחלקות יכולות להכיר מבני-נתונים, אך מבני נתונים לעולם לא יכירו מחלקות.
• אם שדות של מחלקה השתנו, זה יכול להיגמר בלי השפעה סביבתית. אם שדות של מבנה-נתונים משתנים - הם כמעט תמיד יגררו שינויים במחלקות אחרות. למה? כי זו מטרתם בחיים: להעביר נתונים בין מחלקות, וגם מ/אל מערכות חיצוניות (קריאה ל-API, שליפה מבסיס נתונים, וכו׳).
בהחלט קיימת נטייה לבלבל ולערבב בין מחלקות ומבני-נתונים. הבלבול הזה לוקח אותנו למימוש פחות נכון של פרדיגמת ה-OO - לפחות בצורה העדכנית שלה. אם אנחנו כבר משקיעים את כל העבודה בניהול מחלקות והכמסה - חבל לפספס את ההבחנה החשובה הזו!
ההבחנה בין מחלקות למבני-נתונים תורמת למידול המערכת, ותורמת להכמסה (כי אנחנו לא מבזבזים כוחות היכן שהיא לא נדרשת - וכך מצמצמים את הקולות לוותר עליה).
לסיכום
המשכנו לאורך המסלול ההיסטורי, מתכנות פרוצדורלי עד לתכנות מונחה-עצמים.
לאורך התקופה הזו, הייתה והשפיעה פרדיגמה משמעותית נוספת: פרדיגמת התכנות הפונקציונלי - שלה אני אקדיש פוסט נוסף.
שיהיה בהצלחה!
-----
[א] יש כאלו שמסווגים את הרעיון הזה כחלק מהתכנות המובנה. אין פה אמת אחת, ויש חפיפה רעיונית ותקופתית בין שתי הפרדיגמות.
באופן דומה, יש גם לא מעט חפיפה בין תכנות פרוצדורלי ל-OO. לצורך הפוסט - אני מפשט את הדברים ופשוט מייחס כל רעיון לפרדיגמה אחת ויחידה.
[ב] זה כמובן, חצי מדויק: לפעמים מבנה הנתונים הוא מורכב (למשל HashMap) ואנו מכמיסים את מורכבות המבנה הפנימי בכדי לחשוף למשתמש מ
מאת: ליאור בר-און, ארכיטקט ראשי בחברת Gett וכותב בבלוג http://www.softwarearchiblog.com
רוצים להתעדכן בתכנים נוספים בנושאי ענן וטכנולוגיות מתקדמות? הירשמו עכשיו לניוזלטר שלנו ותמיד תישארו בעניינים > להרשמה
במאמרים הקודמים (מאמר א', מאמר ב'), סקרנו את האבחנה של פרקטיקות בתוכנה לפרדיגמות, סקרנו את הפרדיגמות הבסיסיות - ובחנו כמה פרקטיקות רלוונטיות שהביא לעולם פרדיגמת ה״תכנות המובנה״. בחלק הזה ארצה להמשיך ולסקור פרדיגמות מתקדמות יותר.
התכנות הפרוצדורלי - מה הוא נתן לנו?
אם התכנות המובנה היה קפיצת מדרגה, שקשה מאוד לדמיין את עולם התוכנה בלעדיה, אזי גם התכנות הפרוצדורלי הציג וקידם עוד כמה רעיונות שכיום הם ״מובנים מאליהם״.
אין מה הרבה מה לספר על תהליך התגבשותה של הפרדיגמה הזו, בגדול זה היה עוד צעד בשכלול שפות התכנות - בכדי לאפשר לנהל בסיסי קוד גדולים ומורכבים יותר. השלב הטבעי הבא.
Functional Decomposition
הרעיון החזק ביותר שהציג התכנות הפרוצדורלי [א] נקרא Functional Decomposition. הוא הציל את עולם התוכנה מכבלי הקדמוניות - אבל מאז הפך גם ל-Anti-Pattern מסוכן ונפוץ.
זוהי טכניקה / תהליך / Pattern שמשפר מערכות בגודל בינוני, אך מסוכן עד מזיק - כאשר מנסים להתאים אותו למערכות גדולות ומורכבות.
הרעיון, הולך בערך כך:
איך מתמודדים עם בעיה גדולה ומורכבת? - נכון: Divide & Conquer. מחלקים לבעיות קטנות יותר, שקל יותר לפתור אותן אחת אחת.
אם אצליח למסגר (to frame) בעיה / פיצ׳ר נדרש במערכת כסט בן שלושה חלקים (שאתאר מיד) - אז יש לנו מסגרת לפתרון - כיצד לממש אותו.
החלקים הם:
• תיאור state ראשוני - נתון.
• תיאור state סופי - רצוי.
• סדרה של טרנספורמציות שיהפכו את ה-state הראשוני ל-state הסופי.
את הטרנספורמציות אתאר כפרוצדורות (~= וריאציה מוקדמת יותר של הפונקציות), ואז למרות שאני לא ידוע בדיוק איך לממש כל פונקציה - שברתי את הבעיה הגדולה לבעיות קטנות. עכשיו יהיה עלי להתמודד עם פונקציה בודדת בכל פעם - ולפתור בעיות קטנות יותר, ולכן קלות יותר.
יתרה מכך - הפרוצדורות / פונקציות הללו - הן בסיס טוב ל-code reuse. טרנספורמציה על מחרוזת כגון ()trim או ()replaceAllCaptialsWithNonCapitalLetters - יכולה לשמש אותי במקרים רבים נוספים!
זה רעיון כ״כ בסיסי והגיוני, שגם מי שלא למד את ״התאוריה של תכנות פרוצדורלי״ - מגיע אליו שוב ושוב.
כנושא במשרת ״ארכיטקט״ כבר שנים רבות, מעניין לי לציין שזה היה שלב מוקדם הוא השתלב תיאור תפקיד של ארכיטקט: ״הארכיטקט מחלק את התהליך לפרוצדורות, והמתכנתים ממשים את הפרוצדורות השונות״. גם זו, גישה שכנראה תרמה / הצליחה עד שלב מסוים, אבל מעבר לו - היא כבר נחשבת בעיקר כבעייתית.
מה הבעיות של Functional Decomposition שהפכו אותו ל-Anti-Pattern בעולם ה-OO?
• אי התייחסות / מחסור ב-Information Hiding ו-Encapsulation:
• האם ה-State הראשוני חשוף לכלל המערכת? האם הוא גלובאלי, למשל - כך היה בהתחלה.
• האם כל פונקציה שאפעיל רשאית לעשות כל שינוי ב-state?
• אם ה-state הוא רשימה של מחרוזות - אז אין בעיה. ככל שה-state גדול ומורכב יותר (קיצונות אחרת - לב הנתונים של המערכת) - קל יהיה יותר לאבד שליטה ובקרה: איזה פונקציה עושה מה - על הנתונים הללו.
• סיכויים גוברים לארגון נחות של המערכת:
• כאשר הפונקציות מפוזרות במערכת ללא סדר וללא היגיון - קל להגיע לבלאגן.
• כאשר אין סדר במערכת, סביר יותר שלא אמצא פונקציה קיימת ומספקת - ואכתוב אותה מחדש = קוד כפול.
• סיכויים גדולים למידול נחות של המערכת:
• חשיבה על המערכת בצורה של ״נתונים״ ו״טרנספורמציות״ אינו טובות למערכת גדולה ומורכבת. במערכת מורכבת, חשוב מאוד למצוא הפשטות (abstractions) טובות לפרטי המערכת, כך שיתאפשר לנו לחשוב ברמה גבוהה יותר של הפשטה. ה-Functional Decomposition לא מוביל אותנו לשם, ואולי אפילו מפריע.
• ביטוי של הסיכון הזה עשוי להגיע בדמות מודל אנמי - דפוס עיצוב שלילי.
למרות ש-Functional Decomposition נשמע כמו נאיביות של העבר, השימוש בו צץ שוב ושוב גם היום - גם בשנת 2019. בעשור האחרון נתקלתי בעשרות מקרים של ״נסיגה״ מ-OO ל-Functional Decomposition שלא הועילו למערכת. שווה ללמוד את ה-Anti-Pattern הזה ולהבין אם אתם מיישמים אותו במערכת. אולי ההבנה הזו - תעזור לכם לפשט את המערכת, ולהפוך אותה לקלה יותר לשינויים ותחזוקה.
עוד מסר חשוב: Functional Decomposition עשוי להישמע כמו Functional Programming - אבל הוא לא. בתכנות פונקציונלי, למשל, פונקציות לא משנות state, בטח לא state חיצוני. ניתן, כמובן, ליישם Functional Decomposition (גם) בשפות של תכנות פונקציונלי - אבל שפות של תכונת פונקציונלי מספקות כלים נוספים, בכדי לא להגיע לשם.
Functional Decomposition היא יוריסטיקה טובה לחיפוש פתרון Design לבעיה במערכת: לפרק בעיה גדולה לגורמים ולהבין מהיכן לתקוף אותה. חשוב מאוד לא לסיים שם, ולהפוך את הפתרון הנאיבי הנדסית, שאליו הגענו בעזרת Functional Composition - לפתרון בר-קיימא.
Modules
רעיון החלוקה למודולים, הוא הרעיון שאנו נחלק בחלוקה יזומה של קוד המערכת שלנו לאזורים - ע"פ קריטריונים מסוימים, מה שיאפשר לנהל טוב יותר את בסיס הקוד.
איזה סדר בדיוק? - אין לכך הנחיה ברורה אחת. חשוב שהסדר במערכת יהיה ברור לכולם, ועקבי - אחרת הוא חסר משמעות.
יש דרכים שונות לארגן קוד לאזורים שונים במערכת. בשפות תכנות שונות, יש וריאציות מעט שונות או לפחות שמות שונים לאותם "מודולים": Packages, Namespaces או Modules - הם שלוש צורות / שמות - לאותו הרעיון:
• כל פיסת קוד שנכתבת תהיה ״מקוטלגת״ או ״מיוחסת״ לאזור מסוים בקוד - להלן ״מודול״.
• הקרבה הזו היא קרבה רעיונית, ולא בהכרח פיסות קוד שקוראות אחת לשנייה.
• אין ברירה, קוד ממודול אחד - יקראו לקוד במודול שני. אבל, אנחנו רוצים לחלק את הקוד למודולים כך, שנצמצם את הקריאות בין המודולים, ונמקסם את הקריאות / ההיכרות בתוך אותו המודול.
• הרעיון הזה נקרא גם: ״High Cohesion / Low Coupling״. בעברית: אחידות גבוה (בתוך המודל) / תלות נמוכה (בין המודולים).
למרות שרעיון החלוקה למודלים הוא לא מדויק (לא מדויק בהגדרה, ולא מדויק במימוש) - הוא רעיון רב עוצמה שיש עליו קונצנזוס גדול: רבים ממובילי דעת הקהל בעולם התוכנה מאמינים שאם נחלק את המערכת לחלקים ע״פ סדר משמעותי - יהיה יותר קל להשתלט עליה ולנהל אותה. גם אם אין לכך הוכחה מתמטית ברורה.
בהמשך הדרך, האזורים של הקוד, "המודולים" - צמחו גם להיות יחידות נפרדות של קומפילציה, או linking/loading ואולי גם deployment. הנה, למשל, רעיון ה-Micro-Services - על קצה המזלג.
כל אלו הם רק שיפורים - על הרעיון הבסיסי.
הפרדיגמה מונחית-העצמים (OO)
מי שחי בתקופה בה צמחה הפרדיגמה מונחית העצמים, בעיקר בשנות ה-80 וה-90 - חווה דיון נוקב בהבדלים בין תכנות מונחה-עצמים (OOP), ותכנון מונחה-עצמים, Object-Oriented Design, או בקיצור: OOD.
אפילו לא פעם נשמעה הטענה ש"OOD הצליח - אך OOP נכשל". טענה שנויה במחלוקת, הייתי מוסיף.
אני לא רוצה להשקיע זמן על שחזור הוויכוח, ועל הדקויות הנלוות - ולכן אתייחס בעיקר ל-OO כ-OOD+OOP.
ב-OOP השתרשה ההתייחסות ל-3 עקרונות יסוד מקובלים: הכמסה, ריבוי צורות, והורשה.
הדיון לאורך גיבוש הפרדיגמה, שארך כמה עשורים - היה מורכב בהרבה.
בחרתי כמה עקרונות של OO שהייתי רוצה לשים עליהם דגש, אלו שאני מאמין שיש עוד מה לחדש לגביהם:
Everything is an Object
על העיקרון הזה לא מדברים היום הרבה, אבל הוא עיקרון מרכזי - וזה שנתן לפרדיגמה את שמה. הרעיון הוא בעצם פיתוח ושיפור של רעיון ה-Modules.
לרעיון יש שתי פנים:
• לארוז קוד ביחידות קטנות (יותר) של מודולריזציה - להלן מחלקות.
• למדל את המערכת ליחידות המתארות את העולם האמיתי. זה עיקרון ליבה של ה-OOD, שלעתים לא מודגש מספיק: זה לא מספיק לחלק את הקוד ל״מחלקות״. חשוב מאוד שהחלוקה הזו תתאר את עולם הבעיה (העסקית) - בצורה נאמנה והגיונית. המיפוי / מידול הזה - מקל על הבנת המערכת, ועל התקשורת לגביה - מה שמקל על לקבוצה גדולה של אנשים להיות שותפים אליה ולעבוד בצורה קוהרנטית.
• אם בעולם שאותו המערכת משרתת יש מונחים שלא מתבטאים במערכת כאובייקטים - אז כנראה עשינו מידול לא מוצלח.
• אם הקשר בין האובייקטים לא תואם להיגיון מקובל - אזי כנראה שהמידול שלנו לא מוצלח.
• אחד מכלי המחשבה למידול לאובייקטים הוא המחשבה על ״תחום אחריות״ (להלן: SRP). אם האובייקט היה בן-אדם, מה הוא היה דורש שרק הוא יעשה? שיהיה רק באחריותו?
o טכניקה מעניינת של מידול שצמחה, למשל, היא CRC cards.
האובייקטים תוארו בעזרת המטאפורה של כ״תא ביולוגי עצמאי״. לתא יש מעטפת קשיחה המגנה עליו מהעולם (על כך - בהמשך) והוא מכיל בפנים את מה שהוא זקוק לו לפעולה עצמאית. כלומר: אנו מצמדים את הנתונים (state) לפעולות (functions). זה עוזר לנו גם בכדי להגן על ה-state - אבל גם בכדי ליצור סדר הגיוני וצפוי במערכת.
שפות תכנות מודרניות, המתוארות כ-OO, לרוב מספקות מבנה בשם מחלקה (Class) - שמקל עלינו למדל את המערכת כאובייקטים. האחריות לתוכן, והמידול עצמו - היא כמובן בידנו. שום שפה לא תעשה את זה במקומנו.
אם המערכת שלנו בנויה מ"מחלקות של נתונים", ומנגד, מ"מחלקות של פעולות" - אז פספסנו את הרעיון המרכזי הזה של Everything is an Object. זה לא משנה בכלל אם אנחנו עובדים ב-Enterprise Java או Shell Script. יותר מהכל, OO הוא לא כלי - אלא רעיון.
אל תבטלו את העניין הזה סתם: אנחנו עדיין כותבים הרבה קוד שלא מציית לרעיון של Everything is an object. הרעיון הזה קל אולי להבנה - אבל לא תמיד קל ליישום.
Information Hiding
הרעיון הזה אינו חדש, והתגלגל גם בפרדיגמות מוקדמות יותר.
OO חידשה בכך ששמה את ה-Information Hiding כעקרון ליבה מחייב - ולא עוד כהמלצה ״לפעמים כדאי לצמצם את הידיעה של חלק אחד בקוד על חלקים אחרים״. ב-OO מדגישים: ״בכל מקום במערכת אנחנו נסתיר כל מה שלא נחוץ - לחלקים האחרים״.
Encapsulation הוא השילוב של הרעיון הזה, בשילוב הרעיון של Everything in an Object. ההכמסה היא ״קרום התא הביולוגי״ המגן כל פנים התא הרגיש (ה state הפנימי) - מהשפעות חיצוניות.
• בשפות OO לרוב יש לנו directives הנותנים לנו לשלוט על הנראות: private, package, protected - וכו'.
• אובייקטים הרוצה משהו מאובייקט אחר, שולח לו ״הודעות״. לא עוד אלך ואפשפש לי (ואולי גם אשנה) State של חלק אחר במערכת. יש מעתה Gate Keeper, שלו אני שולח רק את המידע הנדרש ("ההודעה") - ואקבל בחזרה - תשובה.
o אם אתם יוצרים הודעות בין אובייקטים ושולחים את כל ה-State של האובייקט, אז אתם מממשים משהו שקרוב יותר לתכנות פרוצדורלי - מאשר ל-OO.
• יש צורות נוספות של Information Hiding מלבד הכמסה של אובייקטים:
• הפרדה של בסיס הנתונים לסכמות, תוך הגבלת הגישה לסכמות השונות - הוא information hiding
• תכנון המערכת כך שיהיה צורך של פחות אובייקטים להכיר אחד את השני - הוא information hiding מעבר להכמסה של האובייקט הבודד.
• העברה ל-Front-End רק את פיסות המידע הנדרשות (לפעמים נדרש עיבוד נוסף לצורך כך) - הוא information hiding.
• המוטיבציה העיקרית ל-Information Hiding היא היכולת לבצע שינויים בחלקים מסוימים במערכת, בלי שהדבר יגרור צורך לשינויים באזורים נוספים. להגביל את גודל השינוי.
• אם אני לא יודע על חלקים אחרים - שינוי בהם לא אמור לדרוש ממני להתעדכן.
• זה לא תמיד נכון. לפעמים יש השפעות עקיפות - שכן ידרשו ממני להתעדכן. למשל: סדר שונה של פעולות שמרחש במערכת. לא נחשף לי מידע חדש / שונה, אבל עדיין אני צריך להתאים את עצמי.
לרעיון של Information Hiding (או הכמסה: אנו נוטים היום להשתמש במונחים לחליפין) - יש מחיר: הסתרה של נתונים דורשת עבודה נוספת - עוד כתיבת קוד, וחשיבה ותשומת לב - שבעקבותיה עוד כתיבת / שינוי קוד.
ברור שנקודת האופטימום איננה למקסם את ה-Information Hiding עד אינסוף. אין כלל ברור כיצד למצוא את נקודת האופטימום, ורוב אנחנו מוצאים אותה (פחות או יותר) תוך כדי גישוש.
לאורך חיי ראיתי מערכות רבות שחסר בהן Information Hiding, וראיתי גם מערכות שיש בהם עודף של Information Hiding - והתקורה לכל שינוי, הייתה רבה מדי.
הורשה
הורשה היא כלי נחמד, ולעתים מזיק: מזיק להכמסה, ומזיק למידול טוב של המערכת לעולם האמיתי. כלי שנוטה להזיק - לפעמים עדיף להיפטר ממנו, ואכן הרעיון להיפטר מהכלי שנקרא הורשה - עולה מדי פעם.
לפחות הייתי ממליץ להגביל את השימוש בהורשה לאובייקטים קטנים ופשוטים. כן יש משהו קל להבנה בהורשה רדודה ולא-מתוחכמת.
שלא תגידו שלא ידעתם.
non-Objects
אם "Everything is an Object" - אז איך יש דברים שאינם אובייקטים?
את הסתירה הזו ניתן ליישב רק בהסתכלות לאורך זמן: בהתחלה ניסו באמת להגדיר שכל דבר יהיה אובייקט - אבל עם הזמן הבינו שיש חריגים. שמדי פעם עדיף שיוגדרו במערכת גם ישויות - שלא יצייתו לחוקי "האובייקטים".
כש-OO אומץ בצורה יותר ויותר רחבה, עלו עוד ועוד קולות שרצו להבחין בין מחלקות (classes) לבין מבני-נתונים (structs). בניגוד למחלקה, מבני-נתונים רק "מחזיקים" כמה נתונים ביחד - ואין עליהן פעולות (כך טענו בתחילה). יותר מאוחר הסכימו שיכולות להיות גם על מבני-נתונים פעולות (פונקציות) - אבל רק כאלו שעוזרות לגשת לנתונים במבנה, ובוודאי לא Business Logic. ההבחנה הזו לא השתנה - ולא נראה שיש קולות לשנות אותה.
ג׳אווה, שפה מאוד פופולארית ומשפיעה - דילגה על ההבחנה בין מחלקות למבני-נתונים. אם אנחנו רוצים להגדיר בה מבנה-נתונים - אנחנו משתמשים ב-classes. בעצם כך, שפת ג'אווה "מנעה" במידת מה, מההבחנה בין מחלקות למבני-נתונים לחלחל בתעשייה.
• האם Map או List הם מחלקות? לא - אלו הם מבני-נתונים. כל מטרתם היא להחזיק ולחשוף נתונים. הכמסה? זה לא הקטע שלהן [ב].
• האם DTOs או Enum הם מחלקות? לא - אלו מבני-נתונים. בשפת ג׳אווה נממש DTOs כ-Class, אך מבחינה רעיונית הן לא מחלקות: אין להן הכמסה [ב], ואין להם אחריות לתאר פעולות בעולם.
• בג'אווה הרבה פעמים כאשר ממשמשים DTO (לרוב מצוין ע"פ Suffix בשם) - מאפשרים לכל השדות של ה-DTO להיות public - ומדלגים על השימוש ב-getter/setters. הגיוני.
חוסר ההבחנה בין מחלקות ומבני-נתונים לא מאפיין את כל השפות: ב-#C קיימים structs, בקוטלין יש Data Classes, ובפייטון היו named tuples כסוג של ייצוג, ולאחרונה הוסיפו גם Data classes.
אפשר להסתכל על המבנים הללו רק ככלי לאופטימיזציה של קוד/ביצועים בשפה - אבל שימושי הרבה יותר להשתמש בהם ככלי להבחנה סמנטית בין אלמנטים שונים בתוכנה: מחלקות, ומבני-נתונים.
יש כמה סימנים שיעזרו לנו לזהות מבני-נתונים
:
• על מבני-נתונים אין פעולות, לפחות לא כאלו שמבצעות Business Logic.
• מחלקות יכולות להכיר מבני-נתונים, אך מבני נתונים לעולם לא יכירו מחלקות.
• אם שדות של מחלקה השתנו, זה יכול להיגמר בלי השפעה סביבתית. אם שדות של מבנה-נתונים משתנים - הם כמעט תמיד יגררו שינויים במחלקות אחרות. למה? כי זו מטרתם בחיים: להעביר נתונים בין מחלקות, וגם מ/אל מערכות חיצוניות (קריאה ל-API, שליפה מבסיס נתונים, וכו׳).
בהחלט קיימת נטייה לבלבל ולערבב בין מחלקות ומבני-נתונים. הבלבול הזה לוקח אותנו למימוש פחות נכון של פרדיגמת ה-OO - לפחות בצורה העדכנית שלה. אם אנחנו כבר משקיעים את כל העבודה בניהול מחלקות והכמסה - חבל לפספס את ההבחנה החשובה הזו!
ההבחנה בין מחלקות למבני-נתונים תורמת למידול המערכת, ותורמת להכמסה (כי אנחנו לא מבזבזים כוחות היכן שהיא לא נדרשת - וכך מצמצמים את הקולות לוותר עליה).
לסיכום
המשכנו לאורך המסלול ההיסטורי, מתכנות פרוצדורלי עד לתכנות מונחה-עצמים.
לאורך התקופה הזו, הייתה והשפיעה פרדיגמה משמעותית נוספת: פרדיגמת התכנות הפונקציונלי - שלה אני אקדיש פוסט נוסף.
שיהיה בהצלחה!
-----
[א] יש כאלו שמסווגים את הרעיון הזה כחלק מהתכנות המובנה. אין פה אמת אחת, ויש חפיפה רעיונית ותקופתית בין שתי הפרדיגמות.
באופן דומה, יש גם לא מעט חפיפה בין תכנות פרוצדורלי ל-OO. לצורך הפוסט - אני מפשט את הדברים ופשוט מייחס כל רעיון לפרדיגמה אחת ויחידה.
[ב] זה כמובן, חצי מדויק: לפעמים מבנה הנתונים הוא מורכב (למשל HashMap) ואנו מכמיסים את מורכבות המבנה הפנימי בכדי לחשוף למשתמש מ
מאת: ליאור בר-און, ארכיטקט ראשי בחברת Gett וכותב בבלוג http://www.softwarearchiblog.com
רוצים להתעדכן בתכנים נוספים בנושאי ענן וטכנולוגיות מתקדמות? הירשמו עכשיו לניוזלטר שלנו ותמיד תישארו בעניינים > להרשמה
לפרטים נוספים ויצירת קשר עם נציג אורקל
הודעתך לא התקבלה - נסה שוב מאוחר יותר