CS-150 – Low-Level Programming: Machine & Assembly Language Vocabulary

Vocabulary flashcards summarizing key terms, components, and instructions related to machine language, assembly language, and the Pep/9 virtual computer as presented in the CS-150 lecture notes.

Computer

A programmable electronic device that can store, retrieve, and process data.

Stored-program computer (von Neumann)

Architecture in which both data and the instructions that manipulate them are stored together in memory as bit patterns.

Fetch–Decode–Execute cycle

The repetitive process by which a CPU retrieves an instruction, interprets it, and carries it out.

Abstraction (programming)

Hiding low-level details so programmers can focus on desired functionality; higher-level languages give more abstraction than assembly or machine code.

Machine language

Binary-coded instructions built into a CPU and executed directly by the hardware.

Assembly language

A low-level programming language that uses mnemonic names for machine opcodes; translated to machine code by an assembler.

Assembler

A program that converts assembly language source code into machine-language object code.

Virtual computer

A hypothetical machine used for teaching that models key features of real hardware.

Pep/9

A 16-bit virtual computer (designed by Stanley Warford) with 40 machine instructions, used in CS-150 to illustrate low-level programming concepts.

Program Counter (PC)

Pep/9 register holding the address of the next instruction to execute.

Instruction Register (IR)

Pep/9 register that temporarily stores the current instruction’s opcode and operand during execution.

Accumulator (A)

Pep/9 16-bit register used to hold data and arithmetic/logic results.

Memory-mapped I/O

Technique where specific memory addresses are reserved for input/output devices instead of ordinary RAM.

Pep/9 input device address

Memory location FC15 (hex) that supplies one input byte when read.

Pep/9 output device address

Memory location FC16 (hex) that outputs one byte when written.

Pep/9 instruction format

Consists of an opcode (4 bits), addressing-mode/flag bits, a register specifier or 5th opcode bit, and an optional 16-bit operand.

Opcode

Portion of an instruction that specifies which operation the CPU should perform.

Addressing mode

Field in an instruction that tells the CPU how to interpret the operand (e.g., as a value, an address, etc.).

Immediate addressing mode

Addressing mode 000 in Pep/9 where the operand itself is the data to use.

Direct addressing mode

Addressing mode 001 in Pep/9 where the operand gives the memory address of the data.

Pseudo-op

Directive to the assembler (not an executable CPU instruction) that affects assembly or reserves memory.

.END

Pep/9 pseudo-op that marks the end of an assembly-language program.

.ASCII

Pseudo-op that stores a string of ASCII characters (automatically appends terminating 00H).

.WORD

Pseudo-op reserving one 16-bit word of memory and optionally initializing it.

.BLOCK

Pseudo-op reserving a specified number of bytes in memory without initialization.

Label (assembly)

User-defined name placed before an instruction or data location, used as a symbolic address in operands or branches.

BR

Pep/9 unconditional branch instruction; sets PC to the specified address.

BRLT

Pep/9 branch that executes if the Negative flag is set (accumulator < 0).

LDBA

Instruction that loads a byte into the accumulator (form chosen by addressing mode).

STBA

Instruction that stores the low byte of the accumulator to a memory location or I/O device.

DECI

Pep/9 instruction that reads a signed decimal number from input and stores it at a memory address.

DECO

Pep/9 instruction that outputs a signed decimal number, either immediate or from memory.

STRO

Instruction that outputs a null-terminated ASCII string from memory.

CPWA

Pep/9 instruction that compares a memory word with the accumulator, setting condition flags.

STOP

Opcode 0000 in Pep/9; halts program execution.