COMPSCI110 · Introduction to Computer Systems
The Complete Exam Bible · S2 2026Introduction to Computer Systems
COMPSCI110 Introduction to Computer Systems is the University of Auckland's Stage I tour through every layer of a modern computer — 15 points, and compulsory for the Computer Science major (you cannot take it with or after COMPSCI210). 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.
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.
How COMPSCI 110 is assessed
| Component | Weight | Format |
|---|---|---|
| Final Exam | 50% | UoA S2 exam period; Inspera digital exam (IIB, Mode D), 36 questions / 50 marks; covers Modules 1-4, 6-11 |
| Mid-Semester Test | 20% | In-semester; covers the earlier modules including Module 5 (algorithms & pseudocode) |
| Assignments | 20% | Programming/analysis assignments across the course (AI-permitted 'uncontrolled' lane) |
| Essays | 8% | Short written essays (AI-permitted lane) |
| Tutorials | 2% | Weekly group-work tutorials |
Subtraction through the adder — 6 − 2 in 4-bit two's complement
- +1Represent both operands in 4-bit two's complement. +6 = 0110₂ and +2 = 0010₂ (both positive, so the sign bit is 0 and the pattern is the plain binary value).
- +1Turn the subtraction into an addition. a − b = a + (−b). To negate b in two's complement, invert every bit of b (one's complement) and add 1 — the circuit supplies that +1 as a carry-in of 1 to the least-significant bit. Invert 0010 → 1101.
- +1Add a + inv(b) + carry-in: 0110 + 1101 + 1. First 0110 + 1101 = 10011₂, then + 1 = 10100₂ (a 5-bit result with a carry out of the most-significant bit).
- +1Discard the carry out of the sign bit (two's-complement / modular arithmetic ignores it). The 4-bit answer is 0100₂ = +4. Check: 6 − 2 = 4. ✓
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
Is COMPSCI110 hard?
It is broad rather than deep — eleven modules that each speak a different dialect (binary arithmetic, logic circuits, assembly, networks, compilers, cryptography, Turing machines), so the difficulty is breadth and precision, not abstraction. The reliable mark-losers are the exact ones: two's-complement ranges, gate truth tables, the opcode table, the fetch order and d_trans = L/R. Students who drill the small mechanical procedures until they are automatic — and keep up with the weekly rhythm rather than cramming — generally find it very manageable. It is a Stage I course pitched at first-years with no prior assumed.
Can AI help me with COMPSCI110?
Yes — for learning, not for doing graded work. Sia is an AI tutor trained on how COMPSCI110 is actually taught and assessed at the University of Auckland: it explains any step by step (a two's-complement conversion, a sum-of-products circuit, a Round-Robin schedule, a compiler tokenisation), checks your reasoning and quizzes you on fresh numbers. One hard rule: the final exam and mid-semester test are in the controlled, no-AI lane, and University of Auckland academic-integrity rules apply — use AI to prepare before test day, never to produce answers for an assessment. Sia will not sit assessments for you.
Where can I find past exam papers / practice for COMPSCI110?
The course itself is the primary source: past mid-semester test papers (multiple years, including Summer/S1/S2 offerings) and exam-revision resources are posted on Canvas, and there is unlimited practice on the course's automated practice system. This guide adds worked examples for every module — two's complement, gate circuits, assembly desk-checks, Round-Robin scheduling, block ciphers, Turing traces — solved line by line, and you can ask Sia to generate more questions in the same pattern for any chapter. Always confirm which past papers match the current syllabus on Canvas.
How is COMPSCI110 assessed, and what is the pass hurdle?
Five components in two groupings. Theory = the 20% mid-semester test + the 50% final exam (an Inspera digital exam, IIB Mode D, 36 questions / 50 marks). Practical = assignments 20% + essays 8% + tutorials 2%. To pass you must reach at least 50% overall AND pass BOTH groupings separately: the theory grouping needs at least 35 of 70 (50%) and the practical grouping at least 15 of 30 (50%). Missing either hurdle fails the course even if your overall mark clears 50% — confirm the current rules on Canvas and the course outline.
What does the final exam cover, and is Module 5 on it?
The final exam covers Modules 1–4 and 6–11. Module 5 (algorithms & pseudocode) is examined only in the mid-semester test — it is NOT on the final exam, a split worth knowing so you spend revision time where the marks are. The final's per-module weighting leans toward the systems modules: Operating Systems (8 marks) and Compilers (7 marks) are the heaviest, followed by Security and Turing Machines (6 each), Networks and AI (5 each), then Binary (4) and the Logic/Organisation/Assembly modules (3 each). Confirm the exact date on Canvas and the UoA Semester-2 exam timetable.
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.
