איך מחשב עובד: רכיבים, הרצת תוכנה ושפות תכנות

מה בשיעור#

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

1. פרק ראשון — רכיבי המחשב: CPU, RAM, Storage ו-Registers
2. פרק שני — מה קורה מהרגע שמפעילים תוכנה ועד שהיא רצה
3. פרק שלישי — סוגי שפות תכנות: מקוד מכונה ועד Python

פרק ראשון: רכיבי המחשב: CPU, RAM, Storage ו-Registers#

מה נלמד?#

נפתח את “מכסה המחשב” ונכיר ארבעה רכיבים שכל מתכנת צריך להבין:

למה צריך את זה?#

כל שורת קוד שתכתבו בקורס עוברת דרך הרכיבים האלה. כשתבינו אותם, תבינו גם דברים שנראים כרגע “קסם”:

• למה משתנה נעלם כשהתוכנית נגמרת, אבל קובץ נשאר?
• למה תוכנית שקוראת מהדיסק איטית יותר מתוכנית שעובדת רק בזיכרון?
• למה המחשב “נתקע” כשפותחים יותר מדי תוכנות?
• בנושא Backend ומסדי נתונים, למה שומרים מידע ב-Database (על Storage) ולא סתם במשתנה?

בראיונות עבודה שואלים לעיתים קרובות “מה ההבדל בין RAM ל-Storage” — זו שאלה שבודקת אם מבינים את הבסיס.

הסבר מהבסיס#

CPU — Central Processing Unit (יחידת העיבוד המרכזית)#

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

• Clock Speed (מהירות שעון), נמדדת ב-GHz: 3 GHz ≈ שלושה מיליארד “פעימות” בשנייה.
• Core (ליבה): מעבד מודרני מכיל כמה ליבות, וכל ליבה היא כמו מעבד קטן נפרד. 8 ליבות = 8 דברים במקביל.

הקשר להרצת תוכנה: כל שורת Python שכתבתם מתורגמת בסוף להרבה הוראות קטנות, וה-CPU מבצע אותן אחת אחרי השנייה.

Registers — האוגרים#

Registers הם תאי זיכרון זעירים (כל אחד מחזיק מספר אחד) בתוך ה-CPU עצמו. זה הזיכרון המהיר ביותר שיש במחשב. כדי לחבר שני מספרים, ה-CPU קודם מביא אותם מה-RAM לתוך Registers, מחשב, ושומר את התוצאה ב-Register.

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

RAM — Random Access Memory (זיכרון גישה אקראית)#

RAM הוא הזיכרון שבו נמצאות התוכנות שרצות עכשיו והנתונים שלהן. כשאתם כותבים name = "Dana", הערך "Dana" נשמר ב-RAM.

שתי תכונות חשובות:

1. מהיר — הרבה יותר מ-Storage (פי אלפים).
2. זמני (Volatile) — כשהתוכנית נגמרת או שהמחשב נכבה, התוכן נמחק.

Storage — אחסון קבוע#

Storage הוא הדיסק: SSD (מהיר, בלי חלקים נעים) או HDD (דיסק מסתובב, ישן ואיטי). כאן שמורים מערכת ההפעלה, התוכנות המותקנות וכל הקבצים שלכם, כולל hello.py.

1. קבוע (Non-volatile) — המידע נשאר גם כשהמחשב כבוי.
2. גדול וזול — מאות GB עד TB, לעומת 8–32 GB של RAM.
3. איטי יחסית ל-RAM.

למה לא להסתפק ברכיב אחד?#

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

לקרוא מפרט של מחשב#

כל מה שלמדנו מופיע במפרט של כל מחשב — בחנות, באתר של היצרן, או ב-Task Manager. מפרט טיפוסי של לפטופ:

CPU       8 cores, 3.2 GHz
RAM       16 GB       (temporary)
Storage   512 GB SSD  (permanent)
OS        Windows 11, 64-bit (x64)

את אותם נתונים אפשר לראות במחשב עצמו: ב-Windows ב-Task Manager (Ctrl + Shift + Esc) → Performance, ובמק ב-Activity Monitor. שם רואים גם בזמן אמת כמה RAM תפוס, ואיך הוא עולה כשפותחים עוד ועוד תוכנות.

RAM מול Storage בפועל#

הקשר לתכנות: כל משתנה שתכתבו בתוכנית חי ב-RAM. בכל הרצה התוכנית מקבלת זיכרון חדש וריק, וכשהיא מסתיימת — הזיכרון משתחרר והערכים נעלמים. לכן מונה שסופר בתוך תוכנית “מתחיל מאפס” בכל הרצה מחדש.

מה שצריך להישאר — רשימת סטודנטים, הזמנות, ציונים — חייב להיכתב ל-Storage: לקובץ, או למסד נתונים. נלמד את שתי הדרכים בהמשך הקורס.

טעות נפוצה#

הטעות — “הוספתי RAM והמחשב ישמור יותר קבצים”, או ההפך: “יש לי 1TB דיסק אז לא חסר לי זיכרון”.

אלה שני משאבים שונים:

• מעט RAM ‏←‏ המחשב איטי כשהרבה תוכנות פתוחות. מערכת ההפעלה מתחילה להעביר חלקים מה-RAM לדיסק (נקרא Swap / Page File), והדיסק איטי.
• מעט Storage ‏←‏ אין מקום לשמור קבצים ולהתקין תוכנות.

טעות שנייה — “שמרתי”, אבל רק ב-RAM. תוכנה מציגה הודעה “נשמר!”, אבל בפועל המידע נמצא רק במשתנה, כלומר ב-RAM. כל עוד התוכנית רצה — הכול נראה תקין. כשהיא נסגרת או שהמחשב נכבה — הנתונים נעלמים. שמירה אמיתית היא תמיד כתיבה ל-Storage.

סיכום#

• CPU מבצע הוראות. Cores מאפשרות ביצוע במקביל, ו-GHz מודדים את קצב הפעימות.
• Registers הם הזיכרון הזעיר והמהיר ביותר, בתוך ה-CPU, ומחזיקים את מה שמחושב ברגע זה.
• RAM מהיר וזמני: משתנים חיים בו ונעלמים בסוף התוכנית.
• Storage (SSD/HDD) איטי יותר אבל קבוע: קבצים נשארים גם אחרי כיבוי.
• כדי ששמירה תשרוד, צריך לכתוב ל-Storage (קובץ / Database).

דוקומנטציה רשמית#

• Windows — Memory Management — RAM, זיכרון וירטואלי ואיך תוכנות מקבלות זיכרון
• Windows — About Memory Management — איך מערכת ההפעלה מנהלת את הזיכרון

פרק שני: מה קורה מהרגע שמפעילים תוכנה ועד שהיא רצה#

מה נלמד?#

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

למה צריך את זה?#

• כשתוכנית “לא עולה”, תדעו לשאול באיזה שלב היא נכשלה: הקובץ לא נמצא? אין הרשאה? חסר זיכרון?
• כשמדברים בנושא Python על Runtime Error (שגיאה בזמן ריצה) לעומת Syntax Error (שגיאת תחביר), ההבדל נובע בדיוק מהשלבים שנלמד כאן.
• בנושא Backend ומסדי נתונים נריץ שרת, תוכנה שלא נגמרת אלא ממשיכה לרוץ ולחכות לבקשות. כדי להבין את זה צריך להבין קודם מהי תוכנה רצה.

הסבר מהבסיס#

תוכנה שמורה לעומת תוכנה רצה#

תוכנה (Program) שלא רצה היא סתם קובץ על הדיסק — רצף של בתים ב-Storage. כדי שהיא “תעשה” משהו, צריך לטעון אותה ל-RAM ולתת ל-CPU לבצע את ההוראות שבה. תוכנה בזמן ריצה נקראת Process (תהליך). ההבחנה הזו חשובה מאוד, ונעמיק בה מחר.

המסלול הכללי — 6 שלבים#

1. בקשה — המשתמש לוחץ פעמיים על אייקון, או כותב פקודה ב-Terminal.
2. איתור — מערכת ההפעלה (Operating System) מחפשת את קובץ התוכנה על ה-Storage.
3. בדיקת הרשאות — מערכת ההפעלה בודקת שמותר למשתמש הזה להריץ את הקובץ.
4. יצירת Process — מערכת ההפעלה רושמת תהליך חדש, נותנת לו מספר מזהה (PID — Process ID) ומקצה לו אזור זיכרון משלו ב-RAM.
5. טעינה ל-RAM — מערכת ההפעלה מעתיקה את הוראות התוכנה מהדיסק לאזור הזיכרון של התהליך, ומכניסה אותו לתור של ה-CPU.
6. ביצוע — ה-CPU מתחיל לבצע את ההוראות, אחת אחרי השנייה, במחזור שנקרא Fetch → Decode → Execute.

מחזור Fetch → Decode → Execute#

זה ה"דופק" של כל מחשב. ה-CPU חוזר עליו מיליארדי פעמים בשנייה:

ומה קורה עם Python?#

ה-CPU לא מבין Python. הוא מבין רק שפת מכונה (Machine Code) של הארכיטקטורה שלו. אז מה קורה כשכותבים python hello.py?

1. מערכת ההפעלה מוצאת את התוכנה python (קובץ python.exe ב-Windows), יוצרת Process וטוענת אליו את התוכנה. מה שרץ על ה-CPU הוא ה-Interpreter, שהוא בעצמו תוכנה בשפת מכונה.
2. ה-Interpreter קורא את hello.py מהדיסק.
3. הוא בודק תחביר ומתרגם (Compile) את כל הקובץ לשפת ביניים פשוטה שנקראת Bytecode. אם יש שגיאת תחביר, התהליך נעצר כאן, לפני ששורה אחת רצה.
4. ה-PVM (Python Virtual Machine), החלק ב-Interpreter שמבצע Bytecode, עובר על ההוראות אחת אחרי השנייה ומבצע אותן. אם שורה מסוימת נכשלת (למשל חלוקה באפס), נוצרת שגיאה בזמן ריצה, ושורות שכבר רצו — רצו.
5. כשהקוד נגמר, ה-Process מסתיים ומערכת ההפעלה משחררת את ה-RAM שלו.

hello.py (Storage)
   │  python reads the file
   ▼
Syntax check + compile  ──►  Bytecode  (in RAM)
   │
   ▼
PVM executes bytecode instruction by instruction
   │  each instruction = many machine instructions
   ▼
CPU: Fetch → Decode → Execute (billions per second)

כל הרצה היא תהליך חדש#

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

python hello.py   ->  new Process, PID 14872
python hello.py   ->  new Process, PID 9316
python hello.py   ->  new Process, PID 20480

ה-Program (הקובץ hello.py) לא השתנה. כל Process הוא הרצה נפרדת שלו, שנולדת, רצה ונעלמת. אפשר לראות את זה בעיניים ב-Task Manager: תהליך בשם python מופיע בזמן שהתוכנית רצה, ונעלם כשהיא מסתיימת.

טעות נפוצה#

הטעות: לחשוב שכל השגיאות קורות באותו רגע. יש שני רגעים שונים לגמרי:

print("Line 1 runs?")
print("Line 3"
→ SyntaxError: '(' was never closed
  (nothing runs at all)

print("Line 1 runs")
print(10 / 0)
→ Line 1 runs
→ ZeroDivisionError: division by zero

• SyntaxError נתפסת בשלב בדיקת התחביר, לפני שנוצר Bytecode — ולכן אף שורה לא רצה, גם לא הראשונה.
• ZeroDivisionError היא שגיאת זמן ריצה — ה-PVM כבר ביצע את השורות שלפניה, ונעצר רק כשהגיע לשורה הבעייתית.

כך מזהים באיזה שלב של המסלול נמצאת הבעיה: אם שום דבר לא הודפס — כנראה תחביר. אם חלק הודפס — הבעיה בשורה שבה התוכנית נעצרה.

סיכום#

• תוכנה על הדיסק היא סתם קובץ. כשהיא רצה, היא Process עם PID משלה ואזור ב-RAM.
• מערכת ההפעלה מוצאת את הקובץ, בודקת הרשאות, יוצרת Process וטוענת את התוכנה לזיכרון שלו ב-RAM.
• ה-CPU מבצע הוראות במחזור Fetch → Decode → Execute, בעזרת Registers.
• ב-Python: הקוד נבדק ומתורגם ל-Bytecode, ואז ה-PVM מבצע אותו.
• Syntax Error עוצרת לפני שורה ראשונה. Runtime Error עוצרת באמצע, אחרי ששורות קודמות כבר רצו.

דוקומנטציה רשמית#

• Windows — About Processes and Threads — מתוכנית לתהליך שרץ
• Python Glossary — bytecode — מה Python עושה עם הקובץ לפני שהיא מריצה אותו

פרק שלישי: סוגי שפות תכנות: מקוד מכונה ועד Python#

מה נלמד?#

בפרק הקודם ראינו שה-CPU מבצע הוראות במחזור Fetch → Decode → Execute. היום נשאל: מאיפה מגיעות ההוראות האלה? נלמד:

• מה זה קוד מכונה (Machine Code) ולמה אף אחד לא כותב בו.
• מה ההבדל בין שפות Low-level לשפות High-level.
• שתי הדרכים לתרגם קוד להוראות: Compiler ו-Interpreter.
• איפה Python נמצאת, ולמה בחרנו בה לקורס.

למה צריך את זה?#

כשמתחילים לתכנת, שומעים כל הזמן משפטים כמו “C מהירה”, “Python איטית”, “JavaScript רצה בדפדפן” או “צריך לקמפל את זה”. בלי להבין איך קוד הופך להוראות שה-CPU מבצע, המשפטים האלה נשמעים כמו קסם.

ההבנה הזו עוזרת גם בפועל:

• להבין למה Python מוצאת שגיאת תחביר עוד לפני שהקוד רץ, אבל שגיאות אחרות רק באמצע הריצה.
• לבחור את הכלי הנכון למשימה — ולהבין למה חברות משתמשות בכמה שפות במקביל.
• לענות על שאלה קלאסית בראיונות עבודה: “מה ההבדל בין Compiled ל-Interpreted?”

הסבר מהבסיס#

מה ה-CPU באמת מבין#

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

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

שפת תכנות היא גשר: אנחנו כותבים בשפה שנוחה לנו, ותוכנה מיוחדת מתרגמת אותה להוראות שה-CPU מבין.

Low-level מול High-level#

אותה פעולה — לשמור את האות a — בכמה רמות:

Machine Code   10110000 01100001
Assembly       MOV AL, 61h
C              char c = 'a';
Python         c = "a"

• Low-level (שפה ברמה נמוכה) — קרובה למכונה. שולטים בכל פרט: בזיכרון, ברגיסטרים, בכל הוראה. מהיר מאוד, אבל קשה לכתוב וקל לטעות. דוגמאות: Assembly, ובמידה רבה גם C.
• High-level (שפה ברמה גבוהה) — קרובה לשפה של בני אדם. השפה דואגת לפרטים בשבילנו: ניהול זיכרון, סוגי נתונים, רשימות ומילונים מוכנים. קל לכתוב ולקרוא, ובדרך כלל איטי יותר בזמן ריצה. דוגמאות: Python, JavaScript, Java.

Compiled — מתרגמים הכול מראש#

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

Compiled (C, Go, Rust):
  source code -> compiler -> program.exe -> run
  translate once, run many times

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

Interpreted — מתרגמים בזמן ההרצה#

בשפה מפורשת תוכנה בשם Interpreter (מפרש) קוראת את הקוד בזמן ההרצה, ומבצעת אותו תוך כדי תרגום.

Interpreted (Python, JavaScript):
  source code -> interpreter -> run, line by line
  translate every time you run

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

שפות מוכרות ומה עושים איתן#

ואיפה Python נמצאת?#

Python היא שפה High-level ומפורשת. אבל מאחורי הקלעים יש שלב ביניים, כמו שראינו בפרק הקודם:

1. Python קוראת את כל הקובץ ובודקת תחביר — לכן SyntaxError עוצר הכול לפני שורה ראשונה.
2. היא מתרגמת את הקוד ל-Bytecode — הוראות ביניים פשוטות.
3. ה-PVM (Python Virtual Machine) מריץ את ה-Bytecode הוראה אחרי הוראה — ושגיאות כמו ZeroDivisionError מתגלות רק כשמגיעים לשורה.

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

טעות נפוצה#

“איזו שפה הכי טובה?” — זו שאלה בלי תשובה.

• אין שפה הכי טובה — יש שפה שמתאימה למשימה. משחק תלת-ממד צריך מהירות של C++; ניתוח נתונים צריך את הספריות של Python; אתר צריך JavaScript.
• שפה שמהירה בזמן ריצה בדרך כלל איטית יותר לכתיבה, ולהפך.
• הרעיונות עוברים בין שפות: משתנים, תנאים, לולאות, פונקציות ואובייקטים קיימים כמעט בכל שפה. מי שלמד שפה אחת היטב — לומד את הבאה הרבה יותר מהר.

טעות נוספת: לחשוב ש"מפורשת" אומר “לא בודקת כלום מראש”. Python כן בודקת את התחביר של כל הקובץ לפני הריצה — היא פשוט לא מייצרת קובץ הרצה נפרד.

סיכום#

• ה-CPU מבין רק קוד מכונה — אפסים ואחדים. שפת תכנות היא גשר בינינו לבינו.
• Low-level — קרובה למכונה, מהירה וקשה. High-level — קרובה לאדם, קריאה ונוחה.
• Compiler מתרגם הכול מראש לקובץ הרצה — ריצה מהירה. Interpreter מתרגם בזמן ההרצה — פיתוח נוח.
• Python היא High-level, מפורשת ודינמית, עם שלב Bytecode שה-PVM מריץ.
• אין שפה הכי טובה — יש שפה שמתאימה למשימה, והרעיונות עוברים בין שפות.

דוקומנטציה רשמית#

• Python FAQ — What is Python? — איפה Python נמצאת בין השפות
• Python Glossary — interpreted — שפה מפורשת מול שפה מקומפלת

תרגול#

שאלות הבנה על החומר של השיעור — בלי קוד.

תרגיל 1: איזה רכיב?#

לכל תיאור — איזה רכיב מתאים: CPU, Registers, RAM או Storage?

1. נמחק כשהמחשב נכבה, ובו נמצאים המשתנים של תוכנית שרצה.
2. מבצע מיליארדי הוראות בשנייה.
3. שומר את הקבצים גם כשאין חשמל.
4. תאי זיכרון זעירים ומהירים ביותר, בתוך המעבד.

תרגיל 2: לקרוא מפרט#

זה המפרט של לפטופ:

CPU       8 cores, 3.2 GHz
RAM       16 GB
Storage   512 GB SSD

1. מה המשמעות של 8 cores?
2. דני אומר: “יש לי 512 GB, אז אני יכול לפתוח כמה תוכנות שאני רוצה בלי שהמחשב יאט”. מה הטעות?

תרגיל 3: המסלול מקובץ לתהליך#

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

• (א) מערכת ההפעלה יוצרת תהליך (Process) חדש, עם PID ואזור זיכרון משלו
• (ב) מערכת ההפעלה מוצאת את קובץ התוכנה על הדיסק (Storage)
• (ג) ה-CPU מבצע את ההוראות של התוכנה, אחת אחרי השנייה (Fetch, Decode, Execute)
• (ד) מערכת ההפעלה טוענת את הוראות התוכנה מהדיסק לאזור הזיכרון של התהליך ב-RAM

תרגיל 4: שגיאה — באיזה שלב?#

בכל אחד מהמקרים הבאים: האם זו שגיאת תחביר (SyntaxError) או שגיאת זמן ריצה? והאם השורה הראשונה הודפסה?

# Program A
print("Start")
print("End"

# Program B
print("Start")
print(10 / 0)

תרגיל 5: Compiled מול Interpreted#

1. מה ההבדל בין Compiler ל-Interpreter?
2. תנו יתרון אחד לכל דרך.
3. איפה Python נמצאת בתמונה, ומה התפקיד של Bytecode ושל PVM?