COMPSCI130: pass the exams, not just read the notes
Your complete guide to University of Auckland's introduction to software fundamentals course. See where the marks are, work real practice questions, and study with an AI tutor that knows COMPSCI130.
Sia generates COMPSCI130 practice questions, walks through python revision and software maintenance step by step, and quizzes you on the material the exam weights most heavily.
Find what is wrong
The values 8, 3, 10, 1, 6 are inserted in that order into an empty binary min-heap. After all insertions, what is the array representation of the heap?
Insert 8: [8]. Insert 3 at the end and bubble up past 8: [3, 8]. Insert 10 at the end; 10 is larger than its parent 3, so it stays: [3, 8, 10].
Insert 6 at index 4. Its parent is index 1 (value 3); 6 is larger, so it stays: [1, 3, 10, 8, 6].
Check the heap property: every parent is no larger than its children (1 under 3 and 10; 3 under 8 and 6). Option B is the sorted array, which a heap is not.
The trap: Expecting the heap array to be sorted. A heap only guarantees that each parent is at most its children; siblings and cousins are unordered, so [1, 3, 10, 8, 6] is a valid heap even though 10 sits before 8. classic slip!
One exam decides 50% of your grade. Test + Exam: at least 35/70 required. This whole page is built around that.
Overview
What COMPSCI130 is, and where it sits
COMPSCI 130 is the University of Auckland's entry course to Computer Science for students who already program. The catalogue frames it around the quality of software processes and products: reading, writing and documenting code, decomposing problems, testing, debugging, recursion and error handling, then the efficient organisation of data — sorting, searching, and implementing the standard abstract data types.
The published twelve topics are the syllabus: Python revision; software maintenance, modularity, testing and exceptions; complexity and Big O; sorting and searching; abstraction, classes and ADTs; stacks and queues; recursion; linked lists; trees; binary search trees; hashing; and priority queues and heaps. Nine learning outcomes map onto them, from decomposing a problem into functions to implementing ADTs with arrays, linked lists, hash tables and trees.
Assessment is labs and assignments 30%, a mid-semester CodeRunner test 20% and a CodeRunner exam 50%. Passing needs three things at once: 50% overall, at least 35 of the 70 marks across test and exam, and at least 15 of the 30 practical marks. The course runs in Summer Semester, Semester One and Semester Two, with one lecture and two two-hour labs a week.
Always treat your own course outline and the exam timetable as authoritative.
Difficulty & time commitment
Is COMPSCI130 hard, and how much time does it take?
COMPSCI130 is manageable if you keep a weekly rhythm and treat the back half as the main event. The pattern is consistent: it starts gently and steepens, and the heaviest assessment is the part that separates grades.
The difficulty curve and the assessment weighting point the same way: the back half is harder and worth more. Front-loading effort there is the highest-return decision in the course.
Is this course for you
Who tends to do well, and who tends to struggle
You will likely do well if
- You already program comfortably and want to understand what your data structures cost.
- You can draw a linked list, a tree and a heap on paper and then implement what you drew.
- You write tests before you trust code, because testing is a graded outcome.
- You keep the practical component above 15/30 from week one rather than chasing it in week twelve.
You may struggle if
- Your only programming experience is following tutorials; this course expects independent problem solving.
- You skip labs in the second half when trees and hashing arrive — the practical threshold is 15/30.
- You memorise Big O tables without being able to derive a complexity from code.
- You treat recursion as a trick rather than a technique; it underpins trees, BSTs and heaps.
- Implement every ADT twice: once with a Python list, once with nodes and references, and compare the complexity.
- For each sort and search, write the loop invariant in one sentence before coding it.
- Trace recursive functions with an explicit call stack on paper until the base case is instinctive.
- Rehearse the exam's two halves separately: timed CodeRunner coding, and written explanations of how a structure sits in memory.
Syllabus
The 12 topics, topic by topic
The exam-weight marker on each topic shows where the marks concentrate. The amber topics carry the highest exam weight.
T1 · Python revision
Topic 1The syntax overview the course opens with; assumes you can already program in some language.
T2 · Software maintenance, modularity, testing and exceptions
Topic 2; learning outcomes 4 and 6Writing maintainable code, decomposing into modules, unit tests and handling unexpected errors.
T3 · Complexity of programs and Big O
Topic 3Counting operations and classifying growth rates.
T4 · Sorting and searching
Topic 4Linear and binary search; elementary and efficient sorts and their complexity.
T5 · Abstraction, classes and abstract data types
Topic 5; learning outcome 8Defining classes and separating an ADT's interface from its implementation.
T6 · Stacks and queues
Topic 6LIFO and FIFO structures, their operations and applications.
T7 · Recursion
Topic 7; learning outcome 3Base cases, recursive cases and the call stack; recursive versions of iterative algorithms.
T8 · Linked lists
Topic 8; learning outcome 9Nodes and references; implementing list operations without arrays.
T9 · Trees
Topic 9Tree terminology, representation and traversal.
T10 · Binary search trees
Topic 10Insertion, search and deletion; ordering property and its consequences.
T11 · Hashing
Topic 11Hash functions, collisions and hash tables as dictionary implementations.
T12 · Priority queues and heaps
Topic 12The binary heap and heap-ordered insertion and removal.
How it's assessed
Assessment structure
| Component | Weight | Format & timing |
|---|---|---|
| Labs & Assignments | 30% | Weekly labs released two days before the lab day, due 11:59pm on the lab day, plus assignments. Weekly. Practical component: at least 15/30 required. |
| Test | 20% | One mid-semester CodeRunner test assessing programming ability, evening or Saturday. Mid-semester. Test + Exam: at least 35/70 required. |
| Exam | 50% | CodeRunner examination assessing data-structure concepts and programming ability. Examination period. Test + Exam: at least 35/70 required. |
- Three thresholds, all required: at least 50% overall; at least 35 out of 70 across the test and exam; and at least 15 out of 30 across labs and assignments. A 50% total is not enough if either component is under its line.
- The mid-semester test (20%) assesses programming ability on CodeRunner; the exam (50%) adds understanding of data-structure concepts to programming. Preparation therefore has two halves: executing code under time, and explaining how structures are modelled in memory.
This is an exam-cram course. With the exams at 50% of the grade and the exam alone at 50%, your result is overwhelmingly decided by how well you perform under time pressure. Test + Exam: at least 35/70 required.
Final exam timing: During the examination period. Confirm the exact date and venue on your exam timetable.
How to actually pass it
A weekly rhythm, two checklists, and the traps to avoid
The course rewards consistency over cramming, and practice over re-reading. Here is the loop that works, then what to have nailed before each exam.
The weekly loop
Before the mid-semester checklist
- Decompose a problem into functions and compose them.
- Write tests and use exceptions to handle unexpected input.
- Derive the Big O of a short program.
- Implement and compare sorting and searching algorithms.
Before the final heaviest topics
- Implement stacks, queues and linked lists from nodes.
- Write and trace recursive algorithms.
- Insert, search and delete in a binary search tree.
- Explain hashing and implement priority-queue operations on a binary heap.
The mistakes that cost marks
Losing the reference in a linked list. Reassigning next before saving the old link orphans the rest of the list. Draw it first.
No base case. A recursive function without a reachable base case recurses forever; the test will check yours.
Passing the total but failing a threshold. Fifty percent overall is not a pass here; both the 35/70 and 15/30 lines must be cleared.
Formula & concept sheet
The vocabulary and formulas you must own
- Abstract data type
- A specification of operations and behaviour independent of the data structure that implements it.
- Big O
- An upper bound on how running time grows with input size, ignoring constants.
- Binary search
- Halving a sorted range at each step to find a target in logarithmic time.
- Recursion
- A function that calls itself on a smaller instance until a base case stops it.
- Stack
- A last-in, first-out structure with push and pop.
- Queue
- A first-in, first-out structure with enqueue and dequeue.
- Linked list
- A chain of nodes each holding a value and a reference to the next node.
- Binary search tree
- A binary tree where every left descendant is smaller and every right descendant larger than its node.
- Hash table
- A structure that maps keys to positions via a hash function, with a policy for collisions.
- Binary heap
- A complete binary tree that keeps the smallest (or largest) element at the root, backing a priority queue.
- Exception
- A signalled error condition that can be caught and handled instead of crashing the program.
Set texts
The prescribed reading
The syllabus references map straight onto these.
COMPSCI 130 online text
.
Where it fits
Prerequisites, related courses & why it matters
Prerequisite: COMPSCI 101, or a B+ or higher in ENGGEN 131, or NCEA Level 3 Digital Technologies and Programming 91906 or 91637. Restriction: COMPSCI 105 and COMPSCI 107. COMPSCI 130 is 15 points at Stage 1, offered in Summer Semester, Semester One and Semester Two at the City campus.
Your COMPSCI130 study toolkit
Study the course with Sia, not just read about it
Each tool already knows COMPSCI130: your syllabus, your texts, and where the marks are. Grouped by how you study, from first contact to exam week.
FAQ
Frequently asked questions
Is COMPSCI 130 hard?
It rates moderate on the six-factor rubric, but at the hard end for a Stage 1 course: the data-structures content is real, 70% of the grade is invigilated CodeRunner work, and three separate pass thresholds must all be met.
What is the assessment breakdown?
Labs and assignments 30%, mid-semester test 20%, exam 50%, as published on the catalogue page.
What are the pass rules?
At least 50% overall, at least 35/70 across the test and exam combined, and at least 15/30 across labs and assignments. All three must be satisfied.
Do I need COMPSCI 101 first?
COMPSCI 101 is one route. The catalogue also admits a B+ or higher in ENGGEN 131, or NCEA Level 3 Digital Technologies and Programming achievement standards 91906 or 91637.
Is it taught in Python?
Yes. The course assumes you can program but not in any particular language, and opens with a short Python syntax overview.
When are labs due?
Per the catalogue, labs are released two days before the lab day and are due at 11:59pm New Zealand time on the lab day, a change made in response to student feedback.
Study COMPSCI130 with Sia
Work through python revision, software maintenance, complexity of programs and the rest of the course with a tutor that knows it and quizzes you on the topics the assessments weight most heavily.
Start studying with Sia
