Explain the benefits and drawbacks of using either a compiler or interpreter and justify the use of each

5.2 Language Translators

Learning Objective

Explain the benefits and drawbacks of using a compiler or an interpreter, and justify the most appropriate choice for a given programming task.

Key Definitions

• Language translator: A program that converts source code written in a high‑level language into a form that a computer can execute.
• Compiler: Translates the entire source program into target code (machine code or an intermediate representation) before any part of the program runs.
• Interpreter: Reads the source program and executes it directly, typically statement‑by‑statement, at run‑time.

Typical Compilation Phases (Cambridge A‑Level requirement)

1. Lexical analysis – source text → sequence of tokens.
2. Syntactic analysis (parsing) – tokens → parse tree / abstract syntax tree (AST).
3. Semantic analysis – type checking, scope resolution, detection of static errors.
4. Intermediate code generation – AST → three‑address code, byte‑code, etc.
5. Optimisation – dead‑code elimination, constant folding, loop unrolling, inlining, etc.
6. Target code generation – intermediate code → machine code or assembly.
7. Linking & loading – combine object modules, resolve external references, produce an executable.

Typical Interpreter Types

• Tree‑walk interpreter – traverses the AST and evaluates each node on the fly.
• Byte‑code interpreter – source → byte‑code (compact intermediate form) → executed by a virtual machine (e.g. Java Virtual Machine, CPython).
• REPL (Read–Eval–Print Loop) – interactive environment that reads a single statement, evaluates it, prints the result, then repeats.

Benefits and Drawbacks

Compilers

• Benefits

  • Fast execution – native machine code runs directly on the hardware.
  • Extensive optimisation – whole‑program analysis enables powerful transformations (loop unrolling, inlining, dead‑code elimination).
  • Source‑code protection – end users receive only a binary, reducing IP risk.
  • Static type checking catches many errors before the program runs.
  • Predictable resource usage – memory and CPU requirements are known from the compiled binary.

• Drawbacks

  • Longer development cycle – every change requires a recompilation step.
  • Platform dependence – a binary compiled for one architecture (e.g. x86) will not run on another (e.g. ARM) without recompilation.
  • Higher compilation resource demand – large projects may need substantial RAM and CPU time during the build.
  • Debugging difficulty – the executing code is not the original source; source‑level debugging relies on symbol tables and line‑number information.

Interpreters

• Benefits

  • Immediate feedback – ideal for interactive development, scripting, and teaching (e.g. Python REPL).
  • Platform independence – the same source runs on any machine that provides a compatible interpreter.
  • Smaller initial distribution – source can be shipped directly; no separate binary is required.
  • Dynamic features – runtime code generation, eval(), and reflective capabilities are easy to implement.
  • Simpler debugging – errors are reported with the original source line numbers.

• Drawbacks

  • Slower execution – each statement is parsed and evaluated each time it runs.
  • Limited optimisation – only local, runtime optimisations are possible.
  • Source exposure – the original code must be present on the target machine.
  • Later error detection – some errors (e.g. type mismatches) appear only when the offending line is executed.
  • Higher runtime memory overhead – the interpreter itself occupies memory in addition to the program.

Direct Comparison

When to Choose a Compiler

1. Performance‑critical applications (e.g. video games, scientific simulations, embedded control systems).
2. Software that will be distributed to end‑users without revealing source code.
3. Systems with limited run‑time resources where interpreter overhead would be unacceptable.
4. Projects that benefit from extensive static analysis (type safety, security audits) and optimisation.

When to Choose an Interpreter

1. Rapid prototyping, scripting, or educational environments where quick feedback is essential.
2. Cross‑platform tools that must run on many operating systems without recompilation.
3. Applications requiring dynamic behaviour such as plug‑in architectures, runtime code loading, or interactive command shells.
4. Small utilities or one‑off scripts where development speed outweighs execution speed.

Justifying the Choice – A Structured Approach (Exam Checklist)

1. Identify the key requirements – performance, portability, security, development speed, memory constraints.
2. Match requirements to translator characteristics – use the comparison table to find the best fit.
3. State the chosen approach and give at least two concrete reasons (e.g. “A compiler is preferred because the application processes large data sets in real‑time, and native code provides the necessary speed”).
4. Consider hybrid solutions – mention byte‑code or JIT compilation if the question allows a nuanced answer.

Hybrid Approaches (Byte‑code + JIT)

Modern languages often combine the advantages of both techniques:

• Java – source → byte‑code (platform‑independent) → executed by the JVM, which may JIT‑compile hot spots to native code.
• Python (CPython) – source → byte‑code → interpreted; alternative implementations (PyPy) use JIT for speed.
• C# – source → MSIL (Microsoft Intermediate Language) → JIT‑compiled by the .NET CLR.

These hybrid models provide portability (via an intermediate representation) and speed (via just‑in‑time optimisation).

Suggested Diagram (for classroom use)

5.1 Operating Systems

Purpose & Core Functions

• Resource management – CPU scheduling, memory allocation, I/O handling.
• File system services – creation, deletion, access control, hierarchical directories.
• Security & protection – user authentication, permission bits, isolation between processes.
• User interface – command‑line shells, graphical desktops.
• Utility programs & libraries – compilers, editors, system libraries (e.g. libc).

Common OS Types

Key Concepts for Exam

• Process vs. thread, multitasking, context switch.
• Virtual memory & paging.
• File permissions (read/write/execute) and ownership.
• System calls – the interface between user programmes and the OS kernel.

4 Processor Fundamentals

CPU Architecture Overview

• Control Unit (CU) – fetches instructions, decodes them, and coordinates execution.
• Arithmetic‑Logic Unit (ALU) – performs integer arithmetic, logical operations, and shifts.
• Registers – small, fast storage inside the CPU (e.g. ACC, PC, IR, general‑purpose registers).
• Cache – multi‑level memory (L1, L2, L3) that reduces latency.

Fetch‑Decode‑Execute Cycle

1. Fetch – the Program Counter (PC) supplies the address of the next instruction; the instruction is read from memory into the Instruction Register (IR).
2. Decode – the CU interprets the opcode and determines which registers or immediate values are needed.
3. Execute – the ALU performs the operation; results may be stored back in a register or memory.
4. PC is incremented (or altered by a branch/jump) and the cycle repeats.

Simple Assembly‑Language Example (x86‑like)

; Compute the sum of the first 5 natural numbers
MOV  R0, #0      ; accumulator = 0
MOV  R1, #1      ; i = 1
LOOP:
ADD  R0, R1      ; accumulator += i
ADD  R1, #1      ; i = i + 1
CMP  R1, #6      ; compare i with 6
BLT  LOOP        ; branch to LOOP while i < 6
; R0 now holds 15

Bit Manipulation (required for AS)

• Logical operators: AND, OR, NOT, XOR.
• Shift operators: SHL (left shift), SHR (right shift).
• Masking – e.g., extracting the low‑order 4 bits: value AND 0x0F.

6 Security, Privacy & Data Integrity

Core Concepts

• Confidentiality – ensuring that only authorised users can read data (encryption, access control).
• Integrity – guaranteeing that data has not been altered unintentionally or maliciously (hashes, checksums, digital signatures).
• Authentication – verifying the identity of a user or system (passwords, biometrics, two‑factor).
• Non‑repudiation – preventing a party from denying an action (digital signatures, audit logs).

Simple Encryption Example (Caesar Cipher)

plaintext = "HELLO"
shift = 3
ciphertext = "KHOOR"

Illustrates the idea of a reversible transformation; modern encryption uses far more complex algorithms (AES, RSA).

Hash Functions & Checksums

• One‑way functions that map data of arbitrary size to a fixed‑size digest (e.g., SHA‑256).
• Used for integrity checks – if the hash of a received file differs from the expected hash, the file has been corrupted or tampered with.

Basic Security Measures for Programmers

• Validate all input (prevent injection attacks).
• Use prepared statements for database queries.
• Store passwords using salted hashes, not plain text.
• Apply the principle of least privilege to files and processes.

7 Ethics & Ownership

Professional Ethics

• Follow a recognised code of conduct (e.g., BCS Code of Conduct, ACM/IEEE guidelines).
• Respect privacy, avoid plagiarism, and report security vulnerabilities responsibly.

Software Licences

AI & Emerging Ethical Issues (A‑Level extension)

• Bias in training data and algorithmic fairness.
• Responsibility for autonomous decisions.
• Intellectual‑property questions for AI‑generated code.

8 Databases

Relational Model Basics

• Data stored in tables (relations) consisting of rows (records) and columns (attributes).
• Primary key uniquely identifies each record; foreign keys create relationships between tables.

Entity‑Relationship (ER) Diagram Example

+----------------+          +----------------+
|   STUDENT      |          |   COURSE       |
+----------------+          +----------------+
| StuID (PK)     |◄───────►| CourseID (PK)  |
| Name           |          | Title          |
+----------------+          +----------------+
▲
│
│
+----------------+
| ENROLLMENT     |
+----------------+
| StuID (FK)     |
| CourseID (FK)  |
| Grade          |
+----------------+

DDL (Data Definition Language) Examples

CREATE TABLE Student (
StuID   INT PRIMARY KEY,
Name    VARCHAR(50)
);
CREATE TABLE Course (
CourseID INT PRIMARY KEY,
Title    VARCHAR(100)
);
CREATE TABLE Enrollment (
StuID    INT,
CourseID INT,
Grade    CHAR(1),
PRIMARY KEY (StuID, CourseID),
FOREIGN KEY (StuID) REFERENCES Student(StuID),
FOREIGN KEY (CourseID) REFERENCES Course(CourseID)
);

DML (Data Manipulation Language) Examples

INSERT INTO Student VALUES (1, 'Alice');
INSERT INTO Course  VALUES (101, 'Databases');
INSERT INTO Enrollment VALUES (1, 101, 'A');
SELECT S.Name, C.Title, E.Grade
FROM Enrollment E
JOIN Student S   ON E.StuID = S.StuID
JOIN Course C    ON E.CourseID = C.CourseID;

Normalization (up to 3NF)

• 1NF – atomic (indivisible) attributes.
• 2NF – no partial dependency on a composite primary key.
• 3NF – no transitive dependency on non‑key attributes.

9 Algorithms & Computational Thinking

Core Techniques

• Abstraction – focus on essential features, hide unnecessary detail.
• Decomposition – break a problem into smaller, manageable sub‑problems.
• Pattern recognition – identify similarities to reuse known solutions.
• Algorithm design – develop step‑by‑step procedures (pseudocode, flowcharts).

Pseudocode Conventions (Cambridge)

• Upper‑case keywords: IF … THEN … END IF, WHILE … DO … END WHILE, FOR … TO … DO … END FOR.
• Indentation indicates block structure.
• Comments start with # or //.

Example Algorithm – Linear Search

PROCEDURE LinearSearch(A[0..n-1], target)
FOR i ← 0 TO n-1 DO
IF A[i] = target THEN
RETURN i          // position found
END IF
END FOR
RETURN -1                 // not found
END PROCEDURE

Flowchart Symbols (quick reference)

• Oval – Start/End
• Parallelogram – Input/Output
• Rectangle – Process/Assignment
• Diamond – Decision (yes/no)
• Arrows – Flow of control

10 Data Types & Structures

Primitive Types (required for AS)

• Integer, Real (floating‑point), Boolean, Character, String.
• Range and overflow considerations (e.g., 16‑bit signed integer: –32768 to 32767).

Composite Types

• Array – fixed‑size collection of elements of the same type.
  

  INTEGER scores[10];

• Record (struct) – heterogeneous fields.
  

  RECORD Person { STRING name; INTEGER age; }

• Abstract Data Type (ADT) – logical description; examples: Stack, Queue, List.

ADT Example – Stack (Pseudocode)

TYPE Stack
ARRAY data[0..MAX-1] OF INTEGER
INTEGER top ← -1
END TYPE
PROCEDURE Push(S, value)
IF S.top = MAX-1 THEN
ERROR "Overflow"
ELSE
S.top ← S.top + 1
S.data[S.top] ← value
END IF
END PROCEDURE
FUNCTION Pop(S) RETURNS INTEGER
IF S.top = -1 THEN
ERROR "Underflow"
ELSE
value ← S.data[S.top]
S.top ← S.top - 1
RETURN value
END IF
END FUNCTION

11 Programming (Basics & Structured Programming)

Fundamental Constructs (Paper 2)

• Variables & assignment.
• Input/Output (e.g., READ, WRITE).
• Selection – IF…THEN…ELSE, CASE.
• Repetition – WHILE…DO, FOR…TO…DO, REPEAT…UNTIL.
• Procedures & functions (parameter passing by value/reference).

Structured Programming Principles

• Top‑down design – start with a high‑level overview, then refine.
• Single‑entry, single‑exit blocks – each control structure has one entry point and one exit point.
• Modularisation – break the program into reusable procedures/functions.

Sample Programme (Python‑style pseudocode)

# Programme to compute the factorial of a non‑negative integer
FUNCTION factorial(n: INTEGER) RETURNS INTEGER
IF n = 0 THEN
RETURN 1
ELSE
RETURN n * factorial(n-1)
END IF
END FUNCTION
READ n
IF n < 0 THEN
WRITE "Error: negative number"
ELSE
result ← factorial(n)
WRITE "Factorial =", result
END IF

12 Software Development Life‑Cycle (SDLC)

Common Models

Testing Levels (required for AS)

• Unit testing – individual modules or functions.
• Integration testing – combined modules.
• System testing – whole system against requirements.
• Acceptance testing – user validation.

Maintenance Types

• Corrective – fixing defects.
• Adaptive – adapting to new environments.
• Perfective – improving performance or usability.
• Preventive – refactoring to reduce future errors.

A‑Level Extensions (Optional but Frequently Examined)

Virtual Machines & JIT Compilation

• Definition of a virtual machine (VM) – an abstract computing layer that executes byte‑code.
• Advantages: platform independence, sandboxing, dynamic optimisation.
• Examples: JVM (Java), CLR (.NET), Python’s CPython VM.

Parallel Processing & Concurrency

• Multi‑core CPUs enable simultaneous execution of threads.
• Concepts: race condition, deadlock, synchronization (locks, semaphores).
• Simple parallel algorithm example – parallel sum using divide‑and‑conquer.

Advanced Security Topics

• Public‑key cryptography (RSA, Diffie‑Hellman).
• Digital certificates & PKI.
• Secure coding standards (OWASP Top Ten).

Networking Protocols (required for A‑Level)

• OSI model – 7 layers, focus on Transport (TCP/UDP) and Application (HTTP, SMTP).
• IP addressing, subnetting, NAT.
• Basic socket programming pseudo‑code.

Artificial Intelligence (A‑Level optional)

• Search algorithms – depth‑first, breadth‑first, A*.
• Simple machine‑learning concepts – supervised learning, decision trees.
• Ethical considerations revisited – bias, accountability.

Quick Revision Checklist (All Topics)

1. Identify the syllabus area the question belongs to (e.g., Language Translators, OS, Algorithms).
2. Recall the key definitions, core concepts, and one representative example.
3. Use the comparison tables or bullet‑point lists to structure your answer.
4. Where appropriate, justify choices with at least two concrete reasons.
5. For A‑Level questions, consider hybrid or advanced options (JIT, parallelism, security).