First-Year CS Exam Revision
Walk into my first-year CS exams having practised the actual questions under timed conditions, not having re-read the slides.
This is a starting point — make it yours
Use this goal to build your own roadmap — tailored to you and starting fresh.
Week 1: find out where you stand
Revision without a diagnosis is just re-reading the topics you already like. This week is uncomfortable on purpose.
Sit one past paper cold, before revising anything~4h
Full time limit, no notes, no pausing. It will go badly and that is the point — it tells you where the marks actually are and what the questions really look like.
Done when: one full paper is attempted under exam conditions and marked honestly against the scheme.
Map the syllabus against the marks you lost~2h
List every examinable topic, then rank by marks lost in the diagnostic weighted by how often the topic appears across past papers. A topic worth 25% that you scored 30% on beats a topic worth 5% that you failed.
Done when: you have a ranked list and the top three are unambiguous.
Collect every past paper and mark scheme you can get~1h
Five years if available, plus any specimen papers. Mark schemes matter as much as the questions — they show exactly what the examiner rewards, which is often less than you'd assume.
Done when: the papers are in one folder and you know how many you have.
Book the revision into the calendar, backwards from the exam~1h
Work back from the exam date, reserving the final 20% of the time for full papers and weak areas. Everything else fits before that.
Done when: the schedule exists, with the last-fifth reserved and nothing new scheduled inside it.
Weeks 2-4: the heavy topics
Data structures and algorithms are usually the largest and most transferable part of the marks. Do them first and while you are freshest.
Write out every core data structure's operations and complexities from memory~5h
Array, linked list, stack, queue, hash table, BST, heap, graph. Insert, delete, search, and their best/average/worst cases. Closed book, then check.
Done when: you can reproduce the full table with no more than two errors.
Hand-trace the standard algorithms on paper~8h
Quicksort, mergesort, BFS, DFS, Dijkstra, binary search. Exams ask you to show intermediate states, and running code teaches you nothing about that.
Done when: you can trace each on a small input and produce the correct intermediate states without checking.
Do every past-paper question on complexity analysis~6h
Big-O of a given loop nest, comparing two approaches, justifying a bound. These questions repeat across years with small variations more than almost any other topic.
Done when: you have done every complexity question from the papers you collected and marked them.
Timed practice: one algorithms section under exam conditions~3h
Just that section, strictly timed. Speed is usually the real problem rather than knowledge, and untimed practice hides it completely.
Done when: the section is completed inside its time allocation and marked.
Weeks 5-6: architecture, discrete maths and databases
Smaller topics, but they are where easy marks get dropped through unfamiliarity rather than difficulty.
Drill number representation and logic until it's automatic~5h
Two's complement, floating point, binary and hex conversion, boolean simplification, Karnaugh maps. These are pure-technique marks — reliable if practised, embarrassing if not.
Done when: you can do twenty conversions in ten minutes with no errors.
Practise proofs by induction and set/relation questions~6h
Discrete maths marks are lost on presentation as much as on reasoning. Write out the base case, the hypothesis and the step explicitly every time, because the mark scheme awards them separately.
Done when: you can produce a full induction proof in the expected structure without prompting.
Normalise ten relations to 3NF and write the SQL from memory~6h
1NF through 3NF with the reasoning written out, then joins, GROUP BY and subqueries by hand on paper. Exams want the justification, not just the final schema.
Done when: ten relations are normalised correctly with reasons, and you can write a three-table join without a reference.
Make a one-page sheet per topic and test yourself off it~5h
One side of A4, from memory, then corrected against your notes. The making is the revision; the sheet is a by-product. Use them for five-minute recall sessions afterwards.
Done when: one sheet exists per examinable topic and each was written from memory first.
Weeks 7-8: full papers only
No new material from here. Everything is full papers, marking, and attacking whatever they expose.
Sit three full past papers under exam conditions~12h
Correct time, no notes, no phone, ideally the same time of day as the real exam. Mark each against the scheme immediately, being strict.
Done when: three papers are done, marked, and the scores are written down.
Spend a session on each recurring mistake~6h
Go through the marked papers and group the losses. Almost everyone finds two or three repeating causes — misreading questions, running out of time, one weak topic. Fix them individually.
Done when: each recurring cause has had a dedicated session and a re-test showing improvement.
Rehearse the exam-day timing plan~2h
Decide in advance how many minutes each question gets, what you do when you're stuck, and in which order you'll answer. Panic is a time-management failure more often than a knowledge one.
Done when: you have a written plan and used it in a full paper without overrunning.
Stop early the day before~2h
Light recall from your one-page sheets in the morning, nothing after lunch. Cramming the night before reliably costs more in fatigue than it gains in recall.
Done when: the day before is spent as planned rather than in a panic.