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:

• 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 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 compiler produces object code/machine code for the whole program (1) so there is no complete executable until every line has been translated (1)
• The compiler translates all the source code before producing the object code (1) so the program cannot start until translation has finished (1)
• The compiler checks the whole program for errors during translation (1) so all of the source code must be read before an executable can be produced (1)

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

Allow 'in one go'/'all at once' for the translation point, but this does not earn the second mark unless it is linked to why the program cannot be executed until translation has finished.

A statement that the whole program is translated, with no linked reason about when the program can be executed, earns 1 mark only.

Do not accept 'a compiler is faster' or 'compiled code runs faster' on its own; this does not explain why translation must finish before execution.

Do not accept 'it translates and runs the program one line at a time', as this describes an interpreter.

Indicative content

Ease of learning, use and debug

• High-level language statements are written in English-like words and mathematical symbols, so the students can read the quiz game code and understand what each line does.
• The language is easier to learn than a low-level language, so students who are new to programming can start writing the quiz game quickly.
• Errors are easier to find and fix because the code is readable; for example, the students can check a line that updates a score against the rule they intended.
• The students do not need to know how the processor carries out each statement, so they can concentrate on the quiz questions and rules.

Data structures

• High-level languages provide lists or arrays, so the names and scores of all the players can be stored under one name and processed with a loop.
• A record can store a player's name and score as one item; in some languages a dictionary or class can be used instead, which keeps related data together.
• Using a data structure makes the code shorter and easier to understand than separate variables for every player's name and score.

Built-in functions and library routines

• High-level languages provide built-in functions such as print and input, so the students can display a question and read a player's answer without writing the underlying code.
• Library routines such as a random number generator can be used to choose quiz questions, saving the students time.
• String-handling routines can check or compare a player's answer, so the students do not have to write these routines themselves.
• Reusing tested routines reduces the amount of code the students write and can reduce errors in the quiz game.

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: Credit only points applied to the quiz game and the students; comparison with low-level languages is not required, but a correct contrast may support a point if it is applied. Do not award generic claims such as 'high-level programs run faster', 'work on any computer' or 'students do not need to learn syntax' unless they are justified for the quiz game.

Level 3 responses must cover all three bullet areas with linked reasoning that explains why the characteristic helps the students finish the game quickly with few errors; an answer covering only two bullet areas is limited to Level 2. Do not award the idea that high-level code is already machine code or is understood directly by the processor. Accept dictionaries or classes as equivalents of records.

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.