Understand the advantages and disadvantages of low-level language…

The idea

Low-level languages sit close to the hardware: machine code is binary instructions executed directly by the processor, and assembly language uses mnemonics that map almost one-to-one onto machine instructions. High-level languages such as Python or Java use readable statements, named variables and structured constructs, and need a translator before the processor can run them. Comparing them means weighing control against convenience. Low-level code can be written to use registers and memory precisely, so it can be very fast and compact, and it gives direct access to hardware — useful for device drivers and embedded firmware. The costs are that the programmer must manage every detail, code is hard to read and debug, it is tied to one processor family so it is not portable, and writing it takes far longer.

What earns the marks

• Low-level languages (machine code and assembly) are close to the hardware and give direct control of the processor and memory.
• Low-level programs can be very fast and memory-efficient because the programmer controls exactly what the processor does.
• Low-level code is difficult to read, write and debug, and takes much longer to produce.
• Low-level code is usually specific to one processor family, so it is not portable to different hardware.
• High-level languages are easier to read, write, test and maintain because they use understandable statements and named variables.
• High-level programs are portable between different machines, provided a suitable translator exists for the target platform.
• High-level code hides hardware detail, so it gives less precise control and may be slower or less memory-efficient than hand-written low-level code.
• A strong response pairs an advantage of one level with the corresponding disadvantage of the other, rather than listing unconnected points.

Common mistakes and how to put them right

• Saying high-level languages need no translation.

  Put it right by stating that high-level source code must be translated (by a compiler or interpreter) before the processor can execute it.

• Claiming low-level languages are always faster in every situation.

  Put it right by saying low-level code can be faster and more memory-efficient because of direct hardware control, not that it always is.

• Treating assembly language as identical to machine code.

  Put it right by explaining that assembly uses mnemonics mapped almost one-to-one to machine instructions, while machine code is binary.

• Listing advantages without matching disadvantages.

  Put it right by pairing each point, for example portability of high-level code against the non-portability of low-level code.

Exam tips

• Read the question to see whether it asks for advantages, disadvantages or a comparison, and answer exactly that.
• Pair each advantage with the matching disadvantage so the comparison is explicit.
• Use precise terms such as machine code, assembly language, mnemonics, portability and hardware control rather than vague words like 'better'.
• Link each point to a consequence, for example that direct hardware access suits device drivers or embedded systems.