This reading path is for rebuilding a practical model of what it means for software to run and how represented information becomes running behavior.
The path moves from the meaning of running to bytes and files, source code, code artifacts, machine execution, operating-system support, and managed runtime behavior.
Core Idea
Software becomes running behavior when stored representation is interpreted, translated, loaded, scheduled, and executed inside runtime environments.
Who This Reading Path Is For
This reading path is for readers who want to understand how digital artifacts become running programs inside real execution environments.
It is especially useful when source code, executable files, processes, operating systems, runtimes, and JVM behavior feel like one vague idea of “the program running.”
Learning Layers
- Orientation: software, code, files, programs, artifacts, runtimes, processes, and behavior as distinct layers.
- Representation: bytes, files, formats, and code artifacts before runtime behavior exists.
- Bridge to runtime: source files, code artifacts, executable files, runtime entry points, and processes.
- Translation and machine execution: C, assembly, CPU instructions, registers, memory addresses, and stack frames.
- Runtime support: processes, virtual memory, operating-system resources, I/O, scheduling, threads, and diagnostics.
- Managed runtime behavior: class files, bytecode, JVM memory, garbage collection, JIT compilation, pauses, and runtime diagnostics.
Reading Order
-
What Does It Mean for Software to Run?
This route covers the orientation layer. It explains running as the transition from stored representation to live behavior, and separates software, code, source files, programs, artifacts, runtimes, processes, and behavior before the deeper routes begin.
Read it first to avoid treating “software”, “program”, “code”, and “process” as one vague thing. It gives the starting vocabulary for the rest of the path.
-
How Bytes Become Files and Running Programs
This route covers the representation layer. It explains bits, bytes, files, formats, source files, code artifacts, executable files, and the boundary between stored data and runtime behavior.
Read it after the orientation route to get the representation layer: bytes do not mean anything by themselves. They become text, images, source code, class files, object files, executables, or runtime inputs only when some format, tool, runtime, or machine interprets them.
-
How Code Becomes a Running Process
This route covers the bridge from represented code to runtime context. It separates source files, code artifacts, executable files, managed-runtime inputs, runtime entry points, and running processes.
Read it after the bytes-and-files route to understand why a source file or generated artifact is still not running behavior, and why different artifacts need different tools, loaders, runtimes, or process contexts before they can execute.
-
How C Runs: Assembly, Memory, and the CPU
This route covers translation and machine execution. C exposes the connection between source code and machine behavior more directly than higher-level runtimes do. Assembly bridges expressions, variables, functions, pointers, and arrays to CPU instructions, registers, stack frames, memory addresses, executable files, and processes.
Read it after the bridge route to inspect one concrete path where source code is translated into lower-level artifacts and then into instructions that change CPU and memory state.
-
How Operating Systems Support Running Programs
This route covers runtime support. Software does not run on the CPU in isolation. A running program is also an operating-system-managed process with virtual memory, open resources, scheduling state, threads, communication channels, permissions, and observable lifetime.
Read it after the C execution model to place machine execution inside the support layer that makes real programs usable, isolated, interruptible, observable, and able to interact with files, devices, networks, and other processes.
-
How Java Runs on the JVM: Execution, Memory, and Runtime Behavior
This route covers managed runtime behavior. Much modern software runs through a managed runtime rather than directly from native executable code alone. Java source becomes class files, and a JVM process loads classes, executes bytecode or compiled machine code, manages heap memory, coordinates threads, and exposes runtime diagnostics.
Read it after the lower-level execution and operating-system routes so the JVM can be understood as a runtime built on top of the process, memory, file, thread, and CPU model rather than as a vague black box.
What This Reading Path Should Restore
- Running is the movement from stored representation to live behavior inside an execution environment.
- Software, code, files, programs, artifacts, runtimes, processes, and behavior are related but distinct layers.
- Bytes need interpretation before they become text, source code, executable files, or runtime inputs.
- Source code, code artifacts, executable files, runtime inputs, processes, and runtime behavior are related but distinct layers.
- CPU execution and operating-system support are connected, but they are not the same responsibility.
- Managed runtimes run inside operating-system processes while adding their own execution model, memory management, optimization, and diagnostics.
Why This Order Works
The sequence moves from orientation to representation and execution, then from execution to operating-system support and managed runtime behavior. Each route adds one layer without forcing the next layer to explain the previous one again.