كيف تعمل البرامج على الكمبيوتر؟ | كورس أساسيات الكمبيوتر | الحلقة الثامنة

Main ideas / lessons conveyed

• Programs run on computers through a sequence of stages: translation (compile/interpret) → loading into memory (RAM) → execution by the CPU.
• Translation depends on the programming language:
  • Compiled languages (e.g., C, C++): a compiler translates source code into machine code (0s and 1s). The machine code is stored in an executable file (.exe) and executed directly by the CPU.
  • Interpreted languages (e.g., Python, JavaScript): an interpreter executes the program line-by-line without directly translating the whole program into machine code first. This can be slower but more flexible.
• RAM (Random Access Memory) is where code/instructions must be placed so the CPU can work with them while the program runs.
• The CPU (processor) performs the execution cycle:
  • fetch instructions from RAM,
  • decode them,
  • execute them,
  • store results back to RAM,
  • repeating continuously while the program runs.
• Control flow instructions such as jumps and branches manage which instructions run next:
  • they can skip parts of code,
  • repeat sections (supporting loops),
  • evaluate conditions,
  • change program paths based on events,
  • and help integrate features like functions and callbacks.
• Episode takeaway: by understanding how code becomes machine instructions and how the CPU + RAM coordinate, you understand what happens when any program runs.

Method / process described (step-by-step)

1) Compiling or interpreting the code (depends on language)

• Determine language type:
  • If compiled (e.g., C/C++):
    • Compiler translates high-level code into machine code (binary).
    • Machine code is saved as an executable file.
  • If interpreted (e.g., Python/JavaScript):
    • Interpreter runs code line-by-line.
    • It executes directly rather than relying on a pre-produced full machine-code executable.
• Note:
  • Compiled execution happens after translation (all at once).
  • Interpreted execution proceeds in stages.

2) Load program code into memory (RAM)

• After translation/interpretation:
  • The operating system reserves space in RAM for the program.
  • RAM holds the code/instructions needed for execution during startup.

3) CPU execution cycle

• While the program is running:
  • CPU fetches instructions from memory (using its internal counter).
  • CPU decodes the instructions.
  • CPU executes them via an execution unit.
  • CPU stores results back into RAM.
  • Results are shown to the user via the computer screen.
• This cycle runs very quickly, potentially thousands of times per second.

4) Jumps and branches (control flow)

• Use control flow mechanisms to manage instruction order:
  • Skip a section of code and go to another part.
  • Repeat code blocks (enabling loops).
  • Execute different paths based on conditions (branching).
  • Alter the program path when events occur.
  • Support programming features such as loops, conditionals, functions, and callbacks.
• Benefit mentioned: the program can handle unforeseen errors using information provided (contextually tied to control/flow logic).

Speakers / sources featured

• Narrator / video presenter: referred to as “we” (no specific named person given in the subtitles).
• God: referenced (e.g., “God willing” and blessings), but not as a speaker.
• Godzilla website / Godzilla course series: source of the course mentioned.
• No other identifiable speakers or specific authors are named.