How to study computer science at university: a practical guide

By oosync editorial team · Updated 2026-10-14 · 5 min read

Computer science combines two quite different kinds of learning. Programming is a practical skill, built by writing, breaking and fixing a lot of code. Theory, including algorithms, data structures, complexity, logic and discrete maths, is conceptual and often examined on paper. Students who are strong at one often neglect the other.

This guide covers what assessments in computer science usually look like, how to use lectures and readings, the techniques that suit both programming and theory, a weekly routine and an exam-season plan.

What computer science assessments usually look like

Common formats include:

• Programming assignments, often marked partly by automated tests and partly by hand for design, style and documentation.
• Lab exercises, shorter weekly tasks that build skills step by step.
• Written exams, which may ask you to trace code, write short functions by hand, apply algorithms to examples, analyse complexity, prove properties or explain concepts.
• Group software projects, with reports, presentations and code reviews.
• Vivas or code interviews in some modules, where you explain your submitted code.
• Final-year projects or dissertations.

Written exams surprise many students. Without a compiler, autocomplete or the ability to run code, you need to be able to reason about code in your head and on paper.

What to do with lectures and readings

Lectures and slides

Computer science slides often include code snippets and diagrams of data structures. After each lecture:

1. Rebuild your notes in your own words: what each concept is, why it matters and when you would use it.
2. Type out and run any code from the lecture, then change it and predict what will happen before running it again.
3. Write two or three questions: "What is the time complexity of this operation, and why?" or "When would you choose a hash table over a balanced tree?"

Textbooks and documentation

Use textbooks for theory and for exercises. Use official documentation for languages and libraries, and get used to reading it, because it is a core professional skill. When reading about an algorithm, work through it by hand on a small example before moving on.

Techniques that suit computer science

1. Write code from scratch

Following a tutorial or reading solution code produces a strong sense of understanding that often disappears the moment you face a blank editor. The fix is retrieval: after studying an example, close it and write the program yourself from scratch. Then extend it to do something new. Decades of research on the testing effect suggest that producing something from memory strengthens learning far more than reviewing it.

2. Trace code by hand

Take a short function and trace it on paper: write down the value of each variable after each line, for a small input. This is exactly what many written exams ask you to do, and it builds the mental model you need for debugging. Practise with loops, recursion and pointer or reference manipulation, where errors are most common.

3. Explain your code

Explaining code out loud, line by line, to a classmate or even an inanimate object (programmers call this rubber duck debugging) exposes gaps in understanding quickly. This is a form of self-explanation, which tends to help learners understand reasoning rather than memorise steps. It is also excellent preparation for vivas and code reviews.

4. Flashcards for theory

Some computer science content is worth committing to memory with spaced repetition: time complexities of common operations, properties of data structures, definitions in logic and formal languages, and the steps of key algorithms. Keep cards focused and include why:

Q: Why is searching a balanced binary search tree O(log n) in the worst case? A: Each comparison discards about half the remaining nodes, and a balanced tree's height is proportional to log n.

5. Interleave problem types

Once you have learned several algorithms or techniques, practise mixed problems where you must decide which approach fits: sorting, searching, dynamic programming, graph traversal, greedy methods. Choosing the technique is often the hardest part of an exam or interview problem, and mixed practice trains it.

6. Small projects of your own

Build small things that interest you, using concepts from your modules. A project with no answer key forces you to read documentation, design solutions and debug, which tutorials cannot give you.

Academic integrity with code

Programming modules often have specific rules about collaboration, code reuse and AI tools. These rules vary widely, so read them for every module and assignment.

• Discussing ideas with classmates is often allowed. Sharing or copying code for assessed work usually is not.
• Code from online sources may need to be cited, if it is allowed at all.
• AI coding assistants may be permitted, permitted with acknowledgement or banned. Follow the specific rules.
• Similarity-checking tools for code are common, and simply renaming variables does not disguise copied work.

Whatever the rules, make sure you understand every line you submit. If you cannot explain your code, it is not really your work, and a viva or exam will show it. Our guide on using AI for study without breaking academic rules covers this in more depth, in the guides section.

A weekly routine during term

Start programming assignments as soon as they are released. Debugging takes longer than you expect, and starting early gives you time to ask for help in labs.

Exam-season plan

Four weeks out: gather past papers and check the exam format. List the question types: tracing, writing code by hand, algorithm application, complexity analysis, proofs, short explanations. Audit your confidence in each.

Three weeks out: work on weak areas. Trace code daily. Write short functions by hand on paper, not in an editor, so you get used to working without tools.

Two weeks out: do timed past-paper questions, mixing topics. Mark them carefully and keep an error log: syntax errors, logic errors, off-by-one errors, wrong complexity, incomplete proofs.

Final week: full timed papers, then targeted practice on recurring error types. Keep flashcard reviews going and rest before the exam.

Common mistakes

• Tutorial hell. Watching and following along without ever building something independently.
• Copying code without understanding it, from classmates, forums or AI tools.
• Never practising on paper before a written exam.
• Ignoring error messages. Reading them carefully is often the fastest route to a fix.
• Leaving assignments late. Code rarely works first time.
• Neglecting theory and maths modules because programming feels more practical.

Using tools sensibly

Theory-heavy modules often come with long PDFs of notes and slide decks. In oosync you can upload them, ask questions answered from your own materials with citations to the passages, and generate flashcards and practice exams from them, with multiple-choice questions marked automatically. That is useful for the theory side of the degree. For programming, nothing replaces writing code yourself.

Computer science study checklist

1. Run and modify all lecture code.
2. Rewrite examples from scratch without notes.
3. Trace code by hand regularly.
4. Explain your code line by line.
5. Use spaced flashcards for complexities, definitions and algorithm steps.
6. Practise mixed problems where you choose the technique.
7. Build small projects of your own.
8. Read and follow the integrity rules for every assignment.
9. Practise writing code on paper before written exams.