Low Level Languages

These are the "native" languages of computers, but are difficult for humans to program & maintain large programs.

Machine Code

• Raw binary that the CPU understands
• Different for every "type" of CPU (see Instruction Set Architecture), e.g.,
  • x86 instructions used by AMD and Intel chips
  • ARM licensed to many vendors used for most mobile phones, micro:bits, etc...
  • MIPS, Power ISA, and increasingly importantly RISC-V

Assembly Code

• One-to-one equivalence with the corresponding Machine Code / Instruction Set
• Translated to machine code with an assembler
• Uses mnemonics for each instruction
• Adds labels for variables and jump points - addresses of these data and instructions are then calculated by the assembler
• Often written in four columns: For example, using the LMC instruction set:

• See our LMC page for more details & translation tips

What you need to know for the exam is

High level languages are translated to machine instructions using compilers or interpreters. One line of high level language can convert to many lines of assembly / machine code.

Compiled Languages

• The whole program is read into the compiler to be analysed and optimised
• An executable binary file of machine code is produced by the compiler
• The executable can be run without the original source code or compiler - good for distribution of software
• The executable is usually optimised & fast
• Compilation is a (relatively) slow process and a small changes will require a full recompile

Interpreted Languages

• Interpreter reads and executes the source code line-by-line
• Doesn't need to compile/optimize ahead of time so is quick to start and quick to modify the code and restart.
• Doesn't optimize so is generally slower than compilation.
• Requires the source code and an interpreter to run - makes distribution trickier and harder to maintain intellectual property.

Exercises

1. Write a Python program and then a LMC Assembly program to multiply (by repeated addition) two inputted whole numbers. Compare the ease of writing, reading, changing programs using labels vs fixed memory references. Check that they assemble to equivalent machine code.
2. Investigate 2 popular and 2 less popular high level languages. Are they compiled, interpreted or something-else? What programming paradigm to they use and what do their "Hello World" programs look like? What are their major use cases?
3. The following two programs do basically the same thing. Compare their features as a high level language AND then use godbolt.org to compare the produced Python bytecode to the produced C assembly code.

Python 3:

x = 2

y = 3

z = x + y

print(f"{x} + {y} = {z}")

C (GCC 9.2):

#include <stdio.h>

int main() {

    int x = 2;

    int y = 3;

    int z = x + y;

    printf("%d + %d = %d", x, y, z);

    return 0;

}

Aside / Notes:

• The Python bytecode produced by the CPython interpreter is a stack-based language. Intro to the bytecode is here.
• Java, C#, Javascript and other languages use bytecodes too, but the Java and C# ones are compiled/optimised first. The Javascript interpreter in most browsers uses JIT compilation.
• There are different compilers and different architectures available for the C code. Compare the two major compilers, GCC & CLang. Compare the x86 to the ARM assembly with the same compiler family.
• C is often considered to be the lowest possible level of High Level Languages. As close to the machine as you can get without having to write assembly!