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.
• An assembler translates assembly language into machine code.

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.

set 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.
• Assembly is translated by an assembler: each assembly instruction becomes one machine code instruction.

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 one line at a time into machine code and runs it. 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.
• An assembler is used when a program is written in assembly, e.g. for embedded systems or device drivers.

Inside a compiler

• Lexical analysis: comments and spaces are removed; keywords, constants and identifiers become tokens; a symbol table of variables, labels and subroutines is built.
• Syntax analysis: tokens are checked against the grammar rules; syntax errors are reported.
• Semantic analysis: checks the code makes sense, e.g. data types suit the operations.
• Code generation: machine code is produced.
• Code optimisation: the code is made faster or to use fewer resources.

Types of programming error

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 provides automatic line numbering, automatic colour coding of keywords and automatic formatting (indentation), so code is easier to read.
• Statement completion suggests how to finish a statement as you type.

Translate, run and diagnose

• The IDE includes a translator, so you can compile or interpret your code with one click.
• Error diagnostics report each error with a message and its line number, and highlight that line.
• Syntax error detection marks code that breaks the language's rules, often as you type.

Debugging tools

• A break point pauses the program at a chosen line, before that line runs.
• Trace 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.
• A memory inspector shows the contents of the memory locations the program is using.
• These are features of the debugger.

Building the final program

• Libraries are collections of ready-written, tested code for use in your own programs.
• They hold routines/subroutines and standard functions, e.g. to find the length of a string.
• The linker joins your translated code and the library routines it uses into one executable file.
• The loader copies the executable from storage into RAM so it can run.
• Code optimisation makes the translated code faster or use less memory.

It passed every test. So why did it fail for an 18-year-old?

Why test?

• Testing checks that a program works as intended and meets its requirements.
• It finds errors so they can be fixed before users meet them.
• A program can run without crashing and still give wrong results.
• Passing a few easy tests proves little: choose test data that could expose errors.

Normal, edge and wrong data

For a program that accepts whole numbers from 1 to 10:

• Typical data: sensible values that should be accepted, e.g. 5.
• Extreme data: the smallest and largest acceptable values, 1 and 10.
• Erroneous data: data that should be rejected, e.g. ten, −3 or 3.14.

Types of error

• A syntax error breaks the rules of the language, e.g. a missing bracket. The program cannot be translated or run.
• A logic error lets the program run, but it gives the wrong or unexpected result, e.g. > where ≥ was needed.
• A runtime error happens while the program runs and makes it crash, e.g. dividing by zero or using an index past the end of an array. Eduqas calls this a run-time or execution error.
• Testing with good test data is how you find logic errors.

Test plans

• A test plan lists each test before it is run: what it tests, the test data, its type and the expected result.
• After running, record the actual result. If they differ, fix the code and test again.

• Test 2 failed, so the range check needs fixing.

Code that is easy to maintain

• Other people (and you, later) must be able to read and change code. This is maintainability.
• Self-documenting identifiers: totalScore, not t.
• Annotation (comments) explain what each part of the code does.
• Indentation shows which lines belong inside loops, selection and subprograms.
• White space and a clear layout split code into readable blocks.
• Subroutines with well-defined interfaces break code into named, reusable parts.

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; assemblers translate assembly language.
• A compiler works in stages (lexical, syntax and semantic analysis, code generation, optimisation), and errors range from syntax to rounding and truncation.
• An IDE puts an editor, a translator, debugging tools and error diagnostics in one program.
• Editor features such as line numbers, colour coding and automatic formatting and statement completion make code easier to write and read.
• Breakpoints, trace and variable watches help you find logic errors while the program runs.
• Choose test data of every kind: normal, at the edges of the range, and data that should be rejected (typical, extreme, erroneous).
• Syntax errors stop a program running; logic errors give wrong results; runtime errors crash it while it runs.
• Meaningful names, comments, indentation and subprograms make code easy to maintain.