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:

• Translates/converts (high-level/source) code one line/statement at a time (1)
• Translates/converts the code and executes/runs each line as it goes (1)
• Executes/runs each line/statement immediately after it is translated (1)
• Reports/stops with an error message as soon as a syntax error is found (1)

Allow 'runs' for executes, 'converts' for translates and 'instruction' for line/statement

Do not accept translates the whole program before it is run

Do not accept produces/creates object code, an executable file or machine code that is saved

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

• A compiler produces object code/machine code/an executable (file) (1) whereas an interpreter produces no object code/translated file (1)
• A compiler produces a machine code file (1) that can be run on its own/without the compiler/translator being present (1)
• An interpreter produces no object code/file (1) because it translates and executes each line instead of saving translated code (1)
• The compiler's output can be saved/stored (1) and run again later, while interpreted code has to be translated again each time it is run (1)

Allow binary for machine code.

Allow executable/an executable for object code.

Do not accept responses about translating the whole program, reporting errors or the speed of execution.

Do not accept 'the interpreter translates/executes one line at a time' on its own: this is how it translates, not what it produces. It earns the development only when linked to no object code/translated file being produced.

Do not accept the interpreter producing object code/an executable.

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

• Statements are written in English-like words/use maths symbols (1) so the programmer can understand more easily what each one does (1)
• The language uses meaningful names for variables/structured constructs such as loops (1) so the code is easier to read/follow (1)
• One statement translates into several machine code instructions (1) so there are fewer instructions to learn/understand for the same task (1)

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

Do not accept 'it is easier' / 'it is simpler' on its own, without saying what is easier/simpler.

Do not accept 'the computer understands it directly' / 'it does not need translating'.

Do not award answers about the program running faster or using less memory, as these are not about ease of learning.

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.

Indicative content

The output of each type of translator

• A compiler translates the whole program in one go and produces object code.
• The object code is saved as an executable file, which is already in machine code so the processor can run it directly.
• An interpreter does not produce object code, so no translated file exists for the company to save and sell.
• An interpreter translates one line at a time and executes it immediately, but that translation is not kept.

Whether the program has to be translated each time it is run

• Compiled code is translated once, so the executable can be run as many times as the customer likes without being translated again.
• If the source code is edited, the whole program has to be compiled again to produce a new executable.
• An interpreted program is translated again every time it is run, so a customer who runs the program often waits for translation at every run.
• An executable runs faster than interpreted code because it is already in machine code.

What the customer needs on their computer to run the program

• A customer who installs the executable needs no compiler on their computer, so the program will run straight away.
• If the company supplied the source code instead, the customer would need an interpreter installed, and it would have to be an interpreter for their type of computer.
• A customer given only the executable does not have the source code, so cannot change the program.

Conclusion

• A compiler is the better choice for this company, because the executable can be sold and the customer runs it without it being translated again and without being given the source code.
• Using an interpreter would mean supplying the source code to customers and translating the program on every run.

Levels

• Level 0 (0 marks): No rewardable content.
• Level 1 (1–2 marks): Basic, independent points are made, showing elements of understanding of key concepts/principles of computer science. (AO1) The discussion will contain basic information with little linkage between points made or application to the context. (AO2)
• Level 2 (3–4 marks): Demonstrates adequate understanding of key concepts/principles of computer science. (AO1) The discussion shows some linkages and lines of reasoning with some structure and application to the context. (AO2)
• Level 3 (5–6 marks): Demonstrates comprehensive understanding of key concepts/principles of computer science to support the discussion being presented. (AO1) The discussion is well developed, with sustained lines of reasoning that are coherent and logically structured, and which clearly apply to the context. (AO2)

Level 3 responses must cover all three bullets for this company's program, including translating once rather than on every run, and reach a conclusion.

Do not accept 'a compiler fixes errors' (a compiler reports syntax errors at the end of translation, it does not fix them) or 'a compiler is easier to use' with no link to output, translation or the customer. Do not accept answers about translating to assembly language.

Indicative content

How each translator deals with a syntax error

• An interpreter stops as soon as it finds a syntax error and displays an error message.
• With an interpreter, the lines before the error have already been executed, so the student can see how far the program got before it stopped.
• A compiler reports errors at the end of translation, so the student gets a list of all the syntax errors in the program in one go.

How much of the program is translated at a time

• An interpreter translates one line at a time and executes each line immediately.
• A compiler translates the whole program in one go before any of it is run.
• A compiler produces object code, so after every change the whole program must be compiled again before the student can run it.
• An interpreter produces no object code, so the student does not have to wait for the whole program to be translated before it runs.

How this affects the student's testing

• An interpreter suits this student because the program can be run straight away after each small change.
• The interpreter stops at the first error found, so the student fixes that error and runs the program again, but may only find the next error on the next run.
• Reporting every error at the end of compilation means the student can fix several errors at once, but cannot run the program until the whole program compiles.
• The student should use an interpreter while testing, and compile the finished program once it works.

Levels

• Level 0 (0 marks): No rewardable content.
• Level 1 (1–2 marks): Basic, independent points are made, showing elements of understanding of key concepts/principles of computer science. (AO1) The discussion will contain basic information with little linkage between points made or application to the context. (AO2)
• Level 2 (3–4 marks): Demonstrates adequate understanding of key concepts/principles of computer science. (AO1) The discussion shows some linkages and lines of reasoning with some structure and application to the context. (AO2)
• Level 3 (5–6 marks): Demonstrates comprehensive understanding of key concepts/principles of computer science to support the discussion being presented. (AO1) The discussion is well developed, with sustained lines of reasoning that are coherent and logically structured, and which clearly apply to the context. (AO2)

Level 3 responses must relate the way each translator works to the student's testing, not just describe the two translators.

Do not accept answers about run-time or logic errors where no comparison of the translators is made.