Code

In short: A general term for instructions a computer can execute, or that are brought into an executable form.

In more detail: Covers different levels depending on context: source code (human-readable program text), machine code (bytes directly executable by the processor), or bytecode (an intermediate form, e.g. for Java). Converted from one level to the next by a compiler or interpreter.

In Depth

The path from source code to executable code differs by language: compiled languages like C or C++ translate the entire source code into machine code in advance, which then runs directly, with no further translation — fast at runtime, but platform-specific (has to be recompiled for every operating system/CPU architecture). Interpreted languages like Python or classic JavaScript, by contrast, read the source code line by line at runtime and execute it directly, without a separate compilation step — more flexible and platform-independent, but usually slower.

Java and C# take a middle path: they first compile to platform-independent bytecode, which is then executed by a virtual machine (the JVM for Java, the CLR for C#) on the respective target platform — often even translated into real machine code again at runtime (just-in-time compilation), to combine the advantages of both worlds: compile once, run anywhere, at near-compiled speed.

Code as text vs. code as structure

On disk, source code is initially nothing more than plain text — what distinguishes it from ordinary prose is the strict, formal grammar (syntax) that a compiler or interpreter must follow to even process the text at all. The first step of any processing is therefore “parsing”: the text is first broken down into individual tokens (keywords, identifiers, operators, brackets), which are then assembled into a syntax tree (Abstract Syntax Tree, AST) — a tree-like structure that represents the actual meaning of the code independently of formatting or comments. Only based on this tree does the compiler generate the actual machine or bytecode.

Readability as a value in itself

Because code is almost always read more often than it’s written (during bugfixes, code reviews, extensions by other developers), readability is considered its own quality trait in software development, independent of pure functionality — conventions like consistent indentation, meaningful variable names, or linter tools that automatically enforce style rules exist precisely for this reason. “Clean code” has become established as its own technical term for code that not only works correctly, but is also easy for humans to follow.

Minified and obfuscated code

At the other end of the spectrum is code deliberately meant NOT to be human-readable: minified JavaScript code (whitespace, line breaks and long variable names removed) reduces file size for faster load times in the browser, but remains technically followable. Obfuscated code goes further and deliberately disguises the structure (e.g. through meaningless variable names or artificially complicated control flow), usually to make reverse engineering harder — a trade-off that barely affects execution speed but completely sacrifices maintainability.

See also: Source Code, Pseudocode, Java