Show understanding of the characteristics of a number of programming paradigms: Low-level

2.7 Two‑Pass Assembler Process (required by the syllabus)

1. Pass 1 – Symbol Table Construction
   • Read source line by line.
   • When a label (e.g., LOOP:) is encountered, record its address (location counter) in a symbol table.
   • Calculate the length of each instruction to update the location counter.
2. Pass 2 – Code Generation
   • Re‑read the source.
   • Replace symbolic operands with the numeric addresses from the symbol table.
   • Emit the final machine code (binary or hexadecimal).

Sample listing (two‑pass) (using a tiny fictional ISA):

2.8 CPU Architecture & the Fetch‑Decode‑Execute Cycle

• Von Neumann – single memory for instructions and data (most PCs).
• Harvard – separate instruction and data memories (common in micro‑controllers).

Key CPU components (relevant to low‑level code):

• Register file (general‑purpose, special‑purpose such as PC, SP, FLAGS)
• Arithmetic‑Logic Unit (ALU)
• Control Unit (decodes op‑codes)
• Instruction Register (holds the current instruction)
• Program Counter (address of next instruction)
• Caches (L1, L2) – affect timing, important for real‑time systems.

Fetch‑Decode‑Execute Cycle (repeated millions of times per second):

1. Fetch: PC supplies the address; the instruction is read from memory into the Instruction Register (IR); PC is incremented (or altered by a branch).
2. Decode: Control Unit interprets the opcode, selects registers, and determines the required ALU operation or addressing mode.
3. Execute: ALU performs the operation; results may be written back to registers or memory; status flags are updated.

3. Linking Low‑level Paradigms to the Rest of the Syllabus

3.1 Information Representation

• Binary, hexadecimal, octal – essential for reading machine code and addressing.
• Two’s complement – hardware method for signed integer arithmetic.
• Worked example: Convert –13 to 8‑bit two’s‑complement:
  1. 13 in binary = 00001101
  2. Invert bits → 11110010
  3. Add 1 → 11110011
  Result: 11110011.
• Floating‑point (IEEE 754) – hardware representation of real numbers; the ALU may have a dedicated FPU.
• Character encodings – ASCII (7‑bit) and Unicode (UTF‑8/UTF‑16) stored as byte patterns accessed by low‑level code.
• Boolean algebra & Karnaugh maps – used to design the combinational logic that implements the ALU’s operations; low‑level programmers must understand the underlying logic when optimising bitwise code.

3.2 Hardware & Processor Fundamentals

• CPU components (register file, ALU, control unit, cache hierarchy).
• Interrupts – low‑level routines must save the processor state, service the interrupt, then restore state.
• Clock cycles & timing – crucial for real‑time and embedded systems.

3.3 System Software

3.4 Communication & Networks (Foundational Concepts)

• Binary representation of IP addresses (IPv4 = 32‑bit, IPv6 = 128‑bit).
• Network packet headers are parsed using bitwise operations (shifts, masks) that are directly implemented in assembly.
• Low‑level socket APIs (e.g., socket(), send()) eventually invoke system‑call assembly routines.

3.5 Security, Privacy & Data Integrity

• Threats: malware, unauthorised access, data loss.
• Low‑level countermeasures:
  • Memory‑Protection Unit (MPU) and privileged instruction sets.
  • Interrupt‑driven watchdog timers for fault detection.
  • Bitwise checksums and parity bits calculated with AND, XOR, SHIFT instructions.
• Example – Caesar cipher in assembly (shift each byte by 3):

          ; RDI points to start of buffer, RCX = length
          MOV   RBX, #3          ; shift amount
      loop:
          MOV   AL, [RDI]        ; load byte
          ADD   AL, BL           ; shift
          MOV   [RDI], AL        ; store back
          INC   RDI
          DEC   RCX
          JNZ   loop
          

3.6 Ethics & Ownership

Case study – Open‑source device drivers. A driver written in assembly can be released under the GPL, giving users the right to modify and redistribute the low‑level code. Discuss the impact on hardware manufacturers and end‑users.

3.7 Databases – Low‑level I/O

• Relational model (tables, primary/foreign keys) – accessed via high‑level SQL.
• On the hardware side, data is stored in blocks on disk; block‑level I/O is performed with low‑level instructions (e.g., BIOS interrupt INT 13h on x86).
• Understanding how data is laid out in memory helps when optimising queries or designing custom storage engines.

3.8 Data Structures – Implementation Hints

3.9 Algorithm Design & Problem Solving

Students should be able to express an algorithm both in pseudocode/flowchart form and, where appropriate, in low‑level assembly.

• Pseudocode (binary addition)

          INPUT A, B                // decimal numbers
          CONVERT A, B to binary
          PERFORM bit‑wise addition with carry
          OUTPUT result in decimal
          

• Assembly sketch (add two 8‑bit numbers in registers R0 and R1)

          MOV   R0, [A]       ; load operand A
          MOV   R1, [B]       ; load operand B
          ADD   R0, R0, R1    ; R0 = R0 + R1, Carry flag set on overflow
          JC    overflow      ; optional overflow handling
          STORE R0, RESULT
          

3.10 A‑Level Extensions (Common Exam Topics)

• Artificial Intelligence – SIMD (Single Instruction Multiple Data) extensions (e.g., ARM NEON, x86 SSE) accelerate matrix operations used in neural‑network inference.
• Encryption – RSA and AES are implemented using modular arithmetic and bitwise operations; performance‑critical parts are written in assembly to exploit hardware instructions.
• Virtual Machines – A VM (e.g., Java VM) interprets bytecode; the interpreter itself is a low‑level program that fetches, decodes, and executes bytecode instructions using the CPU’s instruction set.

4. When to Use Low‑level Paradigms

• Real‑time or safety‑critical systems where deterministic timing is mandatory.
• Device drivers, firmware, boot loaders, or embedded controllers with severe memory constraints.
• Performance‑critical kernels (OS schedulers, graphics pipelines, cryptographic primitives).
• Situations requiring direct hardware access for debugging, optimisation, or custom peripheral control.

5. Quick Revision Checklist

1. Define “low‑level programming paradigm”.
2. List the two main low‑level languages and give one concrete example of each.
3. Explain the three steps of the fetch‑decode‑execute cycle.
4. Convert -13 to 8‑bit two’s‑complement binary (show the steps).
5. Identify three OS services that rely on low‑level code (e.g., system calls, interrupt handling, memory management).
6. Write a one‑line assembly instruction that adds the contents of registers R2 and R3 and stores the result in R4 (use register addressing).
7. State one advantage and one disadvantage of using low‑level code.

6. Suggested Diagrams for Further Study

• CPU block diagram (register file, ALU, control unit, caches, PC, IR).
• Memory hierarchy (registers → L1/L2 cache → main memory → secondary storage).
• Fetch‑decode‑execute cycle flowchart.
• Simple network packet layout (e.g., IPv4 header fields in binary).
• Entity‑relationship diagram for a small relational database.
• Two‑pass assembler diagram showing symbol table construction and code generation.