Understand that assembly language uses mnemonics and requires an assembler

Learning Objective

By the end of this lesson students will be able to:

• Explain why assembly language uses mnemonics instead of binary op‑codes.
• Describe the role of an assembler and the steps it performs to produce machine code.
• Relate assembly language to the broader Cambridge IGCSE Computer Science syllabus (Topics 1‑10).
• Apply basic number‑system conversions and recognise how data is represented, transmitted, and processed before it reaches the assembler.

Syllabus Alignment (Cambridge IGCSE 0478)

Syllabus Block	Relevant Sub‑topics	How this note addresses them
1 – Data Representation	Binary, hexadecimal, two’s‑complement, logical shift, overflow	Number‑system refresher, 8‑bit addition/shift example, micro‑operation table
2 – Data Transmission	Packet structure, error detection (parity, checksum, CRC), simple encryption	Packet diagram, expanded error‑detection, conceptual symmetric/asymmetric encryption
3 – Hardware	CPU fetch‑decode‑execute cycle, registers, instruction set, embedded systems	Annotated von‑Neumann diagram, register list, instruction‑set examples
4 – Software	System vs application software, OS functions, interrupts, IDEs, compilers & interpreters	Comparison tables, OS functions list, interrupt description, compiler vs interpreter
5 – The Internet	URLs, HTTP/HTTPS, DNS, browsers, cookies, basic client‑server model	New subsection “Internet Fundamentals” (see below)
6 – Automated & Emerging Technologies	Sensors, actuators, robotics, AI basics, digital currency, cyber‑security threats	New subsection “Emerging Technologies” (see below)
7‑8 – Algorithms, Programming & Logic	Programming language levels, translation process, low‑level debugging	Full discussion of assembly language, assembler, and why it matters
9 – Databases	Single‑table design, primary key, basic SELECT/WHERE/ORDER BY, aggregate functions	New subsection “Database Basics” (see below)
10 – Boolean Logic	Logic gates, truth tables, constructing simple circuits	New subsection “Boolean Logic” (see below)

1. Number‑System Refresher (Topic 1)

Binary, Hexadecimal & Two’s‑Complement

• Binary: base‑2, digits 0 or 1.
• Hexadecimal: base‑16, digits 0‑9 and A‑F (e.g. 1010 1100₂ = AC₁₆).
• Two’s‑Complement (8‑bit) – represents signed numbers:
  • Positive numbers: same as binary (e.g. 0000 0110₂ = +6).
  • Negative numbers: invert bits and add 1 (e.g. 1111 1010₂ = –6).

Worked Example – 8‑bit addition with overflow

  0110 1101₂   (109 decimal)
+ 0101 0011₂   ( 83 decimal)
------------   ----------
  1100 0000₂   (192 decimal)  ← overflow ignored in 8‑bit unsigned arithmetic

Result 1100 0000₂ = C0₁₆. If the numbers were signed, the sign bit (most‑significant) changes, indicating overflow.

Logical Shift

A logical left shift moves bits toward the high‑order end, inserting 0s on the right.

  0010 1101₂ << 1  → 0101 1010₂

Micro‑operation Table – Linking Mnemonics to CPU Registers

Mnemonic	Operation (micro‑operation)	Typical Registers Involved
MOV	Transfer data from source to destination	AX, BX, memory address, immediate constant
ADD	ALU adds operand2 to operand1, result stored in operand1	AX, BX, immediate, flags (CF, OF, ZF)
SUB	ALU subtracts operand2 from operand1	AX, BX, immediate, flags
JMP	Program Counter (PC) ← target address	PC, label address
INC / DEC	ALU adds/subtracts 1; updates flags	AX, BX, memory location

2. Data Transmission Basics (Topic 2)

Packet Structure

• Header – source/destination addresses, control flags.
• Payload – the actual data being transferred.
• Trailer – error‑checking bits (parity, checksum, CRC).

Expanded Error Detection

• Parity bit – even or odd parity (single‑bit error detection).
• Checksum – sum of all bytes modulo 256; appended to the packet.
• CRC (Cyclic Redundancy Check) – polynomial division; widely used in Ethernet and storage.
• ARQ (Automatic Repeat reQuest) – protocol that requests retransmission when an error is detected.

Example – Even parity for the byte 10110010₂ (four 1s → even) → parity bit = 0.

Encryption – Conceptual Overview

• Symmetric key encryption – same key encrypts and decrypts (e.g., AES). Used for bulk data.
• Asymmetric (public‑key) encryption – pair of keys; public key encrypts, private key decrypts (e.g., RSA). Used for key exchange and digital signatures.
• For IGCSE depth it is enough to recognise the difference and give a simple real‑world example (e.g., HTTPS uses asymmetric encryption to exchange a symmetric session key).

3. Hardware Overview (Topic 3)

• CPU – Executes instructions using the fetch‑decode‑execute (FDE) cycle.
• Registers – Small, fast storage inside the CPU (e.g., AX, BX, CX, DX, PC, SP).
• Instruction Set – The collection of binary op‑codes a CPU can execute; assembly language provides a symbolic form.
• Embedded Systems – CPUs with limited resources that often run code written directly in assembly for speed or size.

4. Software Overview (Topic 4)

System vs Application Software

Aspect	System Software	Application Software
Purpose	Manages hardware & provides platform services (OS, device drivers)	Performs user‑oriented tasks (word processing, games, web browsing)
Examples	Windows, Linux, BIOS, assemblers, compilers	Microsoft Word, Scratch, mobile apps
CPU Interaction	Runs in privileged mode; can execute any instruction	Runs in user mode; limited to safe instructions

Operating System Functions

• Process management – scheduling, multitasking.
• Memory management – allocation, paging.
• File system – storage, retrieval, directories.
• Device control – handling interrupts from keyboards, printers, etc.

Interrupts

An interrupt is a signal from hardware (or software) that temporarily halts the current CPU activity, saves its state, and jumps to an interrupt service routine (ISR). After handling, execution resumes where it left off.

Compilers vs Interpreters

Feature	Compiler	Interpreter
Translation	Whole program → machine code (object file) before execution	Translates and executes line‑by‑line at run‑time
Speed of execution	Fast (native code)	Slower (translation overhead each line)
Error detection	All syntax errors caught before run‑time	Errors reported only when the offending line is reached
Examples (IGCSE relevance)	Java compiler, C compiler, assembler	Python interpreter, BASIC interpreter

5. Internet Fundamentals (Topic 5)

Key Concepts

• URL (Uniform Resource Locator) – identifies a resource on the web (e.g., https://www.example.com/index.html).
• HTTP / HTTPS – protocols for client‑server communication; HTTPS adds encryption via TLS/SSL.
• DNS (Domain Name System) – translates domain names to IP addresses.
• Web browsers – client software that sends HTTP requests and renders HTML.
• Cookies – small data stored by the browser to maintain state (e.g., login sessions).

These concepts provide the context for how data moves from a user’s computer to a remote server before any assembly‑level processing occurs.

6. Emerging & Automated Technologies (Topic 6)

Brief Overview

• Sensors & Actuators – convert physical phenomena to digital signals and vice‑versa (e.g., temperature sensor, motor driver).
• Robotics – integration of sensors, actuators, and control software; often programmed in low‑level languages for real‑time response.
• Artificial Intelligence (AI) – basic concepts such as machine learning, neural networks, and simple rule‑based systems.
• Digital Currency & Blockchain – decentralized ledgers; introduce concepts of hashing and cryptographic signatures.
• Cyber‑security – common threats (malware, phishing, DDoS) and basic mitigations (firewalls, encryption, authentication).

7. Assembly Language – Mnemonics (Topic 7‑8)

What is Assembly?

• Human‑readable, symbolic representation of a CPU’s machine instructions.
• One mnemonic usually corresponds to one binary opcode (one‑to‑one mapping).
• Operands are expressed with symbolic names: registers (AX, BX), constants, or memory labels.
• Architecture‑specific: an x86 assembler will not produce correct code for an ARM CPU.

Typical Mnemonics (x86 example)

; Load the constant 10 into register AX
MOV AX, 10

; Add the contents of BX to AX
ADD AX, BX

; Store the result from AX into memory location RESULT
MOV RESULT, AX

Structure of an Assembly Instruction

<label:>   <mnemonic>   <operand1>, <operand2>   ; optional comment

• Label – a name for a memory address (used for jumps).
• Mnemonic – the operation (e.g., MOV, ADD, JMP).
• Operands – registers, constants, or memory locations.

8. The Assembler – Translating Mnemonics to Machine Code (Topic 8)

Key Steps Performed by an Assembler

1. Lexical analysis – reads the source file, identifies mnemonics, registers, constants, and labels.
2. Opcode generation – replaces each mnemonic with its binary opcode (e.g., MOV → 10110000).
3. Address resolution – calculates the numeric address for each label and resolves relative jumps.
4. Object file creation – writes the binary opcodes, together with relocation information, into an object file.
5. Optional linking – a separate linker combines one or more object files and resolves external references, producing a final executable.

Why an Assembler Is Required

• The CPU can only execute binary machine code.
• Mnemonics are easier for humans to read, write, and debug.
• Assemblers perform error checking (illegal mnemonics, undefined labels, syntax errors) before code reaches the CPU.

9. Database Basics (Topic 9)

Core Concepts

• Table – collection of rows (records) and columns (fields).
• Primary key – a unique identifier for each record (e.g., StudentID).
• SQL SELECT statement – retrieves data.

  SELECT Name, Score
  FROM Results
  WHERE Score > 80
  ORDER BY Score DESC;
          

• Aggregate functions – COUNT, SUM, AVG, MIN, MAX.

  SELECT COUNT(*) AS Passed
  FROM Results
  WHERE Score >= 50;
          

10. Boolean Logic (Topic 10)

Logic Gates & Symbols

Gate	Symbol	Truth Table
AND		A B | Y 0 0 | 0 0 1 | 0 1 0 | 0 1 1 | 1
OR		A B | Y 0 0 | 0 0 1 | 1 1 0 | 1 1 1 | 1
NOT		A | Y 0 | 1 1 | 0
NAND		(inverse of AND)
NOR		(inverse of OR)
XOR		A B | Y 0 0 | 0 0 1 | 1 1 0 | 1 1 1 | 0

Simple Circuit Construction

To implement the logical expression (A AND B) OR (NOT C):

1. Use an AND gate for A AND B.
2. Use a NOT gate for NOT C.
3. Feed the two outputs into an OR gate.

This demonstrates how Boolean logic underpins decision‑making in both hardware and software.

11. Why Learn Assembly? (Topic 9‑10)

• Provides a concrete link between high‑level code and the hardware that actually executes it.
• Essential for understanding operating‑system kernels, device drivers, and embedded firmware.
• Helps in low‑level debugging (e.g., interpreting a memory dump or crash report).
• Develops logical thinking about how instructions are fetched, decoded, and executed – a core part of algorithmic reasoning.

12. Summary – Key Take‑aways

• Assembly language replaces binary op‑codes with readable mnemonics.
• An assembler translates these mnemonics into machine code, handling opcode lookup, address calculation, and error checking.
• Understanding assembly bridges the gap between abstract high‑level languages and the concrete operations of the CPU.
• Number systems, data transmission, hardware architecture, software categories, the Internet, emerging tech, databases, and Boolean logic all provide the context needed to appreciate low‑level programming.