# Assembly Language & Little Man Computer ## What is the purpose of assembly language? - Assembly language bridges the gap between high-level programming languages (like Python, Java) and machine code (the binary instructions that hardware actually executes) - Enables programmers to write more **efficient** code compared to high-level languages, though this comes at the cost of increased **complexity** - Provides **direct access** to hardware components including registers and memory addresses, allowing fine-grained control - Each CPU architecture has its own specific assembly language tailored to that processor's instruction set

Assembly language is a low-level programming language using mnemonics to represent machine code instructions for a specific computer architecture

## Levels of abstraction in programming languages - Programming languages exist at different levels of abstraction from the hardware: - **Binary code**: Raw 1s and 0s that the CPU executes directly - not human-readable - **Machine code**: Hexadecimal representation of binary instructions - still not practical for humans to write - **Assembly language**: Uses memorable mnemonics (like `ADD`, `MOV`) instead of numeric codes - the lowest level most programmers work at - **Compiled languages** (C, C++): Higher-level syntax that must be translated to machine code before execution - **Interpreted languages** (Python, JavaScript): Even more abstract, executed line-by-line without prior compilation - As you move up these levels, code becomes more **human-readable** and **portable** across different systems - As you move down these levels, code becomes more **efficient** and provides more **hardware control**

Assembly sits one level above machine code - it's as close to the hardware as you can get while still using human-readable instructions

## Little Man Computer (LMC) - The Little Man Computer is a simplified teaching model that demonstrates how real computers work at a fundamental level - It abstracts away the complexity of modern processors while retaining the core concepts - The LMC contains essential components found in real computers: - **Memory**: Storage locations for data and instructions - **Accumulator**: A special register that holds values for calculations - **Calculator**: Performs arithmetic operations - **Instruction set**: Commands the computer can execute

The Little Man Computer (LMC) is a hypothetical computer model used to understand the fundamental operations and mechanics of real computers

## Little Man Computer instruction set - LMC programs use **mnemonics** - short text codes that represent specific operations - Each instruction tells the computer to perform one specific action | Mnemonic | Instruction | Alternative Mnemonic | |----------|-------------|---------------------| | **ADD** | Add | | | **SUB** | Subtract | | | **STA** | Store | STO | | **LDA** | Load | LOAD | | **BRA** | Branch always | BR | | **BRZ** | Branch if zero | BZ | | **BRP** | Branch if positive OR zero | BP | | **INP** | Input | IN, INPUT | | **OUT** | Output | | | **HLT** | End program | COB, END | | **DAT** | Data location | |

Different LMC implementations may use slight variations in mnemonics - any alternative listed will be accepted

### Core instruction explanations - **ADD**: Adds the value at the specified memory location to the accumulator - **SUB**: Subtracts the value at the specified memory location from the accumulator - **STA**: Stores the current accumulator value into the specified memory location - **LDA**: Loads a value from the specified memory location into the accumulator - **BRA**: Unconditionally jumps to a labeled instruction (always branches) - **BRZ**: Jumps to a labeled instruction only if the accumulator contains zero - **BRP**: Jumps to a labeled instruction only if the accumulator contains zero or a positive number - **INP**: Accepts input from the user and places it in the accumulator - **OUT**: Outputs the current value in the accumulator - **HLT**: Stops program execution - **DAT**: Reserves a memory location for storing data (acts as a variable) ## Example 1: Calculate the sum of two numbers - This program takes two numbers as input and outputs their sum ```assembly INP; // Get first number from user STA 50; // Save first number to memory location 50 INP; // Get second number from user ADD 50; // Add the value stored at location 50 to accumulator OUT; // Display the sum HLT; // Stop the program DAT; // Memory location 50 for data storage ``` ### How it works: 1. First `INP` places the user's input into the accumulator 2. `STA 50` copies this value to memory location 50 for safekeeping 3. Second `INP` overwrites the accumulator with the second number 4. `ADD 50` retrieves the first number from memory and adds it to the accumulator 5. `OUT` displays the result 6. `HLT` terminates execution

The accumulator can only hold one value at a time, so we must store intermediate values in memory locations

## Example 2: Find the maximum of three numbers - This program accepts three numbers and determines which is largest ```assembly INP // Input first number STA 81 // Store first number at location 81 INP // Input second number STA 82 // Store second number at location 82 INP // Input third number STA 83 // Store third number at location 83 LDA 81 // Load first number into accumulator SUB 82 // Subtract second number BRP check13 // If first >= second, compare first with third LDA 82 // Load second number SUB 83 // Subtract third number BRP show2 // If second >= third, output second LDA 83 // Otherwise third is largest OUT HLT check13 LDA 81 // Load first number again SUB 83 // Subtract third number BRP show1 // If first >= third, output first LDA 83 // Otherwise third is largest OUT HLT show1 LDA 81 // Load and output first number OUT HLT show2 LDA 82 // Load and output second number OUT HLT DAT DAT DAT ``` ### How it works: - The program uses **branching logic** to chain comparisons together - Comparisons are performed using `SUB` followed by `BRP`: - If the subtraction result is positive or zero, the first value was greater or equal - The `BRP` instruction then jumps to the appropriate section - First comparison: Is first number ≥ second number? - **Yes**: Jump to `check13` and compare first vs third - **No**: Continue to compare second vs third - Second comparison depends on the first result: - If first was larger: Compare first vs third - If second was larger: Compare second vs third - The largest value is eventually loaded into the accumulator and output

Labels like `check13`, `show1`, and `show2` mark locations in the code that branch instructions can jump to

## Worked Example A smart coffee machine has a CPU that uses the Little Man Computer instruction set. The machine allows users to select a coffee strength from 1 to 5 (where 1 is weakest and 5 is strongest). Only values between 1 and 5 inclusive are valid. If the user selects a valid strength, the code outputs a 1 to start brewing. If the selection is invalid, the code outputs a 0 to display an error message. The code is as follows: ```assembly INP STA strength LDA strength SUB minStrength BRP checkMax // If strength >= 1, check upper limit LDA invalid BRA finish checkMax LDA maxStrength SUB strength BRP validChoice // If maxStrength - strength >= 0, input is valid LDA invalid BRA finish validChoice LDA valid finish OUT HLT valid DAT 1 invalid DAT 0 minStrength DAT 1 maxStrength DAT 5 strength DAT ``` **a) What is the purpose of the label `checkMax` in the code? Describe its role in determining the validity of the strength selection.** [2] **b) If a user inputs a strength selection of 6, what will be the output? Justify your answer.** [2] **c) If the valid range was changed to allow strengths from 1 to 7, what modification would be needed in the code?** [2] ### Answer: **Example answer that gets full marks:** a) The label `checkMax` identifies the code section that verifies whether the strength selection is less than or equal to the maximum permitted value (5). It's only reached after confirming the input is greater than or equal to the minimum strength (1). If the input passes the minimum check, execution continues from `checkMax` to test against the maximum; otherwise this section is skipped entirely. b) The output will be 0. This occurs because 6 exceeds the maximum allowed strength of 5. After passing the minimum check, the program compares the input against the maximum at `checkMax`. Since `5 - 6 = -1` (negative), the `BRP` condition fails, and the program loads the invalid value (0) before outputting it. c) The data value at the `maxStrength` label should be changed from 5 to 7. This modification allows the program to correctly validate strengths up to and including 7 when testing the user's input against the maximum threshold. ### Acceptable answers you could have given instead: a) Any response explaining that `checkMax` validates whether the input is within the upper bound of the acceptable range should receive marks. b) Any answer stating the output will be 0 because 6 is above the maximum of 5, with appropriate reasoning, should receive marks. c) Any answer indicating the `maxStrength DAT` value needs changing to 7 should receive marks.