Edexcel GCSE Computer Science (1CP2) Exam Questions

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:

• The interpreter executes each line as soon as it has been translated (1) so translation and execution happen together/at the same time (1)
• The compiler translates the whole program first (1) and the machine code is run later/separately (1)
• The interpreter translates the code and runs it while the program is running (1) whereas the compiler does not run the code it produces (1)
• The compiler produces translated code that is executed only after all the translation has finished (1) but the interpreter executes each line immediately (1)

Allow 'translates one line at a time' where it is linked to executing each line immediately.

Do not accept answers that only state that a compiler is faster/an interpreter is slower, without reference to when execution happens.

Do not accept answers that only give object code, error reporting or portability, without reference to when execution happens.

Do not accept the compiler executing the program as it translates it.

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

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.