Edexcel GCSE Computer Science (1CP2) Exam Questions

• A Executes the line (1)
• The only correct answer is A. The correct answer is that the interpreter executes the line.
• B is not correct because an interpreter does not produce object code; that is what a compiler does
• C is not correct because an interpreter does not save the translated code to a file
• D is not correct because the interpreter executes the current line before it translates the next line

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 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 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.

Indicative content

Machine independence

• A high-level language is machine independent, so the same source code can be run on different types of computer with few or no changes.
• The company can write the program once and sell it to users with different computers, without rewriting the code for each type of computer.
• Only one version of the program needs to be written and maintained, so development takes the company less time.

Processor specificity

• A low-level language is processor-specific, so a program written for one processor will not run on a different processor without being rewritten.
• Assembly language instructions depend on the instruction set of the particular processor, so the company would need a separate version of the program for each type of computer.
• Writing a separate low-level version for every type of computer would take the company much longer than writing one high-level program.
• Low-level code gives direct control of the hardware of one processor, so it is better suited to device drivers than to a program that must run on many different computers.

Translation

• High-level source code is translated for each type of computer by a compiler or an interpreter, so one version of the source code is enough for all the users.
• Assembly language is translated into machine code by an assembler, and the assembler produces machine code for one specific processor only.
• Machine code is already in a form that one particular processor can execute directly, but the same machine code will not run on a different processor.
• Each high-level statement translates into several machine code instructions, so the programmer does not need to know the instruction set of the processor.

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)

Additional guidance

• Level 3 responses must cover both high-level machine independence and low-level processor specificity, with the effect on the company's decision.
• Do not award low-level language, assembly language or machine code as portable, or 'high-level languages are written in English/like English' as a reason for machine independence.

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.