מבט-על על ארגז הכלים של Squeak, כלי ה-System Browser, ה-Package Browser והמחלקה SystemNavigation
היכרות מלאה עם 8 כלי הפיתוח המשלימים של Squeak, שורת 8 כפתורי החקירה של ה-System Browser (כולל קידוד 5 הצבעים של כפתור ה-inheritance), תפריטי ההקשר, פיצול הקטגוריות ב-Package Pane Browser והפעלה תכנותית דרך SystemNavigation.
מודל מנטלי ועיקרון מנחה: כלי הפיתוח ב-Squeak אינם תוכנות חיצוניות — הם עצמים חיים בשירותך!
תחשוב על Squeak כמו על מעבדת מחקר חיה שבה המיקרוסקופים, הסורקים והרובוטים בנויים מאותם תאים בדיוק כמו הדגימות שאתה חוקר. לכן אתה יכול גם ללחוץ על כפתור בממשק הגרפי וגם לשלוח הודעה בקוד כדי לפתוח כל דפדפן!
ה-System Browser עצמו נשען על המחלקה SystemNavigation (ומופעל כ-Singleton דרך SystemNavigation default). כל פעולת ניווט שאנו עושים עם העכבר ניתנת להפעלה פרוגרמטית מתוך הקוד!
שורת הכפתורים שבמרכז ה-System Browser (ובמיוחד כפתור inheritance המשנה את צבעו לפי אופי הדריסה והירושה) חוסכת לך שעות של חיפוש ידני במעלה ובמורד עץ המחלקות.
1. סעיף 9.1: מבט-על (Overview) – 8 הכלים המרכזיים של סביבת Squeak
מיפוי מלא של ארגז כלי הפיתוח המשלימים את הכלים שהכרנו בפרקים הקודמים
שלום לך! עד עכשיו כבר הכרנו את אבני היסוד של Smalltalk והתחלנו לכתוב קוד בסיסי. כעת אני רוצה לקחת אותך אל מאחורי הקלעים של סביבת העבודה Squeak ולהראות לך לעומק את ארגז הכלים המתקדם שלה. כלים אלו משלימים את הכלים שהכרנו קודם לכן, ויחד הם מעניקים לנו שליטה מלאה בניהול מארזי תוכנה, בבחינה ושינוי של עצמים חיים בזיכרון, ובגולת הכותרת של Smalltalk — ניפוי שגיאות ופיתוח קוד חי בזמן ריצה באמצעות ה-Debugger.
בוא נמפה תחילה את 8 קבוצות הכלים המרכזיות שנחקור לאורך הפרק:
כלי הפיתוח הראשי והמרכזי המשמש להצגה, לכתיבה וליצירה של מחלקות ומתודות.
כלי ייעודי ומתקדם לניהול, שמירה, שיתוף וטעינה של חבילות ומארזי תוכנה (Packages).
כלים המשמשים לבחינה, להצגה, לשינוי ולאינטראקציה ישירה עם המצב הפנימי של עצמים בזיכרון.
מעבר לניפוי שגיאות, מתפקד כסביבת עבודה מלאה המאפשרת הוספה, שינוי וכתיבת קוד חי בזמן אמת ישירות בתוך מחסנית הקריאות בעת עצירה.
כלי לבחינה ולשליטה בתהליכים השונים (Threads/Processes) הרצים בו-זמנית ברגע נתון בתוך סביבת העבודה.
מתודות וכלים לאיתור וחיפוש קוד ומתודות לפי שם, לפי חלק משם או לפי דוגמת קלט ופלט.
כלים לבחינה ולניהול של אוסף ומקבצי השינויים (Change Sets) שבוצעו בסביבת העבודה.
סייר קבצים מובנה להצגת מערכת הקבצים של מערכת ההפעלה, ניווט בה, צפייה בקבצים וטעינת קוד.
2. סעיף 9.2: כלי ה-System Browser, ה-Package Browser והמחלקה SystemNavigation
שורת 8 כפתורי הפעולה, קידוד הצבעים של כפתור ה-inheritance, תפריטי ההקשר והניווט הפרוגרמטי
ה-System Browser הוא כלי הפיתוח העיקרי שלנו ליצירת מחלקות ולהצגתן. ממש במרכז החלון שלו (מתחת לארבע חלוניות הניווט של הקטגוריות, המחלקות, הפרוטוקולים והמתודות) ממוקמת שורת כפתורים ייעודיים המאפשרת לנו לקבל מידע נוסף ולבחון את הקוד מכל זווית אפשרית. בוא נעבור יחד על כל אחד מ-8 הכפתורים האלה:
פותח חלון System Browser נוסף וממוקד סביב הפריט הנבחר, כדי שתוכל לעיין במחלקות שונות תוך כדי כתיבת הקוד.
💡 דגש שימושי חשוב: כאשר סמן העכבר ממוקם על חלונית/רשימת הקטגוריות (החלונית השמאלית ביותר), לחיצה על הקיצור Ctrl+b מבצעת פעולת back... — הצגת רשימה של המחלקות שהוצגו לאחרונה לצורך בחירה וניווט מהיר לאחור!
פותח דפדפן (browser) ייעודי המציג את רשימת כל המתודות במערכת השולחות את ההודעה הנבחרת. לחיצה על הכפתור מציגה תחילה את רשימת ההודעות שהמתודה הנוכחית שולחת בעצמה, ולאחר בחירת הודעה מהרשימה, מוצגת בחלון ייעודי רשימת כל שולחי ההודעה ההיא.
מציג את רשימת כל המחלקות והמתודות במערכת המממשות את ההודעה/המתודה הנבחרת. ניתן לגשת לפעולה זו גם מתוך תפריט ההקשר של חלון רשימת המתודות.
מציג ב-browser ייעודי את היסטוריית הגרסאות הקודמות והשינויים של המתודה הנוכחית (מתוך קובץ ה-changes), מאפשר לעיין בהן, מדגים את ההבדלים ביניהן, ומאפשר לחזור לגרסה קודמת.
מציג ב-browser ייעודי את שרשרת הירושה של המתודה — רשימת המתודות במעלה היררכיית הירושה המוגדרות מחדש (overridden) על ידי המתודה הנוכחית. צבע הכפתור עצמו משתנה דינמית ומספק מידע חיוני על אופי הגדרתה של המתודה:
super).
super).
super), וגם מוגדרת מחדש בתת-מחלקה.
super, וגם מוגדרת מחדש בתת-מחלקה.
מציג ב-browser ייעודי (Hierarchy Browser) את עץ / היררכיית הירושה המלאה של המחלקה הנוכחית, וכך ניתן לראות בקלות פרטים על מתודות שנורשו ממחלקות-העל.
מציג רשימה של משתני המופע או של משתני המופע והמחלקה (נקבע לפי מצב הבחירה בכפתורי ה-instance וה-class שמתחת לרשימת המחלקות). הרשימה כוללת גם משתנים שהתקבלו בירושה, ובחירה במשתנה תציג ב-browser ייעודי באילו מתודות נעשה בו שימוש.
מאפשר לבחור את אופן הצגת הקוד (התצוגה שתוצג בחלונית המרכזית של ה-System Browser) — כגון קוד מקור רגיל, bytecode, גרסאות מתועדות ותצוגות שונות של המתודה הנבחרת.
🖱️ פקודות מרכזיות בתפריטי ההקשר (כפתור ימני / צהוב)
file out: מייצא את הקוד לקובץ מקור חיצוני (.st) — ניתן להפעלה על קטגוריה שלמה, מחלקה בודדת או מתודה יחידה בהתאם לעצם/חלון הנבחר.find class…(מחלונית הקטגוריות): חיפוש מהיר של מחלקה לפי שמה המדויק/המלא או לפי חלק משם.Browse Protocol(מחלונית המחלקות): פותח דפדפן ייעודי המציג את כלל המתודות שהמחלקה מבינה, לרבות כל המתודות שהיא ירשה ממחלקות-העל במעלה ההיררכיה.Browse Hierarchy/Show Hierarchy(מחלונית המחלקות): מציג את עץ הירושה של המחלקה בחלון ייעודי (Browse Hierarchy) או ישירות בחלונית המרכזית של ה-System Browser עצמו (Show Hierarchy).
🗂️ דפדפן המארזים – Package Browser (package pane browser)
בסביבת Squeak מחלקות מאורגנות בקטגוריות, ושמות של קטגוריות רבות מכילים מקף (-) המפריד בין תחום ראשי לתחום משני (לדוגמה: Kernel-Objects, Kernel-Numbers, Collections-Strings).
הכלי Package Browser (מופעל מתפריט העולם דרך World -> open… -> package pane browser) מפצל את חלונית הקטגוריות השמאלית לשתי חלוניות נפרדות להקלת החיפוש וההתמצאות:
• החלונית השמאלית: מציגה את השמות הראשיים (משמאל למקף – למשל Kernel, Collections).
• החלונית השנייה: מציגה את השמות המשניים / תתי-הקטגוריות של השם הראשי שנבחר (מימין למקף – למשל Objects, Numbers).
🤖 המחלקה SystemNavigation (שליטה תכנותית)
כלי הדפדפן (System Browser) הוא בעצמו מופע הנשען על שירותיה של המחלקה SystemNavigation (מקטגוריית System-Support), המשמשת כמנוע הניווט הפרוגרמטי של המערכת. הגישה אליה מתבצעת דרך מופע ה-Singleton שלה: SystemNavigation default.
SystemNavigation default browseClass: EllipseMorph.
SystemNavigation default browseHierarchy: EllipseMorph.
SystemNavigation default browseAllCallsOn: #drawOn:.
מבנה החלוניות, שורת 8 הכפתורים, פיצול הקטגוריות במקף (-) ומנוע הניווט התכנותי
מיני-סימולציה 9.1: מפענח 5 הצבעים של כפתור ה-inheritance ב-System Browser
מעבדת System Browser, Package Pane Browser והמחלקה SystemNavigation
הגשר הנרטיבי: למדנו לנווט במחלקות ובמתודות – אבל איך אורזים אותן למארזים ואיך חוקרים עצמים חיים בזיכרון?
ה-System Browser נותן לנו שליטה מלאה בקוד של מחלקות ומתודות. אבל כשמפתחים מערכת שלמה (כמו SqueakLink), איך אנחנו שומרים, משתפים ומנהלים גרסאות של מארזי תוכנה שלמים? ואיך אנחנו משייכים מתודה בודדת במחלקה קיימת (כמו String) לתוך המארז שלנו בעזרת כוכבית (*)?
ומעבר לקוד הסטטי — איך אנחנו פותחים עצם חי בזיכרון (כמו TimeStamp now) ומשנים לו את שדה ה-seconds בזמן אמת? בוא נעבור ליחידה 9.3–9.4 ונגלה את Monticello, ה-Inspector וה-Explorer!
ניהול מארזים עם Monticello ובחינת עצמים חיים עם Inspector ו-Explorer
איך מארגנים מחלקות ומתודות במארזים (Packages), חוק הבלעדיות של מחלקה ומתודה, שיוך מתודות הרחבה באמצעות כוכבית (*), המחלקה PackageInfo, מאגר ה-package-cache, וניתוח ושינוי חי של המופע TimeStamp now ב-Inspector וב-Explorer.
מודל מנטלי ועיקרון מנחה: מארזים מארגנים את הקוד, ו-Inspector/Explorer מאפשרים לגעת בעצמים החיים!
Monticello הוא כמו מערכת המכולות והגיבוי של הנמל: כל מחלקה וכל מתודה ארוזות במכולה אחת בדיוק (ואפילו מתודה בודדת במחלקה זרה מקבלת תווית *שם-מארז ונארזת איתו). ואילו ה-Inspector וה-Explorer הם מכשיר רנטגן שמאפשר לא רק להביט לתוך עצם חי בזיכרון, אלא גם לשנות לו את הערכים תוך כדי תנועה!
כלל הבלעדיות במארזים: כל מחלקה וכל מתודה שייכות למארז אחד בלבד! כדי לשייך מתודה בודדת (למשל asSQL ב-String) למארז שלנו, משייכים אותה לפרוטוקול ששמו מתחיל בכוכבית ואחריה שם המארז באותיות קטנות (כגון *squeaklink).
בחלונית התחתונה של ה-Inspector המשתנה self קשור תמיד לעצם הנבדק (וכל משתני המופע שלו זמינים לעריכה ישירה), ואילו ב-Explorer העצם מוצג כעץ היררכי שבו self מתעדכן דינמית לפי הצומת שאתה בוחר בעץ!
1. סעיף 9.3: ניהול מארזים ותצורה באמצעות Monticello
מהות המארז (Package), כלל הבלעדיות, פרוטוקול כוכבית (*), המחלקה PackageInfo ומבנה Monticello Browser
כשאנחנו בונים מערכת תוכנה אמיתית, אנחנו לא עובדים על מחלקה בודדת במנותק, אלא מאגדים את העבודה שלנו לתוך חבילות תוכנה מסודרות. בסביבת Squeak, כלי ברירת המחדל לניהול תצורה ומארזים (Package Management ו-Version Control) נקרא Monticello. הכלי הזה מאפשר לנו יצירה, טעינה, עיון, שמירה, השוואת גרסאות (Diff), מיזוג (Merge) והפצה של חבילות תוכנה — הן באופן מקומי והן מרשת האינטרנט.
📦 מהו מארז (Package) ומהו כלל הבלעדיות?
מארז (Package) הוא אוסף מאוגד של מחלקות ומתודות בעלות זיקה משותפת הקשורות למערכת מסוימת (לדוגמה, מערכת SqueakLink הכוללת קטגוריות כמו Model-SqueakLink).
⚖️ חוק יסוד (כלל הבלעדיות): כל מחלקה וכל מתודה שייכות למארז אחד בלבד!
✳️ איך משייכים מתודה בודדת במחלקה חיצונית למארז שלנו?
מעבר לקטגוריות שלמות של מחלקות, מערכת יכולה לכלול גם מתודות בודדות במחלקות שונות לחלוטין שאינן שייכות ישירות למארז (למשל, הוספת מתודה בשם asSQL למחלקות המערכת Object, String ו-Date).
כדי לשייך מתודה בודדת כזו למארז שלנו, אנו משייכים אותה לפרוטוקול מיוחד במחלקה ששמו מתחיל בסימן כוכבית (*) מלווה בשם המארז באותיות קטנות (למשל: *squeaklink).
🔍 המחלקה PackageInfo ומבנה חלון ה-Monticello Browser
World -> open… -> Monticello Browser
מאחורי הקלעים, מחלקת התשתית PackageInfo (תחת PackageInfo-Base) מנהלת את כל המידע אודות המארזים. אם נרצה לשלוף בקוד את רשימת כל המחלקות השייכות למארז מסוים (למשל עבור המארז Collections), נריץ את הביטוי:
image).
package-cache:
מציגה רשימה של מאגרי מארזים (Repositories) מקומיים וברשת האינטרנט. המאגר הראשון ברשימה, package-cache, הוא מאגר מקומי אוטומטי בספרייה בעלת אותו שם תחת תיקיית ההתקנה של Squeak, השומר עותקים של כל החבילות בפורמט קובצי .mcz (קובץ ZIP ייעודי המכיל את קוד המקור וההיסטוריה) ומשמש כגיבוי מקומי או לייבוא ישיר של מארזים קיימים.
+Package), עיון בתוכן ובגרסאות קודמות של מאגר מרוחק (Open), טעינת גרסת מארז למערכת (Load), שמירת גרסה חדשה במאגר מקומי/מרוחק (Save), והשוואת שינויים (Changes).
2. סעיף 9.4: בחינה ושינוי של עצמים חיים עם ה-Inspector וה-Explorer
אינטראקציה ישירה בזיכרון עם מופע חותמת זמן (TimeStamp now), שינוי ערכים בזמן אמת ומעבר לתצוגת עץ
ב-Smalltalk העצמים אינם שורות טקסט רחוקות — הם חיים בזיכרון עכשיו! הכלים Inspector ו-Explorer מאפשרים לנו לפתוח כל עצם חי, להציג את משתני המופע שלו, לתקשר איתו ולשנות את מצבו הפנימי בזמן אמת.
בוא נדגים זאת יחד על מופע של חותמת זמן הנוצר באמצעות הביטוי TimeStamp now:
🔬 כלי ה-Inspector (inspect it / Ctrl+i)
TimeStamp
רושמים בחלון העבודה (Workspace) את הביטוי TimeStamp now ומפעילים עליו inspect it מתפריט ההקשר (או Ctrl+i):
- כותרת החלון: מציינת תמיד את שם המחלקה של העצם (בדוגמה שלנו:
TimeStamp). - החלונית השמאלית: מציגה את רשימת משתני המופע: תחילה הפריט
self(המתייחס לעצם עצמו), אחריוall inst vars(המציג בחלונית הימנית רשימה של כל שדות המופע וערכיהם המחרוזתיים יחד), ולאחריהם משתני המופע עצמם:seconds,offset,jdn,nanos. - החלונית הימנית: מציגה את ערכו (הייצוג המחרוזתי) של המשתנה שנבחר בשמאל. ניתן לערוך את ערכו ישירות בחלונית הימנית ולשמור ב-
acceptבתפריט ההקשר! - החלונית התחתונה (Workspace מקומי): אזור עבודה שבו המשתנה
selfמקושר ישירות לעצם הנבדק, וכל משתני המופע שלו מוכרים ונגישים ישירות. הקלדת הביטויseconds := 0וביצועdo itישנו מיידית את הערך שלsecondsל-0 בתוך העצם החי שבזיכרון!
🌳 כלי ה-Explorer (explore it / Ctrl+Shift+I)
Tree View
ה-Explorer דומה ל-Inspector אך מתקדם יותר, משום שהוא מציג את העצם ואת משתניו במבנה היררכי של עץ (Tree View):
- דרכי הפעלה: באמצעות הפקודה
explore itבתפריט ההקשר (או בקיצורי המקלדתCtrl+Shift+I/Shift+Alt+i) מתוך Workspace, או מתוך חלונית העבודה של ה-Inspector עצמו (ע"י הקלדתselfובחירתexplore it). - מעבר מהיר בין הכלים: בפינה הימנית-תחתונה של החלונות מופיע כפתור המאפשר מעבר מהיר בין תצוגת Inspector לתצוגת Explorer ולהיפך.
- ניווט היררכי עמוק: מאפשר "לפתוח" בלחיצה כל תת-עצם, לבחון את מחלקת-העל שלו, את מילון המתודות שלו ואת המבנה הפנימי.
- קישור דינמי של
self: בחלונית התחתונה של ה-Explorer, המשתנהselfיכול להיות מקושר לעצם עצמו, או להשתנות ולהיות מקושר ספציפית לכל אחד ממשתני העצם שהמשתמש בוחר בעץ!
מבנה חלון Monticello (ופרוטוקול *) לצד בחינת המופע TimeStamp now
מיני-סימולציה 9.2: בודק השיוך למארזים ב-Monticello (כלל הבלעדיות ופרוטוקול *)
מעבדת Inspector ו-Explorer החיה על המופע TimeStamp now
self ומשתני המופע מוכרים ישירות):הגשר הנרטיבי: ראינו איך בוחנים ומשנים עצם חי בזיכרון – אבל מה קורה כשהקוד שלנו קורס באמצע ריצה?
ברוב שפות התכנות, כשיש שגיאת ריצה התוכנית מתרסקת, צריך לסגור הכל, לתקן בעורך הטקסט, להדר מחדש את הפרויקט כולו ולהתחיל מהתחלה.
אבל ב-Smalltalk מחכה לנו אחד הכלים המופלאים ביותר בעולם התכנות: ה-Debugger! ביחידה הבאה נכתוב יחד את המתודה suffix במחלקה String, נגרום לה לקרוס על 'readme.txt' suffix, ונראה איך מתקנים 3 באגים שונים בזמן אמת ישירות בתוך מחסנית הקריאות החיה!
ה-Debugger ב-Squeak: ניפוי שגיאות ופיתוח קוד חי בזמן ריצה (מקרה הבוחן String>>suffix)
ניתוח מלא של מחסנית הקריאות (Stack Trace), שורת 7 כפתורי הבקרה (Proceed, Restart, Into, Over, Through, Where, Full Stack), ואיתור ותיקון חי של שלושת הבאגים במתודה suffix ללא סגירת התוכנית!
מודל מנטלי ועיקרון מנחה: ה-Debugger ב-Squeak הוא חדר ניתוח שבו מתקנים את הקוד כשהלב של התוכנית ממשיך לפעום!
במקום לעצור את המכונית, לגרור אותה למוסך, לפרק את המנוע ולהתחיל את הנסיעה מחדש — ה-Debugger ב-Squeak מקפיא את הרגע המדויק של התקלה, מאפשר לך לשנות את קוד המקור, לשמור ב-accept, ללחוץ Restart ולהמשיך בנסיעה!
ב-Smalltalk, מחרוזת בעלת תו בודד ('.') ותו בודד ($.) הם עצמים מטיפוסים שונים לחלוטין ולעולם אינם שווים ($. = '.' מחזיר false)! לכן חובה להמיר ל-asCharacter.
השימוש ב-detect:ifNone: [self size] יחד עם חיתוך מ-dotPosition + 1 פותר באלגנטיות מושלמת גם את הסרת הנקודה מהסיומת וגם את מקרה הקצה של שם קובץ ללא נקודה כלל!
1. מקרה הבוחן: הוספת המתודה suffix למחלקה String וקריסת התוכנית
איך ניסיון תמים לחלץ סיומת של שם קובץ מוביל לשגיאת NotFound ופותח לנו צוהר אל ה-Debugger
הדרך הטובה ביותר להכיר את עוצמתו של ה-Debugger ב-Squeak היא להפעיל אותו מול קוד חי המכיל שגיאה.
בוא נציב לעצמנו משימה מעשית: אנחנו רוצים להוסיף למחלקה String מתודה חדשה בשם suffix, שמניחה שהמחרוזת מייצגת שם קובץ ומחזירה את הסיומת שלו — כלומר את החלק שמופיע לאחר הנקודה (למשל, עבור 'readme.txt' אנו מצפים לקבל 'txt').
נתחיל במימוש הראשוני הבא (שבו מסתתרים מספר באגים מלמדים במיוחד):
"assumes that I'm a file name, and answers my suffix, the part after the dot"
| dot dotPosition |
dot := FileDirectory dot.
dotPosition := (self size to: 1 by: -1) detect: [:i | (self at: i) = dot].
^ self copyFrom: dotPosition to: self size
כעת אנחנו ניגשים ל-Workspace, רושמים את הביטוי 'readme.txt' suffix ומריצים אותו באמצעות print it.
במקום לקבל 'txt', הביצוע נכשל ומיד קופץ חלון התראה של שגיאת ריצה:
NotFound: Object is not in the collection.
🥞 מחסנית הקריאות (Stack Trace) שהובילה לשגיאה
חלון השגיאה והחלונית העליונה של ה-Debugger מציגים את שרשרת ההודעות המדויקת (מלמטה למעלה או מהקריאה הראשונה עד לשגיאה):
- DoIt (הרצת הביטוי מחלונית העבודה)
- ByteString(String)>>suffix (המתודה שלנו)
- Interval(Collection)>>detect: (חיפוש הנקודה)
- Interval(Collection)>>detect:ifNone:
- error: / errorNotFound: (כישלון באיתור האיבר באוסף!)
🎛️ מבנה חלון ה-Debugger ושורת 7 כפתורי הבקרה
לחיצה על כפתור Debug (או על אחת משורות ה-trace) פותחת את ה-Debugger המלא. במרכזו מוצג קוד המתודה המסומנת עם הדגשת הביטוי שנכשל, בתחתיתו מוצגים משתני המקבל (self ושדות המופע משמאל) ומשתני ההקשר הפעיל (thisContext, משתנים מקומיים וארגומנטים מימין), ובמרכזו שורת 7 כפתורי הבקרה:
- •
Proceed: המשך ביצוע התוכנית כרגיל. - •
Restart: איפוס המסגרת הנוכחית וחזרה לשורה הראשונה (לראש) של המתודה הנבחרת לצורך הרצה מחדש. - •
Into: כניסה לתוך המתודה הנקראת (Step Into). - •
Over: ביצוע השורה הנוכחית ומעבר לשורה הבאה (Step Over). - •
Through: צעידה וכניסה לתוך בלוק קוד (Step Through – למשל מעקב שלב-אחר-שלב אחרי ריצת הבלוק בתוךdo:/detect:). - •
Where: סימון והצגת מיקום הביצוע הנוכחי. - •
Full Stack: הצגת המחסנית המלאה עד רמת המערכת הבסיסית ביותר.
2. שלושת שלבי הניפוי והתיקון החי של suffix בתוך ה-Debugger
איך אנחנו מאתרים ומתקנים את שלושת הבאגים תוך כדי ריצה מבלי לסגור את החלון
כשאנחנו בוחרים את המסגרת ByteString(String)>>suffix, לוחצים על Restart וצועדים לתוך הבלוק של לולאת ה-detect: באמצעות Through ו-Over, אנו רואים בחלונית המשתנים הימנית התחתונה שהאינדקס i יורד מ-10 ל-1. אבל גם כש-i מגיע לאינדקס 7 (שבו נמצאת הנקודה במחרוזת 'readme.txt'), הבדיקה (self at: i) = dot נכשלת והלולאה לא עוצרת!
מדוע? משום שהביטוי FileDirectory dot מחזיר מחרוזת בעלת תו בודד ('.'), ואילו ההודעה self at: i מחזירה מופע של תו ($.)! ב-Smalltalk תו ומחרוזת הם עצמים מטיפוסים שונים לחלוטין ולעולם אינם שווים!
התיקון החי ב-Debugger: ישירות בחלונית הקוד של ה-Debugger אנו משנים את השורה הראשונה ל-dot := FileDirectory dot asCharacter., שומרים באמצעות accept (s) (הקוד מתהדר ומוטמע מיידית!), ולוחצים על Restart.
לאחר התיקון הראשון המתודה רצה ואינה קורסת, אך היא מחזירה את המחרוזת '.txt' (כולל הנקודה עצמה באינדקס 7) במקום להחזיר רק את הסיומת 'txt'!
התיקון: עלינו להתחיל את חיתוך המחרוזת מיקום אחד אחרי הנקודה:
^ self copyFrom: dotPosition + 1 to: self size.
מה יקרה אם נפעיל את המתודה על שם קובץ שאינו מכיל נקודה כלל (כגון 'readme')? מתודת ה-detect: תסרוק את כל המחרוזת, לא תמצא נקודה, ותקרוס שוב עם שגיאת NotFound!
הפתרון האלגנטי והסופי: נחליף את detect: במתודה detect:ifNone:, ונעביר לה בלוק חלופי המחזיר במקרה של היעדר נקודה את אורך המחרוזת כולה ([self size]):
"assumes that I'm a file name, and answers my suffix, the part after the dot"
| dot dotPosition |
dot := FileDirectory dot asCharacter.
dotPosition := (self size to: 1 by: -1) detect: [:i | (self at: i) = dot ] ifNone: [self size].
^ self copyFrom: dotPosition + 1 to: self size
💡 שים לב לאלגנטיות המתמטית: כשאין נקודה במחרוזת (למשל 'readme' שאורכה 6), המשתנה dotPosition מקבל 6 (`self size`), ואז הביטוי self copyFrom: 7 to: 6 (כלומר מ-self size + 1 עד self size) מחזיר באופן טבעי מחרוזת ריקה ('')!
String>>suffixמחסנית הקריאות (Stack Trace), שורת 7 כפתורי הבקרה, החלוניות התחתונות ו-3 התיקונים החיים
מיני-סימולציה 9.3: סייר 7 כפתורי הבקרה של ה-Debugger ובודק הטיפוסים ($. = '.')
מעבדת ה-Debugger החיה: צעד בתוך 'readme.txt' suffix ותקן את 3 הבאגים בזמן אמת!
הגשר הנרטיבי: תיקנו קוד חי ב-Debugger – עכשיו איך שולטים בתהליכים, מאתרים מתודות ומשחזרים קוד שאבד?
ראינו איך ה-Debugger הופך את ניפוי השגיאות לחוויה של פיתוח חי. ביחידה הבאה נשלים את הכרת חמשת הכלים הנותרים של פרק 9 (סעיפים 9.6 עד 9.10): Process Browser לניהול תהליכים רצים, Method Finder ו-Message Names לאיתור מתודות (לפי שם או לפי דוגמת קלט/פלט כמו 4 . 16), Change Set Browser ו-Change Sorter לניהול מקבצי שינויים, File List Browser לניווט בקבצים וטעינת קוד, ושחזור קוד שאבד (Code Recovery) מתוך קובץ ה-.changes!
Process Browser, איתור מתודות (Method Finder ו-Message Names), מקבצי שינויים (Change Sets), File List Browser ושחזור קוד
ניטור ושליטה בתהליכים פעילים, חיפוש מתודות לפי דוגמת קלט/פלט (4 . 16) לעומת צפייה ישירה בקוד ב-Message Names, ארגון והעברת שינויים ב-Simple/Dual Change Sorter, סרגל הפעולות הדינמי בסייר הקבצים ושחזור קוד שאבד מתוך ה-Changes Log.
מודל מנטלי ועיקרון מנחה: מערכת חיה לעולם אינה הולכת לאיבוד — כל תהליך מנוטר וכל שינוי מתועד!
תחשוב על חמשת הכלים האלה כעל מגדל הפיקוח והקופסה השחורה של Squeak: ה-Process Browser מפקח על הטיסות באוויר, ה-Method Finder ו-Message Names הם מנועי החיפוש החכמים, ומקבצי השינויים (Change Sets) וקובץ ה-.changes הם הקופסה השחורה שמאפשרת לשחזר כל שורת קוד גם אחרי קריסה!
Method Finder מול Message Names: השתמש ב-Method Finder כשאתה רוצה לחפש מתודה לפי דוגמת קלט ופלט (כגון 4 . 16 $\rightarrow$ 4 squared), והשתמש ב-Message Names לעבודה יומיומית נוחה משום שהוא מציג את קוד המתודה ישירות בחלונית התחתונה שלו ללא פתיחת System Browser חדש!
סביבת העבודה מכילה מספר מקבצי שינויים (Change Sets) במקביל, אך בכל רגע נתון קיים מקבץ פעיל יחיד (כגון Unnamed1) שאליו מתנקזים השינויים השוטפים, וה-Dual Change Sorter מאפשר להעביר שינויים בין מקבצים!
1. סעיף 9.6: Process Browser (דפדפן התהליכים)
בחינה, ניטור ושליטה בכל התהליכים הרצים בו-זמנית בתוך סביבת העבודה
בסביבת הריצה של Squeak פועלים בו-זמנית מספר רב של תהליכים (Processes / Threads). כלי ה-Process Browser מאפשר לנו לבחון, לנטר ולשלוט בכל התהליכים השונים הרצים ברגע נתון במערכת.
🚪 איך פותחים את ה-Process Browser?
• מתפריט העולם: World -> open… -> process browser
• משורת התפריטים העליונה: Tools -> Process Browser
⚙️ יכולות ניהול ושליטה בתהליכים:
• צפייה ברשימת כל התהליכים הפעילים וברמת העדיפות (Priority) שלהם במעבד.
• בחינת מחסנית הקריאות הפעילה של כל תהליך.
• שליטה במצב התהליך: השהיה (Suspend), חידוש פעולה (Resume), שינוי עדיפות, או סיום כפוי (Terminate) של תהליכים שנתקעו או נכנסו ללולאה אינסופית.
2. סעיף 9.7: איתור מתודות – Method Finder מול Message Names
חיפוש לפי שם או לפי דוגמת קלט/פלט לעומת צפייה נוחה בקוד ללא פתיחת חלונות נוספים
בארגז הכלים העצום של Squeak קיימות אלפי מתודות מוכנות. איך נמצא את המתודה שאנחנו צריכים? לשם כך עומדים לרשותנו שני כלים משלימים:
🔎 1. Method Finder (סייר המתודות)
Example-basedפתיחה: World -> open… -> method finder | Tools -> Method Finder
- חיפוש לפי שם או חלק משם (substring): הקלדת מחרוזת (לדוגמה
time) מציגה את כל המתודות ששמן כולל מחרוזת זו. - חיפוש לפי דוגמה (Example-based search): הקלדת ביטוי המדגים את פעולת המתודה (קלט מול פלט רצוי) בתבנית
מקבל . ארגומנטים . תוצאה צפויהמופרדים בנקודות — למשל הקלדת4 . 16מחזירה את הזיהוי4 squared --> 16! - אופן הצגת התוצאה: בחירת מתודה מהרשימה מציגה את המחלקות הכוללות אותה, ובחירה בה פותחת חלון System Browser חדש המציג את הקוד המלא של המתודה.
💬 2. Message Names (שמות הודעות)
נוח לעבודה שוטפת!פתיחה: World -> open… -> message names
- ייעוד ומאפיינים: כלי ממוקד לאיתור מתודות לפי שמן המלא או לפי תת-מחרוזת המוכלת בשמן (אפשרויות החיפוש שלו מצומצמות יותר כי אינו מחפש לפי דוגמת קלט/פלט).
- יתרונו המעשי הבולט: נוח בהרבה לעבודה יומיומית שוטפת, משום שהוא מציג את המתודות ואת קוד המקור שלהן ישירות בחלונית התחתונה הפנימית שלו, ובכך חוסך פתיחה של חלונות System Browser חדשים!
- דוגמה: חיפוש המחרוזת
suffixמציג בחלונית השמאלית את כל שמות ההודעות המכילות מילה זו (sourceFileSuffixes,suffix,suffixOf:). בחירה ב-suffixמציגה בחלונית העליונה הימנית אתString suffix, ובחירה בה מציגה את קוד המקור המלא ישירות בחלונית העריכה התחתונה!
3. סעיף 9.8: ניהול מקבצי שינויים – Change Set Browser ו-Change Sorter
איך מאורגנים השינויים בזיכרון (Change Sets), המקבץ הפעיל היחיד והעברת שינויים בין מקבצים
כל שינוי קוד, הגדרת מחלקה, הוספת מתודה או מחיקה שאנחנו מבצעים במהלך העבודה אינם נשמרים רק בקובץ ה-.changes, אלא מאורגנים בזיכרון בתוך מקבצים מובנים הנקראים Change Sets (מקבצי שינויים).
סביבת העבודה מכילה מספר מקבצי שינויים במקביל, אך בכל רגע נתון קיים מקבץ פעיל יחיד (Current Change Set) שאליו מתנקזים ומתועדים כל השינויים השוטפים המבוצעים באותו רגע (כברירת מחדל נושא שם כגון Unnamed1).
📋 1. Change Set Browser (Simple Change Sorter)
World -> open… -> simple change sorter | מתפריט Tools
- חלונית שמאלית עליונה: רשימת מקבצי השינויים, תוך הדגשת המקבץ הפעיל הנוכחי.
- חלונית ימנית עליונה: רשימת המחלקות שהשתנו במקבץ הנבחר (למשל
String {Collections-Strings}). - חלונית אמצעית (מרכזית): רשימת המתודות שהשתנו במחלקה הנבחרת (למשל
suffix {as yet unclassified}). - חלונית תחתונה: מציגה את קוד המקור של המתודה שנבחרה מתוך המקבץ.
- תפריטי הקשר: מאפשרים להסיר שינויים מתוך המקבץ, למחוק מחלקות או מתודות מרשימת השינויים של המקבץ, ולשנות את שמו.
🔀 2. Change Sorter – Dual Change Sorter
World -> open… -> dual change sorter | מתפריט Tools
מורכב בפועל משני חלונות Change Set Browsers המוצבים זה לצד זה באותו החלון!
תפקידו המרכזי: מאפשר להעביר (להעתיק/לגרור) ולמזג שינויים — הן מחלקות שלמות והן מתודות בודדות — ממקבץ שינויים אחד למקבץ שינויים אחר באופן חזותי ונוח.
4. סעיפים 9.9–9.10: סייר הקבצים (File List Browser) ושחזור קוד שאבד (Code Recovery)
ניווט במערכת הקבצים עם סרגל כפתורים דינמי, ושחזור מלא של קוד מתוך קובץ ה-.changes ומקבצי השינויים
📁 סעיף 9.9: File List Browser (סייר הקבצים)
סרגל דינמיWorld -> open… -> file list | Tools -> file list
מאפשר לנווט, לצפות ולנהל את מערכת הקבצים של המחשב (מערכת ההפעלה המארחת) ישירות מתוך Squeak:
• חלונית שמאלית: עץ תיקיות היררכי לניווט בכונני המחשב ובתיקיית ה-Resources של Squeak.
• חלונית ימנית עליונה: רשימת הקבצים בתיקייה שנבחרה (שם הקובץ, תאריך ושעת עדכון אחרון, וגודל בבתים).
• חלונית תחתונה/מרכזית: תוכנו של הקובץ שנבחר.
.st או .mcz):
שורת הכפתורים מתעדכנת דינמית בהתאם לסוג הקובץ שנבחר! כשנבחר קובץ קוד מופיעים כפתורים ייעודיים:
•
file in: טעינה והידור של כל הקוד שבקובץ ישירות לתוך סביבת העבודה.
•
browse: פתיחת דפדפן קוד לקריאת המחלקות והמתודות שבקובץ מבלי לטעון אותן למערכת.
•
changes: בחינת השינויים וההבדלים בין הקוד בקובץ לבין הקוד הקיים ב-image.
•
install: התקנה מלאה של המארז למערכת.
🛟 סעיף 9.10: שחזור קוד שאבד (Code Recovery)
Changes Log
מנגנון ההגנה של מקבצי השינויים (Change Sets) וה-Changes Log: כל פעולת עריכה, הגדרת מחלקה, שמירת מתודה וביצוע פקודת do it נשמרים במקבצי השינויים ונרשמים באופן טקסטואלי ורציף אל תוך קובץ ה-.changes במחשב!
לכן, גם אם סביבת העבודה נסגרה בפתאומיות, קרסה, המשתמש יצא ללא שמירה (quit ללא save), או שקוד נמחק בטעות — המידע אינו אובד!
World -> changes... -> recover lost changes... או בוחרים באפשרות recent changes.2. נפתח דפדפן שינויים ייעודי המציג ציר זמן כרונולוגי של כל הפעולות שנרשמו בקובץ השינויים עד לרגע הסגירה או התקלה.
3. מסמנים את שורות השינויים הרצויות ובוחרים בפקודה להרצתן מחדש (
replay / file in), וכך הקוד משוחזר במלואו לתוך תמונת המערכת הנוכחית!
Process Browser, Method Finder מול Message Names, Dual Change Sorter, File List ושחזור קוד
מיני-סימולציה 9.4: השוואה חיה בין Method Finder (חיפוש לפי דוגמה) לבין Message Names
מרכז הבקרה של Squeak: Process Browser, Dual Change Sorter, File List ושחזור קוד שאבד
הגשר הנרטיבי: השלמנו את כל 10 הסעיפים של פרק 9 – בוא נסכם את הפרק ונבחן את עצמנו!
כעת, אחרי שהכרנו לעומק את כל כלי הפיתוח של סביבת העבודה Squeak — מה-System Browser, ה-Package Browser ו-SystemNavigation, דרך Monticello, ה-Inspector וה-Explorer, ועד ל-Debugger החי, ה-Process Browser, כלי החיפוש, מקבצי השינויים ושחזור הקוד — נעבור ללשונית הסיכום שבה מחכים לנו בוחן התאמת תרחישים לכלי המתאים ו-15 כרטיסיות זיכרון תלת-ממדיות!
מילון מושגים אינטראקטיבי וסיכום מלא של פרק 9 (סביבת העבודה Squeak)
אינטגרציה של כל ארגז הכלים של Squeak (סעיפים 9.1 עד 9.10), מבדק התאמת תרחישים לכלי הפיתוח, ו-15 כרטיסיות זיכרון תלת-ממדיות (3D Flashcards) לשינון ולבחינה עצמית.
מודל מנטלי ועיקרון מנחה: שליטה בארגז הכלים של Squeak הופכת אותך למתכנת שחושב וחי בתוך עולם של עצמים!
System Browser, Package Browser, SystemNavigation, Method Finder ו-Message Names מאפשרים לנו לנווט ולאתר כל מחלקה ומתודה, ו-Monticello אורז אותן למארזים מוגדרים היטב.
Inspector ו-Explorer מאפשרים לבחון ולשנות עצמים חיים בזיכרון, ה-Debugger מאפשר לתקן ולהדר קוד חי בתוך מחסנית הקריאות, וה-Process Browser שולט בתהליכים הרצים.
Change Set Browser ו-Change Sorter מנהלים וממזגים את מקבצי השינויים, File List Browser טוען קובצי קוד (.st, .mcz), ומנגנון ה-Changes Log משחזר קוד שאבד!
איך כל 8 משפחות הכלים של פרק 9 משתלבות יחד סביב סביבת ה-Image החיה
מיני-סימולציה 9.5: מבדק התאמת תרחיש לכלי – באיזה כלי ב-Squeak נבחר בכל מצב?
כרטיסיות זיכרון תלת-ממדיות (3D Flashcards) לכל 15 מושגי פרק 9
לחץ על כל כרטיסייה כדי להפוך אותה ולבחון את שליטתך בכל 15 המושגים של פרק 9:
נחשפו: 0 / 15סיימנו במלואו את פרק 9 ואת חלק IV (פיתוח תוכנה בשפת סמולטוק)! מה מחכה לנו בחלק V?
בפרק 9 רכשנו שליטה מלאה בכל ארגז הכלים של סביבת העבודה Squeak: החל מה-System Browser, ה-Package Browser והמחלקה SystemNavigation, דרך ניהול המארזים ב-Monticello, בחינת העצמים החיים ב-Inspector וב-Explorer, ניפוי השגיאות ופיתוח הקוד החי ב-Debugger, ועד לדפדפן התהליכים, איתור המתודות, ניהול מקבצי השינויים, סייר הקבצים ושחזור קוד שאבד.