Edexcel GCSE Computer Science (1CP2) Exam Questions

• B Compiler (1)
• The only correct answer is B. The correct answer is compiler.
• A is not correct because an assembler translates assembly language code into machine code, not a high-level program
• C is not correct because an interpreter translates and executes the code line by line, without producing a complete machine code program first
• D is not correct because a linker combines object code files into a single executable, it does not translate source code

Award one mark for any of the following:

• Translation/execution stops (when the error is found) / the rest of the program is not translated/executed (1)

Allow stops/terminates/halts when the error is found

Do not accept shows/displays an error message on its own

Do not accept the whole program is translated and errors are reported at the end

Do not accept translates line by line on its own

Award one mark for any of the following up to a maximum of two marks:

• It can control/manipulate the hardware (components/registers/memory locations) directly (1)
• Each instruction maps to a single machine-code instruction, so the behaviour/timing can be controlled precisely (1)
• The code can run very quickly / has a fast execution time (1)
• The code uses less memory/RAM (1)
• The code can be optimised for a particular processor/chipset (1)

Only award one mark where both 'controls the hardware' and 'accesses registers/memory locations' are given, as these are the same point.

Do not accept 'it is closer to the hardware' without saying that it controls or accesses the hardware directly.

Do not accept easier/faster to write/program/learn/understand/debug (these are advantages of high-level languages).

Do not accept faster/quicker without qualification.

Do not accept portable/machine independent.

Do not accept does not need to be translated/compiled (assembly language must be assembled).

Do not accept it is a low-level language / a repeat of the question.

Award one mark for any of the following up to a maximum of two marks:

• The (same) program/source code can run on different types/makes of computer/processor (1)
• With few/no changes (to the program code) (1)
• The same source code can be translated for each type of processor (1)
• A different compiler/interpreter is used for each type of processor (1)
• The program does not depend on one specific type of processor/hardware (1)
• Only one version of the program needs to be written/kept (1)
• The program is portable between different computers (1)

Allow 'different computers' as meaning different types of computer/processor.

Do not accept a program that will only run on one type of computer / the computer it was written on.

Do not accept written in machine code/binary, is translated into machine code, compiled/interpreted, is a low-level language.

Award one mark for:

• The whole program (before it is run) (1)

Allow all of the code/the entire program/the whole program in one go

Do not accept one line/statement at a time or each line as it is executed

Do not accept translating only the lines that contain errors

Award up to two marks for a linked explanation such as:

• The programmer can choose the most efficient instructions/registers to use (1) so the program completes its task in fewer steps (1)
• The programmer can optimise the code for the processor (1) because low-level instructions give direct control of registers/memory (1)
• Each low-level instruction maps to one machine code instruction (1) so fewer instructions are executed than for the equivalent high-level code (1)
• The translated code is smaller (1) so fewer instructions are fetched from memory and executed (1)

For both marks, the expansion must follow/associate with the statement.

Do not accept 'it is low-level' / 'it is closer to machine code' / 'low-level code is faster' on its own without a reason why it makes the program run faster.

Do not accept 'high-level code has to be translated' / 'high-level code is interpreted' on its own without saying why that makes the program slower.

Do not accept 'the code is smaller' on its own without saying that this means fewer instructions are fetched/executed.

Do not accept 'it is easier to write' or 'quicker to type' as a reason for faster execution.