Final Mental Model: From File to Run

Learning Question

What is the durable model from file to run?

The concrete example was small:

print("hello")

stored in:

hello.py

and run with:

python hello.py

The durable model is what that small case revealed.

The File Is a Stored Representation

Before execution, hello.py is a stored representation.

It can contain source code, but it is not a running instance. It can be inspected by tools that do not execute it. Its existence does not imply there is a Python process, runtime stack, active control flow, open standard output write, or exit status.

This prevents the first confusion:

code exists != program is running

A Reader Applies Rules

The file becomes relevant to execution only when a reader uses it.

In the Python case, the main reader is the Python interpreter. But the command path also involved the shell, the operating system, and the terminal.

Different readers apply different rules:

Thing being read	Reader	Rule being applied
python hello.py	shell	command parsing
Python executable	operating system	process creation
hello.py	Python interpreter	Python source rules
output bytes	terminal or redirect target	display or storage rules

The reader is what turns stored material into the next step.

Runtime State Makes the Run Live

The run is not just interpretation of text. It creates live state.

For a short script, that state may disappear quickly. For a long-running program, it may persist for hours.

Runtime state can include:

• process identity
• memory
• stack frames
• loaded modules or classes
• open files and streams
• environment variables
• command-line arguments
• current working directory
• pending input or output
• exceptions and exit status

That state is why two runs of the same file can be different.

Behavior Is Observed Over Time

Behavior is what happens during the run:

• text appears in a terminal
• a file is written
• a network request is sent
• memory changes
• a thread waits
• an exception is raised
• a process exits

The behavior may be brief, visible, hidden, successful, failing, deterministic, or dependent on context.

The important point is that behavior unfolds through time. It is not the same kind of thing as a stored file.

The Checklist

When “software runs” feels vague, translate it into these questions:

1. What representation exists before the run?
2. Who reads or starts it?
3. What rules does that reader apply?
4. What process, runtime, or loaded state now exists?
5. What input and environment are part of this run?
6. What behavior is actually observed?
7. What remains after the run exits?

For hello.py, the answers are simple. For a web server, JVM application, C executable, or distributed service, the same questions still help.

The Final Layer Map

Use this map before entering the deeper execution collections:

Layer	Question
bytes and files	What is stored before meaning is applied?
source code	What language-level representation was written?
tool or reader	Who reads the representation next?
artifact or runtime material	What does that reader produce or prepare?
process	What operating-system-managed running instance exists?
runtime	What language or execution layer manages behavior?
environment	What inputs, dependencies, resources, and external state affect the run?
behavior	What actually happens over time?

The map is not a universal sequence. It is a checklist for not collapsing layers.

What To Carry Forward

When a later collection talks about bytes, remember that bytes need interpretation.

When a later collection talks about code artifacts, remember that artifacts target readers.

When a later collection talks about C, remember that native execution still needs translation, loading, process context, and machine execution.

When a later collection talks about operating systems, remember that a process is the live container, not the source file.

When a later collection talks about the JVM, remember that a managed runtime runs inside an operating-system process while adding its own execution model.

The sentence to carry forward is:

Software runs when a stored representation is read by the right execution environment, creating runtime state and observable behavior in a particular context.