Skip to content

Computing | Computer Science - Wyatt's Notes

Undergraduate computing and systems.
Browse Notes

Site Overview

This site contains structured notes and practice problems covering the core curriculum of an undergraduate computer science programme. The material is organised into three broad sections, each accessible from the sidebar navigation.

Sections

Algorithms and Data Structures covers fundamental algorithm design paradigms (divide and conquer, dynamic programming, greedy algorithms), complexity analysis, and the properties of standard data structures (trees, hash tables, heaps, and graph representations).

  • Algorithm design (divide and conquer, DP, greedy, backtracking)
  • Complexity theory (P, NP, reductions, approximation)
  • Data structures (hash tables, trees, heaps, amortised analysis)
  • Combined algorithms and data structures practice

Systems addresses distributed systems (consensus, replication, fault tolerance) and computer networking (protocol layers, transport, routing).

  • Distributed systems (CAP theorem, Paxos, Raft, logical clocks)
  • Networking (OSI model, TCP/IP, DNS, HTTP, error detection)

Theory provides the formal foundations: automata and formal languages, compiler construction (parsing, code generation, optimisation), and cryptographic primitives.

  • Automata and formal languages (finite automata, CFGs, Turing machines)
  • Compilers (lexical analysis, parsing, IR, code generation)
  • Cryptography (AES, RSA, hash functions, key exchange)

Use the sidebar on the left to browse by section. Each section contains explanatory notes followed by interactive practice problems. Practice problems use a multiple-choice format; select an answer to view the explanation and compare your reasoning.

Problems are tagged by difficulty (easy, medium, hard) to help you plan your study sessions. Start with easy problems to confirm basic definitions, then progress to medium and hard problems to test deeper understanding.

How to Get the Most From This Resource

Work through the notes first to build conceptual understanding, then attempt the practice problems without referring back. Mark problems you found difficult and revisit them after a few days. The interleaving of topics across sections reflects the way concepts reinforce one another.

Effective study strategies include:

  • Active recall: attempt each problem before reading the explanation.
  • Spaced repetition: revisit difficult problems after increasing intervals (one day, three days, one week).
  • Elaborative interrogation: after reading an explanation, try to re-derive it in your own words.
  • Interleaving: mix problems from different sections rather than studying one section to completion before moving on.

Contributing

If you find an error or wish to suggest an improvement, please raise an issue or submit a pull request to the repository that hosts this site.

All contributions are welcome.

Common Mistakes

Confusing syntax errors with logic errors: Syntax errors prevent code from running (missing semicolons). Logic errors produce wrong output (incorrect algorithm). Don’t confuse debugging approaches.

Forgetting that arrays start at index 0: In most programming languages, the first element is at index 0, not 1. Off-by-one errors are extremely common.

Mixing up pass-by-value with pass-by-reference: Pass-by-value copies the value. Pass-by-reference shares the original. Modifying a parameter in a function affects the original only with pass-by-reference.

Cross-References

  • Mathematics: University-level mathematics including abstract algebra and real analysis.
  • Physics: Classical mechanics, electromagnetism, and quantum physics.
  • Tools: Programming tools and algorithms implementation.

Intuition

Computer science is the study of what can be computed and how efficiently. The three pillars — algorithms and data structures, systems, and theory — each answer a different facet of this question. Algorithms tell you how to solve a problem step by step and how many steps it takes. Systems tell you how to make those solutions work at scale across networks and hardware. Theory tells you what problems are fundamentally hard and what it means to compute at all.

The key mental model is abstraction layers. At the lowest level, hardware executes instructions. Operating systems abstract hardware into processes, files, and network sockets. Programming languages abstract those into types, functions, and modules. Distributed systems abstract networks into consensus and replication. Each layer builds on the one below, and understanding where bugs and inefficiencies arise means knowing which layer to examine. A slow algorithm is an algorithm-layer problem; a dropped network packet is a systems-layer problem; undecidability is a theory-layer problem.

Approach these notes by building intuition before formalism. Understand why a data structure exists (what problem does it solve?), then learn its operations and complexity. For distributed systems, start with the CAP theorem and work outward to consensus protocols. For theory, begin with finite automata and build up to Turing machines. The practice problems are designed to test whether you can apply concepts to new situations — not just recall definitions, but reason about trade-offs and choose the right tool for the problem.