החומר המופיע בעמוד זה פורסם לראשונה בכתב העת "הבטים בהוראת מדעי המחשב" גליון ינואר 2004, עמודים 39-44

לא ניתן לעשות שימוש מסחרי בחומר זה ללא רשות בכתב מן המחברים או מערכת כתב העת

מגירות סודיות: שיטה מבוססת תבניות

לפתרון בעיות הקשורות לטיפוסי נתונים מופשטים

ד"ר ברוריה הברמן
הוראת המדעים, מכון ויצמן למדע

nthaber@wisemail.weizmann.ac.il   

 

המאמר מתבסס על

Haberman, B. (2002). Frames and boxes: a pattern-based method for manipulating binary trees. Inroads SIGCSE Bulletin, 34(4), 60-64.

 

תקציר

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

 

מבוא

תכנית הלימודים החדשה במדעי המחשב שהטמעתה החלה לפני קצת למעלה מעשור, מדגישה עקרונות ומושגים שאינם תלויי מימוש, בצד יישום פרקטי שלהם בשפות תכנות קונקרטיות ובפרדיגמות תכנות שונות [5,6]. יחידת הלימוד עיצוב תכנה פותחת לתלמידים צוהר להיבטים שונים של פיתוח מערכת תכנה. אחת מהמטרות המרכזיות של היחידה היא פיתוח חשיבה מופשטת ופיתוח יכולות של פתרון בעיות דרך שימוש בטיפוסי נתונים מופשטים (טנ"מ). היחידה מציגה את ההיבטים התיאורטיים בבסיס עבודה עם טיפוסי נתונים מופשטים, ואת תפקידם ככלי בפתרון בעיות ופיתוח מערכות תכנה [3,5,6,7]. ביחידת הלימוד עיצוב תכנה המושג טיפוס נתונים מופשט מוצג בשלוש רמות: איפיון (specification), שימוש (usage) ומימוש (implementation) [3,4].

 

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

 

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

 

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

 

מוטיבציה לפיתוח כלים תומכים לפתרון בעיות בעזרת טנ"מ

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

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

 

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

 

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

 

שיטת "המגירות הסודיות"

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

 

מיון של בעיות

תבניות תיכון (design patterns) משמשות לפיתוח תכנה [8] ויש המשלבים אותם בהוראת קורסים במדעי המחשב [2,9,10,12-15].Soloway  (1985) תיאר שיטה להוראת פתרון בעיות בתכנות פונקציונלי בסביבת LISP. הוא ביסס את השיטה על היחסים בין בעיה, תכנית מחשב, הפשטה מתווכת ו- plan (להלן תבנית) שהוא רעיון לפתרון המנוסח בצורה תבניתית. הוא פיתח טקסונומיה של בעיות – סכימת מיון אשר מקבצת קבוצות של בעיות דומות למחלקות  על פי קריטריונים והתאים להן הפשטות מתווכות ותבניות [15].

 

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

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

2. מחלקת חישוב ערך – מחלקה זו כוללת בעיות אשר פתרונן מתייחס לתוצאת חישוב ערך מייצג של עץ בינרי. מחלקה זו נחלקת לשתי תת מחלקות:

מונה – בעיות המתייחסות למספר המופעים של תכונה מסוימת בעץ. למשל, "כמה צמתים בעץ?"; "כמה צמתים הם בעלי בן יחיד?"; "כמה צמתים הינם בנים יחידים בעץ?"

ערך מייצג – בעיות המתייחסות לתכונה מסוימת של עץ הניתנת לייצוג על ידי ערך אחד. למשל, "גובה עץ"; "סכום ערכי הצמתים בעץ"; "ערך של ביטוי אלגברי המיוצג על ידי עץ בינרי"; "ערך האמת של ביטוי בוליאני המיוצג על ידי עץ בינרי".

3. מחלקת בדיקת קיום תכונה – מחלקה זו כוללת בעיות אשר פתרונן מתייחס לבדיקת קיום תכונה כללית של עץ בינרי או של צמתיו. מחלקה זו נחלקת לשלוש תת מחלקות. לעתים אפשר לשייך בעיה ליותר מתת מחלקה אחת.

בדיקת מבנה – בעיות המתייחסות לתכונה כללית הקשורה למבנה של עץ. למשל, "האם העץ שלם?"; "האם העץ מאוזן?"

בדיקת מאפיין צומת – בעיות המתייחסות לקיום מאפיין של צמתים בעץ. למשל, "האם לכל הצמתים יש ערך זוגי?";  "האם לכל הצמתים אתו ערך?";  "האם קיים לפחות צומת אחד שהוא בן יחיד?"

בדיקת יחס – בעיות המתייחסות לקיום יחס בין צמתי העץ. למשל, "האם העץ הוא עץ מיון?"; "האם כל צומת שווה בערכו לערך בנו השמאלי?"; "האם לכל הצמתים אתו ערך?"

הבעיות השייכות למחלקה זו ניתנות לסיווג אחר בדומה לסיווג המוצע על ידיSoloway  (1985) [15]:

בעיות מסוג“AND predicate”  ובעיות מסוג “OR predicate”. למשל, הבעיה "האם לכל הצמתים יש ערך זוגי?" היא מסוג “AND predicate” .

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

 

יצירת תבניות אבסטרקטיות תואמות

בסעיף זה מוצגות דוגמאות של תבניות אבסטרקטיות המתאימות לבעיות ממחלקות (1), (2), ו- (3).  התבנית הבאה - Pattern A נגזרת מאלגוריתם רקורסיבי של סריקה תחילית, והיא מתאימה לפתרון בעיות ממחלקת איחזור מידע (תבניות דומות ניתנות לגזירה בדומה מכל אלגוריתם סריקה כללי אחר). תבנית זו יכולה לשמש גם לפתרון בעיות ממחלקת עידכון הכרוכות בשינוי ערכי צמתים בעץ.

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

 

Pattern A

   Method_A(T)

   1. if not Is_Empty ? (T) then

   1.1  Perform_on_Current_Node (T)

   1.2  Method_A(Left_Sub_Tree (T) )

   1.3  Method_A (Right_Sub_Tree (T) )

 

התבניות  Pattern C, Pattern Bו- Pattern D מתאימות לפתרון בעיות ממחלקת חישוב ערך ובעיות מסוג  “AND/OR predicate” ממחלקת בדיקת קיום תכונה. שלושת התבניות מייצגות אותו סוג של חישוב, אך הן מנוסחות בצורה שונה. התבנית Pattern B מכילה סימון של אופרטור - op אשר ניתן להחליפו באופרטור אלגברי מתאים או באופרטור בוליאני מתאים. התבנית Pattern C כתובה בסגנון פונקציונלי ומייצגת את הרעיון שהפעולה Perform_on_Current_Node מתייחסת לשלושה פרמטרים: צומת תורן T והערכים המוחזרים של הפעלת Method_C על שני תתי העצים. לחילופין, התבנית Pattern D כתובה בסגנון פרוצדורלי. שלושת התבניות B, C, D מחזירות ערך אחד שהוא למעשה תוצאה של תהליך חישוב, בעוד שתבנית A מציגה כפלט מידע מאוחזר שעשוי להיות רשימת ערכים.  

 

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

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

 

Pattern B

   Method_B(T)

   1.  if not Is_Empty ? (T) then

        1.1 return

              Perform_on_Current_Node (T) op 

              Method_B(Left_Sub_Tree (T)) op 

              Method_B (Right_Sub_Tree (T))

   2.  else return an agreed value

Pattern C

   Method_C(T)

   1.  if not Is_Empty ? (T) then

        1.1  Perform_on_Current_Node (

               T,

               Method_C(Left_Sub_Tree (T)),

               Method_C(Right_Sub_Tree (T)) )

   2.  else return an agreed value

Pattern D

   Method_D(T)

   1. if not Is_Empty ? (T) then

      1.1 L <- Method_D(Left_Sub_Tree (T))

      1.2 R <- Method_D (Right_Sub_Tree (T))

      1.3 Perform_on_Current_Node (T, L, R))

   2.  else return an agreed value

 

ארגז כלים תומך פתרון בעיות

ממשק של טנ"מ עץ בינרי בצירוף האלגוריתמים המייצגים שיטות סריקה סטנדרטיות, ואוסף של תבניות אבסטרקטיות כדוגמת תבניות A, B, C, ו- D מהווים בסיס ליצירת ארגז כלים תומך לפתרון בעיות המתייחסות לעצים בינריים. ארגז הכלים כולל למעשה אוסף של תבניות ואוסף של פעולות שיכול לשמש לפיתוח תוכן של "מגירה סודית" המתאימה לפתרון בעיה קונקרטית. אוסף הפעולות בארגז הכלים מורכב מפעולות ממשק הנחשבות כפעולות בסיסיות וכן מפעולות נוספות מורכבות אשר מוגדרות באמצעות הפעולות הבסיסיות. 

למשל, הפעולהIs_Leaf ?(T)   הבודקת אם צומת T הוא עלה, ממומשת באופן הבא:

 

Is_Leaf? (T)

   If  ( Is_Empty? (Left_Sub_Tree (T) and

          Is_Empty? (Right_Sub_Tree (T) )

     then  return 'true'

     else  return 'false'

 

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

 

תהליך פתרון בעיות תוך שימוש בארגז הכלים:

מומלץ כי תהליך פתרון הבעיה יערך על פי השלבים הבאים: (א) זיהוי סוג הבעיה וקביעת המחלקה אליה ניתן לשייך את הבעיה; (ב) בחירת תבנית אבסטרקטית מתאימה; (ג) שכתוב התבנית על ידי החלפת שמות מופשטים לשמות משמעותיים מתאימים לבעיה הקונקרטית; (ד) כתיבת הקוד הרלוונטי למימוש תוכן ה"מגירה הסודית"; (ה) עריכה סופית של הפתרון.

 

התלמיד יחליט האם לצקת את תוכן ה"מגירה הסודית" במקום המתאים באלגוריתם הראשי, או לחילופין לשמור אותו במודול נפרד. ההמלצה לתת לתלמיד חופש להחליט באיזו תבנית (מתוך אוסף תבניות חלופיות) להשתמש, וכן כיצד לערוך את הפתרון (על ידי יציקת תוכן המגירה הסודית, או הכמסתו במודול נפרד) מבוססת על מחקר שהראה כי לתלמידים העדפות שונות לגבי מידת ההפשטה בה נוח להם לעבוד [10]. תלמידים המרגישים נוח יותר עם הפשטת פעולות עשויים להעדיף את הפתרון המודולרי.

 

שיטת "המגירות הסודיות" מודגמת להלן באמצעות פתרון שתי בעיות: (1) הצגה כפלט של עלי עץ בינרי; (2) חישוב גובה עץ בינרי. לכל בעיה מוצגות שתי שיטות חלופיות של עריכת הפתרון (מודולרית, ומשולבת – בה תוכן המגירה הסודית משולב באלגוריתם הראשי).

 


בעיה: הצגה כפלט של עלי עץ בינרי

 

בעיה: חישוב גובה עץ בינרי

Stage 1: The problem’s type – information retrieve

 

Stage 1: The problem’s type – value compute

Stage 2: The corresponding pattern – pattern A

 

Stage 2: The corresponding pattern – Pattern C

Stage 3: Rewriting the pattern:

Print_Leaves(T)

1. if  not Is_Empty ? (T) then

             1.1   Print_if_Leaf (T)    {  “secret box”  }

             1.2  Print_leaves(Left_Sub_Tree (T) )

   1.3   Print_leaves (Right_Sub_Tree (T) )

 

 

Stage 3: Rewriting the pattern:

Height(T)

1.   if  not Is_Empty ? (T) then  

                 {  "secret box"  }

1.1 return  Compute_Height(

                     T,

                                Height(Left_Sub_Tree (T) ),

                                      Height(Right_Sub_Tree (T) ) )

         2.  else return   -1

Stage 4: Implementing the "secret box":

Print_if_Leaf (T)           

         if  ( Is_Empty? (Left_Sub_Tree (T) ) and

   Is_Empty? (Right_Sub_Tree (T) ) then

                   Write(Retrieve_Root (T) )

 

Stage 4: Implementing the "secret box":

 

Compute_Height (T, Left_Height, Right_Height) 

              return  1 + max( Left_Height, Right_Height)

Stage 5: Formation of the solution

 

Stage 5: Formation of the solution

 A modular solution

Print_Leaves (T)

1.        if  not Is_Empty ? (T) then

1.1   Print_if_Leaf (T)   { "the secret box" }

                         1.1     Print_leaves(Left_Sub_Tree (T) )

                         1.2     Print_leaves (Right_Sub_Tree (T) )

 

{ The content of the “secret box”}

 

Print_if_Leaf (T)           

                 if  ( Is_Empty? (Left_Sub_Tree (T)  and

            Is_Empty? (Right_Sub_Tree (T) )

                    then

                    Write(Retrieve_Root (T) )

 

 A modular solution

Height (T)

1. if  not Is_Empty ? (T) then

             1.1  return  Compute_Height(  { "secret box" }

                                T,

                           Height(Left_Sub_Tree (T) ),

                                Height(Right_Sub_Tree (T) ) )

         2. else return  -1

 

{The content of the “secret box”}

 

Compute_Height (T, Left_Height, Right_Height) 

                return  1 +max( Left_Height, Right_Height)

 An integrated solution

Print_Leaves (T)

   1. if  not Is_Empty ? (T) then

        1.1 if  ( Is_Empty? (Left_Sub_Tree (T)  and

         Is_Empty? (Right_Sub_Tree (T) )

  then

                Write(Retrieve_Root(T) )

        1.2  Print_leaves (Left_Sub_Tree (T) )

        1.3  Print_leaves (Right_Sub_Tree (T) )

 

 An integrated solution

Height (T)

   1. if  not Is_Empty ? (T) then  

     1.1 return 1 + max(Height(Left_Sub_Tree (T) ),

                                      Height (Right_Sub_Tree (T) )

   2. else return  -1

 

 

מסקנות

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

 

מקורות

1.       Aho, A.V., Ullman, J.D., Foundations of computer science. Computer Science Press, W.H., Freeman and Company, 1992.

2.       Astrachan, O., Berry, G., Cox, L., & Mitchener, G. Design patterns: An essential component of CS curricula. Proceedings of the 28th SIGCSE Technical Symposium on CS Education. (1998), 153-160.

3.       Brandeis, O., et al. Software Design (in Hebrew), 1997.

4.       Dale, N., Walker, H.M., Abstract Data Types -specifications, implementations, and applications. D.C. Heath and Company, 1996.

5.       Gal-Ezer,J., Beeri, C., Harel, D., & Yehudai, A. a high-school program in computer science. Computer, 28(10), (1995), 73-80.

6.       Gal-Ezer,J., Harel, D. Curriculum and course syllabi for high school CS program. Computer Science Education, 9(2), 1999, 114-147.

7.       Gal-Ezer, J., Zeldes, A. Teaching software designing skills. Computer Science Education, 10(1), (2000), 25-38.

8.       Gamma, E., Helm, R., Johnson, R., & Vlissides, J. Design patterns, elements of reusable object-oriented software. Addison-Wesly, 1995.

9.       Gelfand, N., Goodrich, M.T., & Tamassia, R. Teaching Data Structure Design Patterns. Proceedings of the 28th SIGCSE Technical Symposium on CS Education. (1998), 331-334.

10.    Haberman, B. High-school students’ attitudes regarding procedural abstraction. Journal of Education and Information Technology, Special issue devoted to recent research projects of Secondary Informatics Education, (2004) (in press).

11.    Linn, M.C., & Clancy, M.J. The case for case studies of programming problems. Communications of the ACM, 35(3), (1992), 121-132.

12.    Nguyen, D. Design patterns for data structures. Proceedings of the 28th SIGCSE Technical Symposium on CS Education. (1998), 336-340.

13.    Nguyen, D., & Wong, S.B. Design patterns for sorting. Proceedings of the 31th SIGCSE Technical Symposium on CS Education. (2001), 263-267.

14.    Rist, R.S. Schema creation in programming. Cognitive Science, 13, (1989), 389-414.

15.    Soloway, E. From problems to programs via plans: the content and structure of knowledge for introductory lisp programming. J. Educational Computing Research, 1(2), (1985), 157-172.

 

אתר המרכז הארצי

אתר הבטים

גליון ינואר 2004

חזרה לתחילת העמוד