COMPSCI 110 Introduction to Computer Systems

How COMPSCI 110 is assessed

What COMPSCI 110 covers

The whole course → one exam-ready map. COMPSCI110 is assessed on a 50% final exam (a digital Inspera exam sat on a computer via the Inspera Integrity Browser, 36 questions for 50 marks) plus a 20% mid-semester test and 30% of practical coursework (assignments, essays and tutorials). The final exam covers Modules 1–4 and 6–11; Module 5 (algorithms & pseudocode) is examined only in the mid-semester test.

Each chapter below links to its free guide.

The course prescription is exactly that journey: the encoding of data and instructions, hardware, low-level programming, operating systems, applications and communications.

It builds bottom-up: how numbers, text and media become binary (Module 1); the logic gates and circuits that compute (Module 2); the von Neumann machine that runs them (Module 3); its assembly language (Module 4); algorithms and pseudocode (Module 5, mid-semester test only); then the systems layer — computer networks (Module 6), compilers (Module 7), operating systems (Module 8), security and cryptography (Module 9), Turing machines and computability (Module 10) and artificial intelligence (Module 11).

Assessment is split into a theory grouping and a practical grouping: theory is the 20% mid-semester test plus the 50% final exam — an in-person, invigilated digital exam sat on a computer via the Inspera Integrity Browser (IIB, Mode D), 36 questions for 50 marks, covering Modules 1–4 and 6–11. Practical is the assignments (20%), essays (8%) and tutorials (2%), all in the AI-permitted coursework lane.

To pass you must reach at least 50% overall AND pass each grouping separately. Confirm the exact exam date on Canvas and the University of Auckland Semester-2 2026 exam timetable.

COMPSCI 110 cheatsheet for the final exam

AskSia publishes a free COMPSCI 110 cheatsheet for the final exam, an A4 cheat sheet that follows the official permitted-materials rule for this assessment and condenses the topics in this guide. Open the COMPSCI 110 cheatsheet.

Worked example · free

Subtraction through the adder — 6 − 2 in 4-bit two's complement

Key terms

Two's complement

The standard signed-integer representation: a negative value is formed by inverting every bit of the positive and adding 1. It has one zero and an asymmetric n-bit range −2ⁿ⁻¹ … 2ⁿ⁻¹−1 (e.g. 8-bit = −128 … +127), and it lets subtraction reuse the adder. Sign-magnitude and one's complement, by contrast, have two zeros and the symmetric range ±(2ⁿ⁻¹−1).

Logic gate & truth table

The primitive circuit elements — AND (a·b), OR (a+b), NOT (Ā), NAND and NOR — each defined by a truth table listing the output for every input combination. NAND and NOR are each functionally complete (any circuit can be built from one of them alone). A combinational circuit's output depends only on the current inputs (no stored state).

Von Neumann architecture

The stored-program model: instructions and data share one memory, the machine has four subsystems (Memory, Input/Output, ALU, Control Unit — the ALU and Control Unit together being the CPU), and instructions execute sequentially (the 'von Neumann bottleneck'). The control unit uses special registers PC, IR, MAR and MDR to run the fetch–decode–execute cycle.

Opcode & instruction set

An opcode is the unsigned integer that names a machine operation; an instruction packs an opcode with its address field(s). The textbook machine uses a 16-instruction set (4-bit opcode + 12-bit address = a 16-bit instruction), from LOAD (0000) through HALT (1111). Only one arithmetic register R exists, so ADD X means R + CON(X) → R.

Packet switching

The Internet's way of sharing a link: data is split into packets that share link capacity dynamically, with no reserved rate (unlike circuit switching, which reserves a fixed guaranteed rate for a call). A packet arriving at a busy link waits in the router's output buffer; if no buffer is free it is dropped (lost).

Turing machine

A minimal model of any computing agent: a tape infinite in both directions (holding input, output and memory), a finite set of states, and instructions written as 5-tuples (i, j, k, s, direction) — 'in state i reading symbol j, write k, go to state s, move left or right'. It halts when it reaches a (state, symbol) pair with no matching rule; the Church–Turing thesis holds that it can compute anything computable.

COMPSCI 110 FAQ

Questions students ask in each COMPSCI 110 chapter

What's the difference between one's and two's complement?

Both put the sign in the leading bit and both negate by inverting bits, but two's complement adds 1 after inverting. That single +1 removes the duplicate zero (two's complement has one zero, the others have +0 and −0) and makes the range asymmetric: n-bit two's complement runs −2ⁿ⁻¹ … 2ⁿ⁻¹−1, while one's complement and sign-magnitude run ±(2ⁿ⁻¹−1). Two's complement wins in practice because subtraction can reuse the adder — you never need separate subtractor hardware. Chapter 01 · Data as Binary

What does it mean that NAND (or NOR) is 'functionally complete'?

It means you can build any digital circuit using only that one gate type. If you tie both inputs of a NAND together it behaves as a NOT; with NOT plus NAND you can make AND and OR, and from AND, OR and NOT you can implement any truth table. NOR has the same property. That is a genuinely useful fact in hardware — a fabrication process only has to make one kind of gate really well. Chapter 02 · Boolean Logic & Digital Circuits

What are the four subsystems of the von Neumann model?

Memory (stores both instructions and data), Input/Output (moves data in and out), the Arithmetic-Logic Unit (does the computing) and the Control Unit (sequences everything). The ALU and Control Unit together are what we call the CPU. The model's other two defining features are the stored-program concept and sequential execution of instructions. Chapter 03 · Computer Organisation

How do I translate an assembly instruction to machine code?

Split the instruction into its opcode and its operand. Look the opcode up in Figure 6.5 to get its 4-bit code, encode the operand's address as a 12-bit binary number, and concatenate them into a 16-bit word (opcode in the top 4 bits, address in the low 12). You can then read the 16 bits as four hex nibbles. Instructions with no operand — HALT and the .BEGIN/.END/.DATA directives — leave the address field as zeros. Chapter 04 · Assembly & Machine Code

Is Module 5 on the final exam?

No. Algorithms & pseudocode (Module 5) is assessed only in the mid-semester test, not on the final exam — the final's per-module breakdown covers Modules 1–4 and 6–11 and omits Module 5 entirely. So study it fully for the test, but during final-exam revision you can safely spend that time on the heavier exam modules such as Operating Systems and Compilers. Always confirm the current split on Canvas. Chapter 05 · Algorithms & Pseudocode

What are the four sources of packet delay?

Processing delay (the router checks the packet and picks an output link — usually sub-millisecond), queuing delay (waiting behind other packets, which grows with congestion), transmission delay d_trans = L/R (pushing the bits onto the link) and propagation delay d_prop = d/s (the bits travelling the link's length). Their sum is the nodal delay at one hop; end-to-end delay adds up the nodal delays along the path. Chapter 06 · Computer Networks

What are the four phases of a compiler?

Lexical analysis (the scanner turns characters into tokens), parsing (checks the tokens against the grammar and builds a parse tree), semantic analysis & code generation (attaches meaning and emits machine instructions) and code optimisation (improves the result's time or space). The first two deal with form, the third with meaning and translation, and the fourth with efficiency. Chapter 07 · Compilers

What's the difference between FCFS and Round-Robin scheduling?

FCFS runs each process to completion in arrival order — no interruptions, so a long early job blocks everything behind it. Round-Robin adds preemption: each process gets at most a fixed time slice, then goes to the back of the ready queue if it isn't done, so the CPU rotates among all ready processes. Round-Robin is more responsive for interactive work; FCFS is simpler but can make short jobs wait a long time. Chapter 08 · Operating Systems

What's the difference between symmetric and asymmetric encryption?

Symmetric encryption uses one shared secret key for both encryption and decryption — fast, but you must somehow deliver that key securely (the key-distribution problem). Asymmetric (public-key) encryption uses a key pair: the public key encrypts and can be published, while only the private key decrypts. That neatly solves key distribution, at the cost of being slower — which is why real systems often use public-key crypto to exchange a symmetric key and then switch to the faster symmetric cipher. Chapter 09 · Security & Cryptography

What are the parts of a Turing machine?

Three things: a tape that is infinite in both directions (each cell holds one symbol and the tape doubles as input, output and memory), a finite set of states numbered 1…k, and a finite set of instructions written as 5-tuples. A read/write head sits over one cell; the instructions tell it what to write, which state to move to, and whether to step left or right. That minimal setup is enough to model any computation. Chapter 10 · Turing Machines & Computability

What is the Turing test?

It's Alan Turing's proposal for deciding whether a machine can 'think', framed as an imitation game: a human judge converses by text with a hidden machine and a hidden human and tries to tell them apart. If the judge can't reliably identify the machine, it passes. The key feature is that it judges behaviour (conversation) rather than internal mechanism — a machine passes by acting indistinguishably from a person, regardless of how it does so. Chapter 11 · Artificial Intelligence

How to study for the exam

Treat COMPSCI110 as eleven small skills, not one big idea, and drill the mechanical ones by hand until they are automatic — that is where the marks are. From Module 1, practise base conversions and two's complement on paper (the invert-then-add-1 rule, and the asymmetric −2ⁿ⁻¹ … 2ⁿ⁻¹−1 range) because two's complement is the single biggest mark-loser.

Keep a one-page reference of the things that must be exact: the AND/OR/NAND/NOR truth tables, the 16-instruction opcode table, the fetch order PC→MAR / FETCH / MDR→IR / PC+1, d_trans = L/R, the compiler token classes, and the CPU-efficiency formula slice/(slice+switch).

For the 20% mid-semester test (restricted book, one A4 sheet, one hour, MCQ), remember it is the ONLY place Module 5 pseudocode is examined — rehearse trace tables for sequence/selection/iteration. Then weight your exam revision by marks: give Operating Systems (8) and Compilers (7) the most reps, and don't neglect the 6-mark Security and Turing modules.

Sit the released past papers on the practice system in timed conditions, and because both the test and the exam are on Inspera, get comfortable with the digital question types (matching, inline choice, multiple response).

Exam week, reduce everything to the reference sheet and re-derive one worked example per module from a blank setup — if you can reproduce the two's-complement subtraction, a sum-of-products circuit, an assembly desk-check and a Round-Robin schedule cold, you are ready.

Your AI Computer Science tutor for COMPSCI 110

Stuck on a hard COMPSCI 110 question? Sia is AskSia’s AI Computer Science tutor — ask any COMPSCI 110 Introduction to Computer Systems question and get a clear, step-by-step explanation grounded in how the course is actually taught and assessed. Read this whole study guide free, then take your hardest questions to Sia.