Why write a 1999 hit game almost entirely in assembly?

What the processor actually runs

• A CPU can only execute machine code: instructions in binary.
• Each instruction is a simple step, such as load a value, add, store a result or jump.
• Each processor family has its own instruction set, so machine code for one family won't run on another.
• Machine code and assembly language are low-level languages: they work directly with the processor's own instructions.

Assembly language

• Assembly language replaces binary with short mnemonics such as LDA (load), ADD and STA (store).
• Each assembly instruction matches exactly one machine code instruction: a 1:1 correspondence.
• Like machine code, it is specific to one processor family.

LDA price    ; load price into the processor
ADD tax      ; add tax to it
STA total    ; store the result in total

High-level languages

• High-level languages use English-like keywords and maths-style expressions.
• One statement often becomes several machine code instructions: the line below becomes the three assembly instructions you just met.
• They are machine independent: the same source code can be translated to run on different processor families.
• A compiler or interpreter must translate the code before the CPU can run it.
• Most programs are high-level: they are quicker to write, read and debug.

total = price + tax

Choosing a level

• Use low-level for device drivers, embedded systems and code where speed or memory is critical.
• Use high-level for most applications, where quick development matters more.

Why do some languages show all your errors, and others just one?

Why translate?

• The CPU can only execute machine code, so the source code that programmers write must be translated first.
• A translator is a program that converts source code into a form the CPU can execute.
• High-level code is translated by a compiler or an interpreter.

Compiler or interpreter?

• A compiler translates the whole program before it runs, producing an executable file of machine code that runs without the compiler.
• An interpreter translates and runs the code one line at a time. It is needed every time the program runs.
• Errors: a compiler gives an error report for the whole program; an interpreter stops at the first error.

Choosing a translator

• An interpreter is mostly used while developing and testing a program; a compiler translates the final program for release.

How can a program tell you which line your bug is on?

One program for writing, running and fixing code

• An Integrated Development Environment (IDE) is software that puts tools for writing, translating, running and debugging code in one place.
• The editor is where you write and edit code. It shows line numbers, colours keywords and indents code automatically, so code is easier to read.

Translate, run and diagnose

• The IDE includes a translator, so you can compile or interpret your code with one click.
• The run-time environment runs your program inside the IDE: you see its output and enter input, and if it crashes the IDE shows what went wrong.
• Error diagnostics report each error with a message and its line number, and highlight that line.

Debugging tools

• A breakpoint pauses the program at a chosen line, before that line runs.
• Stepping runs the program one line at a time, so you can follow the path it takes.
• A variable watch shows the current value of chosen variables while the program runs.

Big ideas

• The CPU only runs machine code (binary); assembly uses mnemonics with a 1:1 match to machine code. Both are low-level and tied to one processor family.
• High-level languages are easier to write, read and debug and are machine independent, but must be translated.
• Low-level suits device drivers, embedded systems and speed-critical code; high-level suits most applications.
• Source code must be translated before the CPU can run it: a compiler translates the whole program into an executable; an interpreter translates and runs it line by line.
• Interpreters suit development and testing; compilers suit the final program.
• An IDE puts an editor, a translator, a run-time environment and error diagnostics in one program.
• Editor features such as line numbers, colour coding and automatic indentation make code easier to write and read.
• Breakpoints, stepping and variable watches help you find logic errors while the program runs.