Classification of programming languages and translators

(a)

• Python — high-level
• Assembly language — low-level
• Machine code — low-level
• C# — high-level (2 — 1 mark per correct pair)

(b) Any two of:

• Faster and easier to write, since one high-level statement replaces many low-level instructions (1)
• Easier to read, debug and maintain, since the code resembles English (1)
• Portable — the same source code can be translated for different processors, whereas low-level code is tied to one processor family (1)
• No detailed hardware knowledge needed (1)

(4)

Difference 1. Machine code is expressed in binary (1), whereas assembly language uses short mnemonics such as LDR, ADD and STR, which makes it readable by a human (1).

Difference 2. Machine code is executed directly by the processor and needs no translation (1), whereas assembly language must be translated by an assembler — with each line of assembly becoming exactly one machine code instruction, a 1:1 correspondence (1).

(4)

(a) Assembler, compiler and interpreter (2 — 1 mark for any two, 2 for all three).

(b)

• Assembler — translates assembly language (1)
• Compiler and interpreter — both translate high-level source code (1)

(4)

Advantages of low-level programming

• It gives direct control over the hardware, so specific processor features and hardware components can be used that a high-level language may not expose (1)
• It can be more efficient, since a skilled programmer can produce code that runs faster and uses less memory — important where resources are very limited (1)

Disadvantages of low-level programming

• It is far slower to write, because many low-level instructions are needed to achieve what one high-level statement does (1)
• It is not portable: machine code is specific to a processor or family of processors, so the program would have to be rewritten for different hardware (1)
• It is harder to read, debug and maintain, since mnemonics and register names carry no obvious meaning (1)
• It requires detailed knowledge of the processor's instruction set, so suitable programmers are rarer (1)

Overall, low-level programming buys control and efficiency at the cost of development time and portability (1).

(6 max)

Difference 1 — how much is translated at a time. A compiler translates the whole program at once, before it is run, producing a complete executable file (1). An interpreter translates and executes the source code one line at a time, every time the program is run (1).

Difference 2 — output produced. A compiler translates its input into machine code directly, so an executable machine code file is created (1). An interpreter does not generate machine code directly — instead it calls appropriate machine code subroutines within its own code to carry out each statement, and no output file is produced (1).

Difference 3 — error reporting. A compiler reports all errors together at the end of compilation, so the program will not run until they are fixed (1). An interpreter stops at the first error it meets and reports it immediately, so errors are found and fixed one at a time (1).

(Also creditworthy: the interpreter must be installed and present every time the program is run, whereas a compiled executable runs without the compiler; and compiled code generally executes faster, since no translation happens while it runs.)

(a) The processor can execute machine code only, and assembly language is not machine code, so it must be translated before it can run (1). The translator used is an assembler (1).

(b) There is a 1:1 correspondence: each line of assembly language is assembled into exactly one machine code instruction (1). The assembler translates its input into machine code directly (1).

(c) The washing machine controller is an embedded system with very limited memory and processing power, and assembly language gives direct control over the specific hardware components while producing small, efficient code (1).

(Also acceptable: the program must control specific hardware such as motors, valves and sensors directly, which a high-level language may not allow.)

Why an interpreter during development

• It stops at the first error and reports it immediately, identifying the line where execution stopped — so errors can be found and fixed one at a time rather than sifted from a long list (1)
• Changes can be tested straight away, without waiting to recompile the whole program, which for a large program would be slow and would interrupt the development cycle repeatedly (1)
• Only the part of the program reached needs to be correct, so an unfinished program can still be run and tested in part (1)

Why a compiled executable for customers

• The compiled program runs faster, because translation has already taken place and no translation happens while the program runs (1)
• The customer does not need an interpreter installed — the executable is machine code and runs on its own, which makes distribution far simpler (1)
• The customer receives machine code, not source code, so the team's original code cannot easily be read, copied or modified (1)

(6)

The case for Python. Development would be much faster, and the code easier to read, debug and maintain, which matters for safety-critical software that must be reviewed and updated over its life (1).

However, the constraints point elsewhere.

• Memory. With only 64 KB, a high-level program together with the interpreter or runtime it needs may not fit at all, whereas low-level code is far smaller (1).
• Predictable timing. The device must respond within a precisely predictable time. Low-level code gives direct control over exactly which instructions execute, making timing predictable, whereas high-level execution is harder to guarantee (1).
• Hardware access. The software must read specific sensors directly, and a high-level language may not expose the hardware features required (1).

Recommendation. Use a low-level language — assembly (1). This is an embedded system with limited resources and direct hardware control requirements, which is exactly the situation the low-level approach exists for; the efficiency and control gained outweigh the slower development (1).

The cost accepted. Development will take considerably longer, the code will be harder to maintain, and it will not be portable — if the company later changes processor, the software must be rewritten (1).

(6 max)

(a) The processor can execute machine code only, and machine code is expressed in binary (1). A high-level language does not consist of machine code, so it must be translated — here by a compiler — before the processor can run it (1).

(b) Machine code is specific to a processor or family of processors, because each type of processor has its own machine code instruction set (1). The binary patterns that represent particular operations on the first processor do not represent the same operations — or any valid operation — on the second, so the executable cannot be executed (1).

(c) Two solutions:

• Recompile the source code using a compiler that produces machine code for the second processor. The source code is portable even though the compiled executable is not, so no rewriting is needed — only re-translation (1).
• Distribute the source code and use an interpreter on each machine. The interpreter for each processor type carries out the statements using its own machine code subroutines, so the same source runs on both and only the interpreter differs (1).

(6)