סיכום קורס: תכנות מונחה עצמים

1.1–1.11 מטרות הקורס, למה Smalltalk וסביבת העבודה Squeak

• ספרי הלימוד והמקורות: הקורס מבוסס על שני ספרי מקור מרכזיים: (1) Squeak by Example (Black et al., 2007) – ללימוד שפת Smalltalk בסביבת Squeak (מתמקד בפרקים 4–9, 11–12, 17–18), ו-(2) Object-Oriented Programming (Timothy Budd, 2002) – לעקרונות תכנות מונחה עצמים בחתך שפות כגון C, C++, Ada, Modula-2, Eiffel, Java ו-Smalltalk (מתמקד בפרקים 2–3, 10, 13–16, 18).
• מדוע כדאי ללמוד Smalltalk? בדומה ל-LISP ול-LOGO, שפת Smalltalk היא שפה מונחית עצמים "טהורה" (Pure OOP) המתבססת על מנגנון הפשטה אחד ויחיד, פשוט וקליט: כל דבר הוא עצם, והתכנות מתבצע אך ורק על ידי הגדרת עצמים ושליחת הודעות ביניהם. היא כמעט נטולת תחביר ומכריחה את הסטודנט לחשוב ולתכנת בגישת OOP טהורה.
• סביבת העבודה Squeak: סביבת פיתוח בקוד פתוח תואמת Smalltalk-80, הממומשת כולה ב-Smalltalk עצמה ובעלת מנשק גרפי עשיר (ששימש אף את אולפני Disney ביצירת סרטים).

2.1 דוגמה לשימוש במנגנוני הפשטה: מניעת חזרה על קבועים

מנגנוני הפשטה מוכרים בשפות תכנות: משתנים, קבועים, טיפוסי נתונים, פרוצדורות/פונקציות, מודולים, טיפוסי נתונים מופשטים (ADT), מחלקות וירושה.
לדוגמה, נניח שב-C++ מוגדר מערך int a[100]; ולולאה for (i = 0; i < 100; i++) cout << a[i];. להלן השוואת 4 מנגנוני הפשטה למניעת חזרה על הקבוע 100 ביתרונותיהם וחסרונותיהם:

2.2 ★ 7 שלבי התפתחות מנגנוני ההפשטה (סעיפים 2.2.1–2.2.7)

3.1–3.3 סוגי עצמים, 3 מאפייני העצם ודוגמאות

• שאלת מפתח: איזה מושג חשוב יותר ב-OOP – "עצם" או "מחלקה"? פתרון: המושג "עצם" הוא בסיסי יותר כמובן, אך למעשה מושג ה"מחלקה" הוא חשוב יותר (כי הוא מנגנון ההפשטה המגדיר קבוצות של עצמים).
• סיווג העצמים לשני מרחבים:
  1. עצמים השייכים למרחב הבעיה (`problem space`): מייצגים ישויות מעולם הבעיה, כגון עובד, שעון נוכחות, פריט במלאי, פטיש בחנות, מספר מרוכב $e+2i$, כלי רכב נושא לוחית זיהוי 19-070-35, או רשימה ממרחב הבעיה (כגון רשימת קניות או רשימת נוכחות תלמידים).
  2. עצמים השייכים למרחב התכנית / הפתרון (`program / solution space`): מייצגים מבני עזר תכנותיים, כגון קובץ, או רשימה ממרחב הפתרון (כגון רשימת בלוקים פנויים במנהל זיכרון או שרשרת גיבוב). שימו לב כי רשימה כגון (13, "hello", true) יכולה להשתייך הן למרחב הבעיה והן למרחב הפתרון בהתאם להקשר השימוש בה.

3.4 האם בשפת C אפשר להגדיר עצמים? (סעיפים 3.4.1–3.4.3)

3.5 ★ זהות עצמית, בדיקת שוויון וסוגי העתקה

• שם מול זהות והמזהה השמור לעצם הנוכחי: שם העצם נבדל מזהותו (ייתכנו שני עצמים בעלי אותו שם, עצם בעל כמה שמות, או עצם ללא שם כלל, אך לא ייתכנו שני עצמים בעלי אותה זהות). המזהה השמור לעצם הנוכחי: ב-C++ וב-Java: this | ב-Eiffel: Current | ב-Smalltalk: self.
• שני סוגי השוואה: (1) השוואת הזהות: שני שמות שווים אמ"ם הזהות זהה (מצביעים לאותו עצם ממש). (2) השוואה מבנית: שני שמות שווים אמ"ם לשני העצמים יש מבנה זהה ומצב זהה.

3.6 מאפיינים סטטיים ודינמיים של עצמים (סעיפים 3.6.1–3.6.2)

4.1–4.4 קובצי סביבת Squeak, 3 כפתורי העכבר ותפריט העולם

4.5–4.10 כלי העבודה ב-Squeak, חיפוש מחלקות/מתודות והמתודה shout

• חלון עבודה (`Workspace`) מול חלון הודעות (`Transcript` – קיצור `Ctrl+t`): Transcript show: 'hello world'; cr. מדפיס ל-Transcript ויורד שורה (בזכות ה-Cascade ;).
• 4 פקודות הביצוע והבחינה ב-Workspace:
  1. do it (Ctrl+d): מבצע את הביטוי המסומן (למשל 3 + 4 מחשב 7 אך לא מציג דבר).
  2. print it (Ctrl+p): מבצע את הביטוי, שולח לעצם המוחזר את ההודעה printString ומציג את הייצוג הטקסטואלי שלו (למשל Time now).
  3. inspect it (Ctrl+i): פותח Inspector – חלונית שמאל מציגה את self ואת משתני המופע, חלונית ימין מציגה את הערך הנבחר, והחלונית התחתונה משמשת כ-Workspace שבו self קשור לעצם הנבחן (למשל self squared על 7 יחזיר 49).
  4. explore it (Ctrl+Shift+i / Shift+Alt+i): פותח Explorer המציג את העצם במבנה עץ היררכי (ניתן לעבור מ-Explorer ל-Inspector ולהיפך דרך הכפתור בחלק הימני התחתון).
• טעינת חבילות עם `SqueakMap` ודפדפן המערכת `System Browser`:
  • SqueakMap: כלי לטעינת חבילות תוכנה מרשת האינטרנט.
  • 4 חלוניות ה-System Browser (משמאל לימין): (1) קטגוריות (Categories) $\to$ (2) מחלקות (Classes) $\to$ (3) פרוטוקולים (Protocols, או --all--) $\to$ (4) מתודות (Methods). לחיצה על כפתור ? במרכז מציגה את תיעוד המחלקה.
  • 4 דרכים לחיפוש מחלקה: (1) ניווט בחלונית הקטגוריות, (2) שליחת ההודעה Boolean browse (או סימון שם המחלקה ו-Ctrl+b), (3) פתיחת Hierarchy Browser (כפתור hierarchy), (4) find class... (f) בתפריט ההקשר של חלונית הקטגוריות.
  • חיפוש מתודות ב-Method Finder: לפי שם/חלק משם (למשל time) או לפי דוגמת מקבל, ארגומנטים ותוצאה מופרדים בנקודה: 4. 16 $\implies$ 4 squared --> 16.

// הגדרת המתודה shout במחלקה String (פרוטוקול converting):
shout
    "Answer a String converted to Uppercase followed by an exclamation mark."
    ^ self asUppercase, '!'
// משולש צהוב בפינה הימנית-עליונה של חלונית העריכה מציין שינויים שטרם נשמרו -> שומרים עם accept (Ctrl+s).
// הרצה ב-Workspace עם print it:  'hello' shout  -->  'HELLO!'

5.1–5.7 ★ הרצת תכנית ראשונה: המשחק Quinto, דיבוג הבאג וייצוא fileOut

המשחק Quinto מתנהל על לוח משובץ ($10 \times 10$): לחיצה על כל משבצת הופכת את מצבן (צהוב חיוור $\leftrightarrow$ כחול כהה) של 4 המשבצות השכנות הצמודות אליה (מעליה, מתחתיה, מימינה ומשמאלה – ללא אלכסונים וללא המשבצת שנלחצה עצמה!). התכנית בקטגוריה SBE-Quinto מורכבת משתי מחלקות:

SBECell >> initialize
    super initialize.
    self label: ''.
    self borderWidth: 2.
    bounds := 0@0 corner: 16@16.
    offColor := Color paleYellow.
    onColor := Color paleBlue darker darker.
    self useSquareCorners.
    self turnOff

SBECell >> mouseAction: aBlock   "פרוטוקול accessing"
    ^ mouseAction := aBlock

SBECell >> mouseUp: anEvent      "פרוטוקול event handling"
    mouseAction value

SBEGame >> initialize
    | sampleCell width height n |
    super initialize.
    n := self cellsPerSide.
    sampleCell := SBECell new.
    width := sampleCell width. height := sampleCell height.
    self bounds: (5@5 extent: ((width*n)@(height*n)) + (2 * self borderWidth)).
    cells := Matrix new: n tabulate: [:i :j | self newCellAt: i at: j]

SBEGame >> newCellAt: i at: j
    | c origin |
    c := SBECell new.
    origin := self innerBounds origin.
    self addMorph: c.
    c position: ((i-1) * c width) @ ((j-1) * c height) + origin.
    c mouseAction: [self toggleNeighboursOfCellAt: i at: j].
    ^ c   "חובה! בלעדיו מוחזר self שהוא SBEGame!"

6.1–6.2 ליטרלים, מערכים סטטיים/דינמיים, 6 פסאודו-משתנים ופרימיטיבים

6.3–7.6 ★ 3 סוגי ההודעות, כללי קדימות, מבנה מתודה ושרשור Cascade

LinkedList >> add: link after: otherLink
    | savedLink |
    lastLink == otherLink ifTrue: [^ self addLast: link].
    savedLink := otherLink nextLink.
    otherLink nextLink: link.
    link nextLink: savedLink.
    ^ link

6.5–6.6 בלוקים, תנאים, מימוש הלולאות ואיטרטורים

• בלוקים (`BlockContext`): פונקציות אנונימיות [ :x :y | | n | ... ]. מוערכים ע"י value, value:, value:value: (עד 4 פרמטרים), או valueWithArguments: anArray (למעל 4 פרמטרים). בלוקים יכולים לגשת למשתנים שהוגדרו מחוץ לבלוק, ופקודת החזרה ^ בתוך בלוק גורמת ליציאה מיידית מן המתודה שבה נכתב הבלוק.
• מימוש מבני בקרה, תנאים ולולאות ב-Smalltalk:

  // 1. מימוש תנאים במחלקות True ו-False:
  True >> ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock
      ^ trueAlternativeBlock value
  False >> ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock
      ^ falseAlternativeBlock value
  
  // 2. מימוש רקורסיבי של לולאת whileTrue: במחלקה BlockContext:
  BlockContext >> whileTrue: aBlock
      ^ [self value] whileTrue: [aBlock value]
  
  // 3. מימוש timesRepeat: ב-Integer ו-to:do: ב-Number באמצעות whileTrue:
  Integer >> timesRepeat: aBlock
      | count |
      count := 1.
      [count <= self] whileTrue: [aBlock value. count := count + 1]
  
  Number >> to: stop do: aBlock
      | nextValue |
      nextValue := self.
      [nextValue <= stop] whileTrue: [aBlock value: nextValue. nextValue := nextValue + 1]

• הבחנה בין 1 to: 10 do: [...] לבין (1 to: 10) do: [...]: ללא הסוגריים נשלחת למספר 1 ההודעה to:do:; עם הסוגריים נוצר תחילה עצם מסוג Interval ואליו נשלחת ההודעה do: (תוצאת הביצוע זהה: 55). וב-Interval>>collect: aBlock נעשה שימוש ב-result := self species new: self size כאשר Interval>>species מחזירה את המחלקה Array!

8.1–8.3 ★ מודל העצמים, 3 סוגי עצמים ב-Squeak, כימוס, מתודות מחלקה ו-Dog/Hyena

• סיווג העצמים ב-Squeak לשלושה סוגים לפי ייצוגם בזיכרון:
  1. עצמים רגילים עם משתני מופע: מועברים באמצעות מצביע (`reference`).
  2. שלמים מסוג SmallInteger: מועברים על פי ערך (`by value`) ונשמרים ישירות בתוך המצביע עצמו (Immediate Value) במקום כעצם נפרד בזיכרון.
  3. עצמים מאונדקסים (`Indexed Objects`): כגון מערכים (`Array`), המתייחסים לרצף זיכרון המכיל אוסף של עצמים.
• גבולות הכימוס (Encapsulation) ב-Smalltalk מול Java ו-C++:
  • ב-Java ו-C++ גבולות הכימוס מוגדרים בתחום המחלקה (מופע אחד יכול לגשת ישירות למשתנים הפרטיים של מופע אחר מאותה מחלקה).
  • ב-Smalltalk גבולות הכימוס מוגדרים בתחום המופע: משתני המופע נגישים ישירות רק למופע עצמו (ולמתודות בתתי-מחלקות, בדומה ל-protected ב-Java), אך לא למופע אחר מאותה מחלקה!
  • דוגמת יישום (`Rectangle>>containsRect: aRect`): הביטוי ^ aRect origin >= origin and: [aRect corner <= corner] ניגש ישירות למשתני המופע origin ו-corner של המקבל (self), אך חייב לקרוא למתודות הגישה aRect origin ו-aRect corner עבור הארגומנט! היתרון: ניתן להעביר ל-containsRect: מלבן ממימוש אחר לגמרי (שמיוצג ע"י נקודה, רוחב וגובה) כל עוד הוא מספק מתודות גישה origin ו-corner!
  • מתודות ב-Smalltalk: כולן ציבוריות (`public`). שיוך לפרוטוקול private או הוספת קידומת pvt לשם המתודה הם מוסכמה בלבד ואינם חוסמים גישה מחוץ למחלקה.

8.3–8.4 ★ דפוס Singleton, מחלקות מופשטות ו-Traits

WebServer class >> uniqueInstance
    uniqueInstance ifNil: [uniqueInstance := self new].
    ^ uniqueInstance

Trait named: #TAuthor uses: {} category: 'SBE-Quinto'
TAuthor >> author  ^ 'on'
// שילוב במחלקה עם מילת המפתח uses:
BorderedMorph subclass: #SBEGame
    uses: TAuthor instanceVariableNames: 'cells' ...

8.5–8.7 ★ איתור מתודות, הגדרה מחדש מול הרחבה, self מול super ומשתנים משותפים

• הגדרה מחדש (Overriding) מול הרחבה (Extension):
  • הגדרה מחדש (Overriding): EllipseMorph>>defaultColor ^ Color yellow דורסת לחלוטין את Morph>>defaultColor ^ Color blue.
  • הרחבה (Extension): BorderedMorph>>initialize מרחיבה את מתודת האב ע"י קריאה ל-super initialize ואחריה אתחול משתני המופע שלה.

• 3 סוגי המשתנים המשותפים ב-Smalltalk:
  1. משתנים גלובליים (`Global Variables`): מוגדרים במרחב השמות Smalltalk (מופע של SystemDictionary), כגון: Transcript (מופע של TranscriptStream), Smalltalk, Sensor (מופע של EventSensor), World (מופע של PasteUpMorph), ActiveHand (מופע של HandMorph), Undeclared (מופע של SystemDictionary) ו-SystemOrganization (מופע של SystemOrganizer). הוספת גלובלי חדש: השמה ב-Workspace או Smalltalk at: #Name put: obj (והסרה ב-Smalltalk removeKey: #Name).
  2. משתני מחלקה (`Class Variables`): מוגדרים ב-classVariableNames: (למשל ב-Character: 'CharacterTable ClassificationTable...'), משותפים לעצם המחלקה, לכל מופעיה ולכל תתי-המחלקות שלה, ונגישים ממתודות מופע וממתודות מחלקה. מאותחלים ב-ClassName class>>initialize (יש להפעילה מפורשות כי היא מופעלת אוטומטית רק כשהמחלקה נטענת לראשונה לזיכרון!) או באתחול עצל במתודת גישה (שמונע גישה ישירה ומוסיף תקורה).
  3. מאגרים משותפים (`Pool Dictionaries`): מילוני משתנים המשותפים לקבוצת מחלקות שאינן קשורות בהיררכיית ירושה (כיום מומלץ להגדירם כתת-מחלקות של SharedPool ולציינם תחת poolDictionaries:).

9.1–9.10 ★ כלי הפיתוח ב-Squeak, Monticello ודיבוג המתודה suffix ב-Debugger

• כפתורי ה-System Browser ו-5 צבעי כפתור inheritance: browse (Ctrl+b) (ובחלונית הקטגוריות מציג back... למחלקות שהוצגו לאחרונה), senders, implementors, versions, hierarchy, vars, source, וכפתור inheritance שצבעו מציין: ורוד = דריסה ללא קריאה ל-super; ירוק = דריסה תוך שימוש ב-super; זהב = מוגדרת מחדש בתת-מחלקה; כתום = ורוד + זהב; סגול = ירוק + זהב.
  • הפעלה תכנותית דרך SystemNavigation default: SystemNavigation default browseClass: EllipseMorph, browseHierarchy: EllipseMorph, ו-browseAllCallsOn: #drawOn:.
• ניהול מארזים ב-Monticello: מארז SqueakLink כולל: (1) את כל המחלקות בקטגוריה SqueakLink ובקטגוריות המתחילות ב-SqueakLink- (למעט מתודות בפרוטוקולים המתחילים ב-*), ו-(2) כל מתודה בכל מחלקה אחרת (כגון Object>>asSQL) שנמצאת בפרוטוקול ששמו *squeaklink או מתחיל ב-*squeaklink-! כתוצאה מכלל זה (הממומש במחלקה PackageInfo), כל מחלקה וכל מתודה שייכת למארז אחד בלבד. גיבוי מקומי של קובצי .mcz נשמר בתיקייה package-cache.
• Inspector מול Explorer: ב-Inspector הפריט השני הוא all inst vars ו-self קשור תמיד לעצם הראשי; ב-Explorer המשתנה self בחלונית התחתונה מתקשר דינמית לאיבר/המשתנה הספציפי שנבחר כרגע בעץ!
• כלי סביבה נוספים: Process Browser (תהליכים רצים), Message Names (חיפוש מתודות ללא פתיחת חלון חדש), Change Set Browser (simple change sorter) ו-Change Sorter (dual change sorter להעברת שינויים בין מקבצי שינויים), File List Browser, ושחזור קוד שהלך לאיבוד מתוך קובץ השינויים (.changes).

// הגרסה השגויה הראשונית שנכשלת בהרצת 'readme.txt' suffix (זורקת Error: Object is not in the collection):
String >> suffix
    | dot dotPosition |
    dot := FileDirectory dot.   "באג 1: מחזיר את המחרוזת '.' בעוד (self at: i) מחזיר תו $. (ו- $. = '.' הוא false!)"
    dotPosition := (self size to: 1 by: -1) detect: [:i | (self at: i) = dot]. "באג 3: קורס אם אין נקודה במחרוזת!"
    ^ self copyFrom: dotPosition to: self size   "באג 2: מחזיר '.txt' כולל הנקודה במקום 'txt'!"

// הגרסה המתוקנת והמלאה לאחר 3 התיקונים ב-Debugger:
String >> suffix
    | dot dotPosition |
    dot := FileDirectory dot asCharacter.   "תיקון 1: המרה לתו $. "
    dotPosition := (self size to: 1 by: -1) detect: [:i | (self at: i) = dot] ifNone: [self size]. "תיקון 3"
    ^ self copyFrom: (dotPosition + 1) to: self size   "תיקון 2: יחזיר 'txt', ואם אין נקודה יחזיר מחרוזת ריקה ''"

10.1–10.6 המושג "מחלקה" (Class): 3 תפקידים, 5 מרכיבים ובבואה (Reflection)

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

11.1 המחלקה Object (הדפסה, שוויון ו-hash, שייכות, העתקה וניפוי שגיאות)

בראש היררכיית המחלקות ב-Squeak נמצאת ProtoObject (המרכזת את ההגדרות המינימליות ביותר), ומתחתיה Object. ל-Object אין משתני מופע ואסור להוסיף לה כאלה, כדי לא לשנות את מבנה הזיכרון של מחלקות שה-VM מסתמכת על מבנן (כגון SmallInteger).

Point >> printOn: aStream
    x printOn: aStream.
    aStream nextPut: $@.
    (y isNumber and: [y negative]) ifTrue: [aStream space].   "שורות 3-4"
    y printOn: aStream

11.2–11.5 מספרים, תווים, מחרוזות, Symbol ובוליאניים

12.1–12.4 ★ אוספים ב-Squeak: היררכיית Collection, 8 סיווגי יכולות ו-5 דרכי מימוש

• 7 הפרוטוקולים המשותפים ב-`Collection`: (1) גישה: size, capacity, at:, at:put: | (2) בדיקה: isEmpty, includes:, contains:, occurrencesOf: | (3) הוספה: add:, addAll: | (4) הסרה: remove:, remove:ifAbsent:, removeAll: | (5) אנומרציה: do:, collect:, select:, reject:, detect:, detect:ifNone:, inject:into:, count:, anySatisfy: | (6) הסבה: asBag, asSet, asOrderedCollection, asSortedCollection, asSortedCollection:, asArray | (7) יצירה (מתודות מחלקה): new, new:, with:, with:with: (עד 4 איברים), withAll:.
• 5 קטגוריות המימוש של אוספים: (1) מימושי מערך (Array – מאחסן איברים במשתנה מופע מאונדקס של האוסף ולכן גודלו קבוע), (2) מימושים סדורים (OrderedCollection, SortedCollection – מאחסנים איברים במערך פנימי השמור באחד ממשתני המופע של האוסף, כך שניתן להקצות מערך גדול יותר לפי הצורך!), (3) מימושי Hash (Set, Dictionary – משתמשים במערך כטבלת גיבוב; ו-Bag שמשתמש בפנים ב-Dictionary שבו האלמנטים הם המפתחות ומספר המופעים הוא הערכים!), (4) מימושים מקושרים (LinkedList – רשימה מקושרת סטנדרטית), (5) מימושי אינטרוול (Interval – ממומש באמצעות 3 שלמים בלבד: start, stop, step).

12.5–12.6 ★ מימוש כל האיטרטורים במחלקה Collection ו-4 כללי הזהב

// מימוש איטרטורים מרכזיים באוספים (do:, collect:, select:, reject:, detect:, inject:into:):
SequenceableCollection >> do: aBlock
    1 to: self size do: [:index | aBlock value: (self at: index)]
// גרסאות נוספות של do: -> doWithout:, withIndexDo:, reverseDo:, ובמילון: keysDo:, valuesDo:, associationsDo: (במילון do: סורקת את הערכים values!)

Collection >> collect: aBlock
    | newCollection |
    newCollection := self species new.
    self do: [:each | newCollection add: (aBlock value: each)].
    ^ newCollection
// זהירות: collect: על String תחזיר String ולכן הבלוק חייב להחזיר תווים (Character), אחרת תיזרק שגיאה!

Collection >> select: aBlock
    | newCollection |
    newCollection := self species new.
    self do: [:each | (aBlock value: each) ifTrue: [newCollection add: each]].
    ^ newCollection

Collection >> reject: aBlock
    ^ self select: [:element | (aBlock value: element) == false]

Collection >> detect: aBlock
    ^ self detect: aBlock ifNone: [self errorNotFound: aBlock]

Collection >> detect: aBlock ifNone: exceptionBlock
    self do: [:each | (aBlock value: each) ifTrue: [^ each]].
    ^ exceptionBlock value

Collection >> inject: thisValue into: binaryBlock
    | nextValue |
    nextValue := thisValue.
    self do: [:each | nextValue := binaryBlock value: nextValue value: each].
    ^ nextValue
// הודעות איטרציה נוספות: count: [:each | ...] ו-anySatisfy: [:each | ...]

13–14.4 ★ רקע, ייצוג פרמוטציה ו-4 אופני הייצוג של חידת N המלכות

• הגדרת בעיית 8 המלכות ועקרונות הסימולציה:
  • הגדרת חידת 8 המלכות: הצב 8 מלכות על לוח שחמט כך שאף מלכה אינה מאיימת על אף מלכה אחרת (אין שתי מלכות באותה שורה, באותה עמודה או באותו אלכסון).
  • רקע היסטורי: הוצגה ב-1848 ע"י שחקן השחמט מקס בזל (Max Bezzel), ונחקרה ע"י גאוס (C.F. Gauss, 1865), פוליה (G. Polya, 1918) ולוקאס (E. Lucas, 1960). במדעי המחשב היא דוגמה קלאסית לאלגוריתמי Backtracking ולסימולציה בעזרת עצמים (הגישה שהולידה את שפת Simula).
  • ייצוג פתרון כפרמוטציה: מכיוון שבכל עמודה ובכל שורה יש בדיוק מלכה אחת, ניתן לייצג פתרון כפרמוטציה מעל $\{0, 1, 2, 3, 4, 5, 6, 7\}$, למשל הפתרון החוקי: $$\begin{pmatrix} 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 \\ 7 & 3 & 0 & 2 & 5 & 1 & 6 & 4 \end{pmatrix}$$

14.5–14.6 ★ 8 סימטריות הלוח ופתרונות זרים ממש

• 8 סיבובי הסימטריה היוצרים פתרונות שקולים איזומורפית:
  • 4 סיבובים דו-ממדיים נגד כיוון השעון: ב-$90^\circ$, ב-$180^\circ$, ב-$270^\circ$, וב-$360^\circ$ (זהות עצמית).
  • 4 סיבובים תלת-ממדיים של $180^\circ$ במרחב (שיקופים): סביב הציר האופקי, סביב הציר האנכי, סביב הציר האלכסוני ($i \ne j$), וסביב הציר האלכסוני הנגדי ($i = j$).

* מספר הפתרונות הזרים ממש: עבור $N = 1, 2, 3, 4, 5, 6, 7, 8$ מספר הפתרונות הזרים ממש (שאינם שקולים איזומורפית תחת 8 הסימטריות) הוא 1, 0, 0, 1, 2, 1, 6, 12 בהתאמה.

15.1 ★ פתרון מונחה עצמים לחידת 8 המלכות: המחלקה Board ושרשרת המלכות

בפתרון מונחה העצמים (פרק 15), לכל מלכה מוקצית עמודה כנחלתה הבלעדית בלוח, והמלכות דנות ביניהן באמצעות שליחת הודעות רק לגבי השורה (row) שכל אחת תתפוס. המחלקה Board מחזיקה משתנה מופע יחיד בלבד (lastQueen) המצביע לראש רשימה מקושרת של 8 מלכות שבסופה מלכה מנוונת (QueenTerminator):

// הגדרת המחלקה Board, אתחול שרשרת המלכות והמתודה solve:
Object subclass: #Board
    instanceVariableNames: 'lastQueen'
    classVariableNames: '' poolDictionaries: '' category: 'OOD-8Queens'

Board >> initialize
    lastQueen := QueenTerminator new.
    (1 to: 8) do: [:i |
        lastQueen := Queen new setColumn: i neighbor: lastQueen]

Board >> solve
    Transcript clear.
    lastQueen firstSolution
        ifTrue: [
            Transcript show: lastQueen result printString; cr.
            [lastQueen nextSolution] whileTrue: [
                Transcript show: lastQueen result printString; cr].
            Transcript show: 'End of Solutions.'; cr]
        ifFalse: [
            Transcript show: 'No Solution.'; cr]

// הרצה ופלט:
// board := Board new initialize. board solve
// OrderedCollection (1 5 8 6 3 7 2 4) ... (92 פתרונות)

15.2–15.4 ★ המחלקה Queen: שלושת משתני המופע ו-7 מתודות הפרוטוקול

למחלקה Queen יש 3 משתני מופע: row (השורה הנוכחית 1..8), column (מספר העמודה הקבוע 1..8), ו-neighbor (המצביע הקבוע למלכה השכנה משמאל).

Object subclass: #Queen
    instanceVariableNames: 'row column neighbor'
    classVariableNames: '' poolDictionaries: '' category: 'OOD-8Queens'

// --- 15.3 ארבע מתודות הפרוטוקול החיצוני ---
Queen >> setColumn: aColumn neighbor: aQueen
    column := aColumn.
    neighbor := aQueen

Queen >> firstSolution
    neighbor firstSolution.
    row := 1.
    ^ self moveToNextNonAttackedRow

Queen >> nextSolution
    ^ self advance and: [self moveToNextNonAttackedRow]

Queen >> result
    "add row to the list"
    ^ neighbor result addLast: row; yourself

// --- 15.4 שלוש מתודות התקשורת הפנימית ("פרטיות") בין המלכות ---
Queen >> advance
    row = 8
        ifTrue: [
            neighbor nextSolution ifFalse: [^ false].
            row := 0].
    row := row + 1.
    ^ true

Queen >> moveToNextNonAttackedRow
    [neighbor canAttack: row x: column]
        whileTrue: [self advance ifFalse: [^ false]].
    ^ true

Queen >> canAttack: testRow x: testColumn
    | columnDifference |
    columnDifference := testColumn - column.
    ((row = testRow
        or: [row + columnDifference = testRow])
        or: [row - columnDifference = testRow])
            ifTrue: [^ true].
    ^ neighbor canAttack: testRow x: testColumn

15.5 ★ הגדרת מלכה מנוונת: המחלקה QueenTerminator (תבנית Null Object)

במקום לסרבל את המימוש בתנאי עצירה (בדיקות neighbor isNil), מגדירים את QueenTerminator המשמשת כשכנה של המלכה הראשונה (בעמודה 1) ובעלת אותו פרוטוקול:

Object subclass: #QueenTerminator
    instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'OOD-8Queens'

QueenTerminator >> canAttack: testRow x: testColumn
    ^ false                        "תמיד מחזיר false (אינה מאיימת על אף משבצת)"

QueenTerminator >> firstSolution
    ^ true                         "תמיד מחזיר true"

QueenTerminator >> nextSolution
    ^ false                        "תמיד מחזיר false (עוצר את החיפוש כשמלכה 1 מיצתה את שורה 8)"

QueenTerminator >> result
    ^ OrderedCollection new        "מחזיר רשימה ריקה חדשה"
// המתודות setColumn:neighbour:, advance ו-moveToNextNonAttackedRow אינן בשימוש במלכה המנוונת!

16.1–16.2 ★ הכללה ללוח N×N (מלכודת משתנה המחלקה N!) וללוח תלת-ממדי N×N×N

הכללה ל-$N$ מלכות על לוח $N \times N$: הצב $N$ מלכות על לוח שחמט $N \times N$ כך שאף מלכה אינה מאיימת על מלכה אחרת. בפתרון מונחה העצמים הקבוע 8 מופיע ב-2 מקומות בלבד: בלולאת 1 to: 8 ב-Board>>initialize ובבדיקה row = 8 ב-Queen>>advance.

board1 := Board new.
board2 := Board new.
board1 initialize: 5.   "קובע N := 5 ויוצר ב-board1 שרשרת של 5 מלכות"
board2 initialize: 1.   "דורס את משתנה המחלקה המשותף וקובע N := 1!"
board1 solve.           "ידפיס: No Solution. !"

dx := (row - i) abs.
dy := (col - j) abs.
dz := (lev - k) abs.
((dx = 0) and: [ dy = 0 ]) ifTrue: [ ^ true ].   "1. איום לאורך ציר המפלסים (אותה שורה ואותה עמודה)"
((dx = 0) and: [ dy = dz ]) ifTrue: [ ^ true ].  "2. איום אלכסוני במישור המקביל לצירים y-z (אותה שורה)"
((dx = dz) and: [ dy = 0 ]) ifTrue: [ ^ true ].  "3. איום אלכסוני במישור המקביל לצירים x-z (אותה עמודה)"
((dx = dy) and: [ dx = dz ]) ifTrue: [ ^ true ]  "4. איום באלכסון מרחבי תלת-ממדי או במישור x-y (כאשר dz=0)"

17.1–17.3 הסביבה הגרפית Morphic: ישירות, חיות, מערכת הצירים והרכבת צורות

• שני עקרונות היסוד של סביבת Morphic:
  1. ישירוּת (`directness`): הצורות על המסך הן עצמים שאפשר לבחון ולשנותם בצורה ישירה. הדגמת ניתוק פריט מתפריט העולם: לוחצים בכפתור הכחול (האמצעי) מעל תפריט העולם לקבלת ה-morphic halo של התפריט $\to$ לוחצים שוב בכפתור הכחול מעל אחד מפריטי התפריט להקפתו ב-Halo משלו $\to$ גוררים אותו החוצה באמצעות צלמית ה-pickup (באמצע השורה העליונה), והפריט מתפקד ככפתור עצמאי!
  2. חיוּת (`liveness`): הסביבה מגיבה אל המשתמש והמידע על המסך מתעדכן בהתאם בזמן אמת.
• הפיכת עצמים וצבעים ל-Morph וחלון ה-Viewer:
  • s := 'Hello' asMorph openInWorld. s openViewerForArgument. פותח בצד ימין את חלון ה-Viewer המאפשר להזיז ולסובב את העצם בלחיצה על סימני הקריאה ! (ולגרום לו "לצחוק" באמצעות שליחת הפקודה הקולית ב-Viewer!).
  • Color>>asMorph ממומשת עם Cascade ו-yourself: ^ (RectangleMorph new) fillStyle: self; borderWidth: 0; yourself.
• מערכת הצירים, מתודות בסיסיות ובניית צורות מורכבות: ראשית הצירים (0@0) נמצאת בפינה השמאלית העליונה של המסך; ציר x מתקדם ימינה וציר y מתקדם כלפי מטה. מתודות: position / position: (פינה שמאלית-עליונה של המלבן החוסם), extent / extent: (רוחב@גובה), color:.

  // יצירת צורה צהובה וצורה ירוקה מסוג Morph:
  mYellow := Morph new color: Color yellow; openInWorld.
  mGreen := Morph new color: Color green; openInWorld.
  10 timesRepeat: [mYellow position: mYellow position + (10@0)].    "הזזה ימינה 10 פיקסלים 10 פעמים"
  10 timesRepeat: [mGreen position: mGreen position + (10@10)].     "הזזה באלכסון למטה וימינה 10 פעמים"
  mGreen extent: mYellow extent.                                    "השוואת גודל הירוקה לצהובה"
  mYellow color: Color blue.                                        "שינוי צבע הצהובה לכחול"

• הרכבת צורות (`Composition`):
  • בקוד: rect addMorph: star מכניסה את הכוכב לתוך המלבן; הזזת המלבן (rect position: ...) מזיזה את שניהם יחדיו, והזזת הכוכב ישירות מזיזה אותו ביחס למלבן אך הוא ממשיך לזוז עם המלבן! star center: rect center ממרכזת אותו (בפרוטוקול geometry), ו-rect removeMorph: star מנתקת אותו (נעלם מהמסך אך קיים בזיכרון ומוצג שוב עם star openInWorld).
  • בממשק החזותי: מתפריט העולם objects (o) → Graphics גוררים שתי צורות, מניחים זו על זו, לוחצים בכפתור הצהוב (ימני) על העליונה ובוחרים embed into. לניתוק: שתי לחיצות בכפתור הכחול (הראשונה מעלה Halo למכילה, השנייה למוכלת) וגרירתה החוצה.

17.4 ★ יצירת צורות גרפיות: CrossMorph, drawOn:, containsPoint: ושני השכתובים

כדי ליצור את המחלקה CrossMorph (היורשת מ-Morph), משכתבים את drawOn: aCanvas (הנעזרת ב-self bounds insetBy: להסטת פינות המלבן החוסם פנימה) ואת containsPoint: aPoint (כדי שרק נקודות על הצלב עצמו יגיבו לעכבר ולא 4 הפינות הריקות של המלבן החוסם):

CrossMorph >> drawOn: aCanvas
    | crossHeight crossWidth horizontalBar verticalBar |
    crossHeight := self height / 3.0.
    crossWidth := self width / 3.0.
    horizontalBar := self bounds insetBy: 0 @ crossHeight.
    verticalBar := self bounds insetBy: crossWidth @ 0.
    aCanvas fillRectangle: horizontalBar color: self color.
    aCanvas fillRectangle: verticalBar color: self color

CrossMorph >> containsPoint: aPoint
    | crossHeight crossWidth horizontalBar verticalBar |
    crossHeight := self height / 3.0.
    crossWidth := self width / 3.0.
    horizontalBar := self bounds insetBy: 0 @ crossHeight.
    verticalBar := self bounds insetBy: crossWidth @ 0.
    ^ (horizontalBar containsPoint: aPoint) or: [verticalBar containsPoint: aPoint]

שני עקרונות תכנון וארגון קוד ב-CrossMorph: (1) ריכוז חישובי horizontalBar ו-verticalBar במתודות עזר פרטיות למניעת כפילות הקוד בין drawOn: ל-containsPoint:; (2) פיצול המלבן האנכי לחלק עליון וחלק תחתון (מעל ומתחת ל-horizontalBar) כך שהריבוע המרכזי המשותף יצויר פעם אחת בלבד (חשוב במיוחד כשמציירים בצבע שקוף למחצה!).

17.5 ★ אירועי עכבר (2 שלבים), מקלדת (3 שלבים) ואנימציית Stepping

// תגובה ללחיצה (הקטנה בלחיצה על הכפתור הצהוב):
CrossMorph >> mouseDown: anEvent
    anEvent redButtonPressed
        ifTrue: [self extent: (self extent * 1.1)].
    anEvent yellowButtonPressed
        ifTrue: [self extent: (self extent * 0.9)].
    self changed   "חובה כדי לתזמן קריאה ל-drawOn:!"

// תגובה לתנועת סמן (אדום בכניסת עכבר, ירוק ביציאה):
CrossMorph >> handlesMouseOver: anEvent  ^ true
CrossMorph >> mouseEnter: anEvent  self color: Color red
CrossMorph >> mouseLeave: anEvent  self color: Color green

17.6–17.10 ★ דו-שיח, Drag & Drop, DieMorph ו-Canvas/fork

• תיבת דו-שיח (`FillInTheBlank`) ותפריט קופץ (`PopUpMenu`):
  • FillInTheBlank request: 'enter your name:' initialAnswer: '??????' $\implies$ מחזירה את המחרוזת שהוקלדה (או '??????' אם אושר ללא שינוי, או '' ב-Cancel).
  • menu := PopUpMenu labelArray: #('x' 'y' 'z') lines: #(1 2 3). menu startUpWithCaption: 'Choose an item' $\implies$ lines: מציין אחרי אילו אינדקסים יופיע קו מפריד, ו-startUpWithCaption: מחזירה את אינדקס הפריט שנבחר (1..3, או 0 אם לא נבחר דבר).
• גרירה והשמטה (`Drag and Drop`) ומנגנון תיאום בין צורות:
  • במקבל (`ReceiverMorph`): wantsDroppedMorph: aMorph event: anEvent (האם לקבל את העצם הנגרר) ו-repelsMorph: aMorph event: ev (אם מחזירה true, עצם שנדחה חוזר למקומו המקורי במקום להישאר מונח בנקודת העזיבה!).
  • בנגרר (`DroppedMorph`): wantsToBeDroppedInto: aMorph ו-rejectDropMorphEvent: anEvent (מגדירה את התנהגות הנגרר במקרה של דחייה).

  // מנגנון Drag & Drop (ReceiverMorph מקבל רק צבע שונה משלו ומחזיר דחויים; DroppedMorph משנה צבע בדחייה):
  ReceiverMorph >> wantsDroppedMorph: aMorph event: anEvent
      ^ self color ~= aMorph color
  ReceiverMorph >> repelsMorph: aMorph event: ev
      ^ (self wantsDroppedMorph: aMorph event: ev) not
  DroppedMorph >> rejectDropMorphEvent: anEvent
      self color: Color random.   "משנה את צבעו כך שבגרירה הבאה יתקבל!"
      super rejectDropMorphEvent: anEvent

BorderedMorph subclass: #DieMorph
    instanceVariableNames: 'faces dieValue isStopped'
    classVariableNames: '' poolDictionaries: '' category: 'SBE-Morphic'

DieMorph class >> faces: aNumber  ^ self new faces: aNumber
DieMorph >> initialize
    super initialize. self extent: 50@50. self color: Color green.
    dieValue := 1. faces := 6. isStopped := false
DieMorph >> faces: aNumber
    (aNumber isInteger and: [aNumber > 0] and: [aNumber <= 9]) ifTrue: [faces := aNumber]
DieMorph >> face1  ^ {0.5@0.5}
DieMorph >> face2  ^ {0.25@0.25 . 0.75@0.75}
DieMorph >> face3  ^ {0.25@0.25 . 0.75@0.75 . 0.5@0.5}  "... עד face9 (קואורדינטות יחסיות 0..1)"
DieMorph >> drawOn: aCanvas
    super drawOn: aCanvas.
    (self perform: ('face', dieValue asString) asSymbol)
        do: [:aPoint | self drawDotOn: aCanvas at: aPoint]
DieMorph >> drawDotOn: aCanvas at: aPoint
    aCanvas fillOval: (Rectangle center: self position + (self extent * aPoint) extent: self extent / 6) color: Color black
DieMorph >> dieValue: aNumber
    (aNumber isInteger and: [aNumber > 0] and: [aNumber <= faces])
        ifTrue: [dieValue := aNumber. self changed]
DieMorph >> stepTime  ^ 100
DieMorph >> step      isStopped ifFalse: [self dieValue: (1 to: faces) atRandom]
DieMorph >> handlesMouseDown: anEvent  ^ true
DieMorph >> mouseDown: anEvent         anEvent redButtonPressed ifTrue: [isStopped := isStopped not]

18.1–18.7 ★ ייצוג מחלקה כעצם, שרשרת class, סיווג למטה-רמות ו-5 רמות עצמים

מכיוון שב-Smalltalk כל דבר הוא עצם וכל עצם הוא מופע של מחלקה, גם מחלקה היא עצם — והיא מופע של מטה-מחלקה (`Metaclass`): מחלקה שהמופעים שלה הם מחלקות!

18.8–18.11 ★ 10 חוקי המודל ב-Squeak, היררכיה מקבילה ואיתור blue ו-new

• הודעות תשאול למחלקה כעצם ובחינה ב-Inspector:
  • הודעות למחלקה: subclasses (מערך תתי-מחלקות), allSuperclasses (אוסף כל מחלקות-העל), instVarNames (מערך משתני המופע של המחלקה), allInstVarNames (מערך כל משתני המופע כולל אלו שנורשו ממחלקות-העל).
  • מעקב שרשרת superclass של מטה-מחלקה: מה מחזיר הביטוי TranslucentColor class superclass superclass? הוא מחזיר את Object class (המטה-מחלקה של Object).
  • שליחת מתודת מחלקה בירושה (TranslucentColor blue): כששולחים TranslucentColor blue, החיפוש מתחיל ב-TranslucentColor class, עולה ל-Color class, מוצא שם את blue ומחזיר צבע כחול אטום רגיל (Color blue). מה אפשר לעשות כדי ש-TranslucentColor blue תחזיר צבע כחול שקוף במקום כחול רגיל? להגדיר מחדש (Override) את המתודה blue במטה-מחלקה TranslucentColor class (למשל ^ super blue alpha: 0.5)!
  • כותרת חלון ה-Inspector: בכותרת ה-Inspector רשום תמיד שם המחלקה של העצם הנבחן (ולא שם העצם): כשבוחנים את Color blue הכותרת היא Color, וכשבוחנים את המחלקה Color הכותרת היא Color class!

18.12–18.15 ★ מחלקות הליבה (Behavior, ClassDescription, Class, Metaclass), נוסחאות ודבר סוף