Concepts / Compilers: Translating Code Before Execution

Compilers: Translating Code Before Execution

The key distinction in this topic is when translation and execution occur.

  • Programming

From Source to Result

When you write a Python statement, Python does not wait for an entire long program before showing every result. An interpreter translates and executes source code line by line. This makes Python suitable for interactive programming, where you can enter a statement and see its result immediately.

Source linePython statementTranslateInterpret the lineExecutePerform its actionResultAvailable to later linesone linetranslated lineupdates program state
How does source code move through translation and execution one line at a time?

A Program in Motion

Consider a program as a sequence of instructions. The interpreter processes the first line, then the second line, and continues in order. Each line can use results produced by earlier lines. It cannot use a result from a line that comes later, because that later line has not yet been processed.

Code walkthrough
total = 4
bonus = 3
grand_total = total + bonus
print(grand_total)
  1. 1
    The interpreter processes total = 4. The name total is associated with the value 4.
  2. 2
    It processes bonus = 3. The name bonus is associated with the value 3.
  3. 3
    It processes grand_total = total + bonus. The earlier values are retrieved and combined, producing 7.
  4. 4
    It processes print(grand_total), which displays 7.
  • Line 1 creates a value associated with total.
  • Line 2 creates a value associated with bonus.
  • Line 3 uses the results of the first two lines.
  • Line 4 displays the resulting value.
total = 4total → 4bonus = 3bonus → 3grand_total = 74 + 37printed outputnext lineearlier values availabledisplay result
What happens to each line of a multi-line Python program, and how does execution flow determine the final output?
Output
7

Interpreters and Compilers

The key distinction in this topic is when translation and execution occur. An interpreter translates and executes source code line by line. A compiler translates code before execution. Python is described here as an interpreter, so its execution model lets you work with statements interactively and see results immediately.

InterpreterCompiler
Translates and executes source code line by lineTranslates code before execution
Supports interactive work with immediate resultsThe provided material does not describe an interactive execution model
Python is described as an interpreterThe source pack provides the before-execution translation distinction

The comparison is limited to the translation and execution distinction described in the source material.

Names and Stored Values

Definition

A variable is a symbolic name that stores a value in memory. It lets a program refer to data by name rather than by repeating the literal value. When a later line uses the variable name, the program retrieves the value associated with that name.

scoresymbolic name10stored valuescore + 5retrieve score15computed resultrefers toretrieved by namecalculation
How does a variable name connect to stored data, and what happens when that name is used to retrieve the value?
python

The name score allows the later expression to retrieve 10 without writing the literal value again. This pattern is fundamental because programs can build new computations from values established by earlier lines.

Interactive Python

Python's interactive execution model follows the same line-by-line idea. You enter a Python statement, the interpreter translates and executes that statement, and you can see the result immediately. The result can then help you decide what statement to enter next.

Enter statementinteractive inputTranslate lineinterpreter actionExecute linestatement runsSee resultimmediate feedbacksubmitline translatedresult appears
What happens between entering a Python statement and immediately seeing its result?

Mistakes in Execution Order

  • Common mistake

    Trying to use a variable before its line has been processed

    What it looks like
    print(final_value)
final_value = 8
    Why it fails

    The first line comes before the line that establishes final_value, so the earlier line cannot use that later result.

    Do this instead
    Place final_value = 8 before print(final_value).
  • Common mistake

    Treating a variable name as if it were the literal value itself

    What it looks like
    points = 6
extra = points + 2
    Why it fails

    The name points must be understood as a reference to the stored value 6. It is not the text of the value; it is the symbolic name used to retrieve it.

    Do this instead

    Trace the name to its stored value before evaluating the expression.

  • Common mistake

    Skipping earlier lines when predicting output

    What it looks like
    base = 5
increase = 4
total = base + increase
print(total)
    Why it fails

    The final line depends on values produced by the earlier assignment lines.

    Do this instead

    Record each variable and its value in execution order.

Best practice

When tracing a program, read from the first line downward. After each assignment, write down the name and the value it now represents. When a later expression uses that name, substitute the stored value mentally before determining the next result.

Practice the Trace

What do you think happens?

What output does this program produce?

first = 2
second = 5
combined = first + second
print(combined)

  • 2

  • 5

  • 7

  • 25

Reveal answer
Answer:

7

The interpreter processes the assignments in order. first represents 2, second represents 5, and combined is calculated from those earlier values, producing 7. The final line displays that result.

EASY

Trace this program without running it. Write the value associated with each name after every assignment, then predict the displayed output.

starting = 3
change = 6
ending = starting + change
print(ending)
Hints
  • Process the assignments from top to bottom.
  • The expression for ending uses the values associated with starting and change.
  • The final line displays ending.

Key Takeaways

  1. 1
    An interpreter translates and executes source code line by line.
  2. 2
    Python's interactive model makes it possible to see results immediately after entering statements.
  3. 3
    Variables are symbolic names that store values and let later code retrieve those values by name.
  4. 4
    Sequential execution means a line can use earlier results but cannot use results from later lines.
  5. 5
    To predict output, trace every line in order and track the values associated with each variable.

At a glance

  • An interpreter translates and executes code one line at a time.
  • Python supports interactive programming because results can be seen immediately.
  • Variables provide symbolic names for stored values.
  • Execution is sequential: later lines can use earlier results, but earlier lines cannot use later results.
  • A reliable output trace records each variable's value as the interpreter moves through the program.

Related Topics

Related concepts

More concepts starting with C