Translators and Integrated Development Environments (IDEs) Worksheet with Answers

Revision Library

revisionlibrary.co.uk

GCSE · Computer Science

P2.10 Translators and Integrated Development Environments (IDEs)

OCR J277 · Calculators not allowed · about 90 minutes

Total Marks

Name: _______________________________ Date: ____ / ____ / ______

Answer ALL questions. Show all your working.

1

Source code must be translated into a form the computer's processor can execute directly.

(a)Which term describes code written by a programmer, before it has been translated?(1)

A) Object code
B) Source code
C) Byte code
D) Pseudocode

(b)Which term describes the code that is ready to be executed directly by the CPU, after translation?(1)

A) Source code
B) Flowchart
C) Object code
D) Comment

(c)Which of these is an example of a low-level language?(1)

A) Python
B) Assembly language
C) Java
D) Visual Basic

(d)Which of these is an example of a high-level language?(1)

A) Machine code
B) Assembly language
C) Binary
D) Python

(Total for Question 1 is 4 marks)

2

An Integrated Development Environment (IDE) is a piece of software that provides tools to help a programmer write, test and debug programs.

(a)Which IDE tool shows different types of code element (e.g. keywords, strings, comments) in different colours, to make code easier to read?(1)

A) Auto-complete
B) Syntax highlighting
C) Breakpoint
D) Run-time environment

(b)Which IDE tool automatically suggests the rest of a keyword, variable or function name as the programmer types, to save time and reduce spelling mistakes?(1)

A) Auto-complete
B) Error diagnostics
C) Translator
D) Debugger

(c)Which IDE tool checks code for syntax errors as it is typed, underlining and reporting the location and type of any errors found?(1)

A) Auto-complete
B) Error diagnostics
C) Breakpoint
D) Refactoring tool

(d)Which IDE tool lets a programmer run a program from within the IDE, without needing separate software, so it can be tested immediately?(1)

A) Run-time environment
B) Version control
C) Auto-indentation
D) Stepping

(Total for Question 2 is 4 marks)

3

State two features of high-level languages that make them different from low-level languages.

(Total for Question 3 is 2 marks)

4

State two features of low-level languages (such as assembly language or machine code).

(Total for Question 4 is 2 marks)

5

Programs can be written in either a high-level or a low-level language.

(a)State one advantage of writing a program in a high-level language rather than a low-level language.(2)

(b)State one advantage of writing a program in a low-level language rather than a high-level language.(2)

(Total for Question 5 is 4 marks)

6

State what an assembler does.

(Total for Question 6 is 2 marks)

7

Explain why assembly language uses mnemonics (short text codes such as ADD or JMP) instead of pure binary machine code.

(Total for Question 7 is 3 marks)

8

Two important translators used when developing software are compilers and interpreters.

(a)Define what is meant by a compiler.(2)

(b)Define what is meant by an interpreter.(2)

(Total for Question 8 is 4 marks)

9

Explain how a compiler translates a program, including what happens if the compiler finds a syntax error.

(Total for Question 9 is 4 marks)

10

Explain how an interpreter translates and executes a program, including what happens if it reaches a line containing a syntax error.

(Total for Question 10 is 4 marks)

11

State three differences between compilers and interpreters.

(Total for Question 11 is 6 marks)

12

A company is developing firmware for a low-cost embedded thermostat. The firmware must run as fast as possible on very limited memory, and will be mass-produced and never modified once installed.

(Total for Question 12 is 3 marks)

13

A student is learning to program and wants to test small sections of code and see errors immediately as they type, without waiting for the whole program to be checked.

(Total for Question 13 is 3 marks)

14

Explain how a breakpoint helps a programmer to debug a program.

(Total for Question 14 is 3 marks)

15

Explain how single-stepping through code (running the program one line at a time) helps a programmer to debug it.

(Total for Question 15 is 2 marks)

16

Explain one benefit of a code refactoring tool built into an IDE.

(Total for Question 16 is 2 marks)

17

A junior programmer keeps forgetting to close brackets and does not indent the inside of loops consistently, making the code hard to read.

(Total for Question 17 is 4 marks)

18

A student writes the following single line of code, which contains a syntax error (a missing closing bracket): OUTPUT ("Well done"

(a)Describe what happens when this line is translated using a compiler.(2)

(b)Describe what happens when this line is run using an interpreter.(2)

(Total for Question 18 is 4 marks)

19

A software company is deciding whether to develop a new mobile game using a compiler or an interpreter. Explain the key differences between compilers and interpreters, and discuss which would be more appropriate for this mobile game, justifying your answer.

(Total for Question 19 is 6 marks)

20

Discuss how IDE tools support a programmer while developing and testing a large program, referring to at least three different IDE tools in your answer.

(Total for Question 20 is 6 marks)

Mark scheme · P2.10 Translators and Integrated Development Environments (IDEs)

Question 1

(a) B1 B cao
(a) Answer: B) Source code
(b) B1 C cao
(b) Answer: C) Object code
(c) B1 B cao
(c) Answer: B) Assembly language
(d) B1 D cao
(d) Answer: D) Python

Question 2

(a) B1 B cao
(a) Answer: B) Syntax highlighting
(b) B1 A cao
(b) Answer: A) Auto-complete
(c) B1 B cao
(c) Answer: B) Error diagnostics
(d) B1 A cao
(d) Answer: A) Run-time environment

Question 3

B1 written using English-like keywords/commands (e.g. IF, FOR, PRINT), making them easier for humans to read and write, oe
B1 not tied to one specific processor's instruction set - the same source code is often portable across different types of computer, oe
Answer: High-level languages use English-like keywords, making them easier to read and write, and are not tied to one processor, so are more portable.

Question 4

B1 written in binary (machine code) or using short mnemonics (assembly language) that closely correspond to individual processor instructions, oe
B1 tied to a specific type of processor - a program is generally not portable between different processor types without rewriting, oe
Answer: Low-level languages closely match individual processor instructions (using binary or mnemonics) and are tied to a specific processor type.

Question 5

(a) B1 easier/quicker for a programmer to write and understand, since the syntax is closer to natural English, oe
(a) B1 more portable - the same source code can often be compiled/run on different types of computer with little or no change, oe
(a) Answer: It is easier and quicker to write and understand, and is more portable across different types of computer.
(b) B1 runs faster/more efficiently, since it does not need to be translated into a less direct set of instructions, oe
(b) B1 gives the programmer precise control over exactly how the hardware/memory is used, which matters for embedded systems or maximum performance, oe
(b) Answer: It runs faster/more efficiently and gives the programmer precise control over the hardware.

Question 6

B1 an assembler translates a program written in assembly language (using mnemonics, e.g. LDA, ADD, STA) into machine code, oe
B1 it typically translates on a one-to-one basis - each assembly language instruction becomes one machine code instruction, oe
Answer: An assembler translates assembly language (mnemonics) into machine code, usually one instruction at a time.

Question 7

B1 mnemonics are short, memorable text abbreviations for machine code operations, oe
B1 they are far easier for a programmer to read, write and remember than long strings of binary digits, oe
B1 this reduces the chance of a programmer making an error, while each mnemonic still maps directly to one machine instruction, so precise control over the hardware is kept, oe
Answer: Mnemonics are short, memorable abbreviations that are much easier to read and write than binary, reducing errors, while each still maps directly to one machine instruction.

Question 8

(a) B1 a compiler is a translator that converts the whole of a high-level source code program into object/machine code, oe
(a) B1 ...before the program is run, producing a standalone executable file, oe
(a) Answer: A compiler translates the whole of a high-level program into object/machine code before it is run, producing a standalone executable file.
(b) B1 an interpreter is a translator that translates and executes a high-level source code program, oe
(b) B1 ...one line/statement at a time, without producing a saved executable file, oe
(b) Answer: An interpreter translates and executes a program one line at a time, without producing a saved executable file.

Question 9

B1 the whole source code is read and translated together, checking for syntax errors, oe
B1 if any syntax errors are found, none of the program is translated/run; the compiler lists/reports the errors it found, oe
B1 if there are no errors, an object code (executable) file is produced, oe
B1 this executable file can then be run/distributed and executed directly, without the compiler or the original source code needing to be present again, oe
Answer: The compiler reads and checks the whole program together; if there are errors, none of it runs and the errors are reported, otherwise an executable file is produced that can be run independently afterwards.

Question 10

B1 the interpreter translates and executes the source code one line/statement at a time, oe
B1 each line is checked and run before the next line is translated, oe
B1 if a line contains an error, the interpreter stops immediately at that line and reports the error, oe
B1 any lines already executed before the error was reached will already have had their effect, but no executable file is produced/saved, oe
Answer: The interpreter translates and runs each line in turn; if it reaches a line with an error it stops immediately and reports it, and no executable file is ever saved.

Question 11

B1 a compiler translates the whole program at once; an interpreter translates it line by line, oe
B1 a compiler produces a saved executable (object code) file; an interpreter does not produce a saved executable file, oe
B1 once compiled, a program can be run without the original source code or the compiler present; an interpreter (or the source code) is needed every time an interpreted program is run, oe
B1 a compiled program generally runs faster, since translation only happens once; an interpreted program generally runs slower, because translation happens every time it is run, oe
B1 a compiler reports all syntax errors together at the end of translation; an interpreter stops as soon as it reaches the first error, oe
B1 nothing runs until a compiled program successfully compiles in full; an interpreted program can often be tested and debugged incrementally, one line at a time, oe
Answer: Compilers translate the whole program at once into a saved, faster-running executable and report all errors together; interpreters translate and run line by line, need no saved executable, run slower, and stop at the first error.

Question 12

B1 compiler, cao
B1 because compiling produces a standalone executable that runs directly/fast without needing the translator present, which suits a device with very limited memory, oe
B1 and because compiling happens once during development, so the slower/more thorough translation process does not affect how fast the finished device runs, oe
Answer: A compiler, because it produces a fast, standalone executable that does not need the translator present, and the one-off translation cost does not affect the device's running speed.

Question 13

B1 interpreter, cao
B1 because it translates and runs code line by line, so the student gets immediate feedback/sees an error as soon as that line is reached, oe
B1 which makes it easier to test and fix small sections of code one at a time while still learning, oe
Answer: An interpreter, because it gives immediate line-by-line feedback, which suits testing and fixing small sections of code while learning.

Question 14

B1 a breakpoint is a marker placed on a specific line of code that pauses execution of the program when that line is reached, oe
B1 this lets the programmer inspect the current values of variables at that exact point in the program, oe
B1 which helps them find the point at which a variable's value first becomes incorrect, narrowing down where a logic error is occurring, oe
Answer: A breakpoint pauses the program at a chosen line so the programmer can inspect variable values at that point, helping to narrow down where a logic error occurs.

Question 15

B1 it lets the programmer watch exactly what the program does, and how variable values change, one instruction at a time, oe
B1 this makes it easier to see precisely which line causes a value to become wrong, rather than only seeing the final incorrect output, oe
Answer: Single-stepping lets the programmer watch each instruction execute and see exactly when a variable's value first becomes wrong.

Question 16

B1 a refactoring tool automatically applies structural changes to code (e.g. renaming a variable everywhere it is used, or extracting repeated code into a subroutine), oe
B1 this saves time and reduces the risk of the programmer missing an occurrence and introducing a new error when making the same change by hand, oe
Answer: A refactoring tool automatically applies a structural change (e.g. a rename) everywhere it is needed, saving time and avoiding missed occurrences that a manual change could introduce.

Question 17

B1 auto-indentation, identified
B1 auto-indentation automatically indents the code inside loops/selection statements consistently, making the program's structure clearer and easier to check by eye, oe
B1 syntax highlighting/bracket matching, identified
B1 highlighting matching brackets (or colour-coding bracket pairs) makes it much easier to spot a bracket that has not been closed, oe
Answer: Auto-indentation, which keeps loop bodies consistently indented and easy to follow; and bracket matching/syntax highlighting, which makes an unclosed bracket easy to spot.

Question 18

(a) B1 the compiler translates the (whole) program and detects the missing bracket as a syntax error, oe
(a) B1 because there is an error, no object code/executable file is produced - the program will not run at all until the error is fixed, oe
(a) Answer: The compiler detects the missing bracket as a syntax error and produces no executable file, so the program cannot run until it is fixed.
(b) B1 the interpreter reaches this line and attempts to translate/execute it, oe
(b) B1 it detects the missing bracket, reports the error immediately, and stops - no more of the program runs, oe
(b) Answer: The interpreter reaches the line, detects the missing bracket, reports the error immediately and stops.

Question 19

Level 1 (1-2): Basic, undeveloped comments about compilers and/or interpreters are given, with little or no reference to the mobile game scenario. Little relevant technical terminology is used.
Level 2 (3-4): At least one genuine difference between compilers and interpreters is explained with some understanding, and a choice is made for the mobile game, but the justification may be one-sided or lack detail in places. Relevant technical terminology is generally used correctly.
Level 3 (5-6): A well-balanced discussion clearly explains multiple differences between compilers and interpreters (e.g. speed, error reporting, distribution) and reaches a justified, well-supported conclusion for the mobile game scenario. Relevant technical terminology is used correctly throughout.
Indicative content:
- A compiler translates the whole program before it is run, producing a standalone executable; an interpreter translates and executes line by line and needs the interpreter present every time the program runs
- Compiled programs generally run faster/more efficiently, which matters for a real-time mobile game that needs smooth performance
- Compiling produces one distributable file that does not expose the readable source code, which also helps protect the company's work from being copied
- A compiler reports all syntax errors together before anything runs, so a fully tested, compiled game is less likely to crash from small errors once released
- An interpreter can be useful earlier in development, for testing small sections of code quickly, but this matters less for the final released product
- A justified conclusion should recommend a compiler for the finished, released mobile game, since running speed and having a single protected executable matter more than line-by-line testing at this stage

Question 20

Level 1 (1-2): One or two IDE tools are named, with little or no explanation of how they help. Little relevant technical terminology is used.
Level 2 (3-4): At least two IDE tools are named and explained with some understanding of how each helps a programmer, but the discussion may lack detail or fail to link the tools together.
Level 3 (5-6): Three or more IDE tools are clearly named and explained (e.g. from editing, error-checking and debugging categories), with a coherent discussion of how, together, they reduce development time and the number of errors in a large program. Relevant technical terminology is used correctly throughout.
Indicative content:
- A source code editor with syntax highlighting, auto-indentation and auto-complete helps a programmer write code faster and with fewer typing mistakes
- Error diagnostics/real-time syntax checking catches mistakes as they are typed, before the program is even run
- A built-in run-time environment lets the programmer test the program immediately, without needing separate software
- Breakpoints, single-stepping and variable/watch windows let a programmer pause execution and inspect variable values, helping locate the exact point a logic error occurs
- Refactoring tools let a programmer safely restructure code (e.g. renaming a variable everywhere it is used) across a large program without missing an occurrence
- Together, these tools reduce development time and the number of errors that reach the finished program, which matters more as a program becomes large and complex

Translators and Integrated Development Environments (IDEs) - Worksheets, Questions and Revision

Next in this strand

P2.10 Translators and Integrated Development Environments (IDEs)

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20