Topics

Pointers, memory, and the machine underneath everything else.

• pointers-in-practiceWhere the mental model breaks: arrays decaying, ownership nobody wrote down, and the difference between a pointer and the thing it points at.
• undefined-behaviourThe compiler is allowed to do anything at all. What that means for code that works today and stops working at -O2.
• memory-bugsLeaks, double frees, use-after-free. Almost none of them crash where the mistake is, which is why they are hard.
• interview-questionsThe C questions that come up, and what the examiner is checking.

Everything C left to you, plus the machinery to manage it.

• ownership-and-raiiWho frees this, and when. The one idea that makes the rest of the language make sense.
• what-the-compiler-generatesCopy, move, and the constructors you did not write but are using anyway.
• templates-when-they-helpAnd when they turn a build into a four-minute wait and an error nobody can read.
• interview-questionsThe C++ questions that come up, and the ones that are traps.

The paper most students carry a backlog in, and the one most jobs want.

• memory-and-gcHeap, stack, generations, and why a pause happened at the worst moment.
• concurrency-trapssynchronized, volatile, and the race that only appears on the marker's machine.
• collections-in-angerWhich one to reach for, what it costs, and what happens when you mutate while iterating.
• equals-and-hashcodeThe contract between them, and the bug you get in a HashMap when you break it.
• interview-questionsThe Java questions that come up in nearly every round.
• viva-defenceSaying why you used an interface there, out loud, without hedging.

Quick to write, and quick to write something surprising.

• mutable-defaultsThe handful of behaviours that bite everyone once, and are obvious forever after.
• the-gil-in-practiceWhat it actually stops you doing, and why your threads did not go faster.
• packagingVirtual environments, versions, and the reason it runs for you and not for them.
• interview-questionsPython questions, including the ones that are really CS questions.

Most people stuck on a framework are stuck here instead.

• this-and-closuresTwo features that explain most confusing JavaScript, including every hook you will write.roadmap
• async-in-practiceThe event loop, and why your data is undefined on the first render.roadmap
• equality-and-coercionWhy == and === are different questions, and which one you meant.
• interview-questionsClosures, hoisting, event loop. The same four, forever.

Types over JavaScript, and a clear line around what they check.

• what-types-do-not-checkEverything at the edges: API responses, JSON, forms. The compiler believed you.
• narrowingGetting from unknown to something usable without reaching for an assertion.
• generics-when-you-need-themWhich is later than most tutorials suggest.

Small language, real concurrency, few places to hide.

• goroutines-and-leaksCheap to start, easy to forget, and nothing tells you they piled up.
• errors-as-valuesWhat it buys, what it costs, and wrapping without losing the cause.
• interfaces-in-practiceAccept interfaces, return structs, and why the nil check surprised you.

The part of the year placement season eats.

• patterns-that-repeatTwo pointers, sliding window, the handful that cover most of what you will be shown.
• where-people-freezeNot the algorithm. Recognising which problem you are looking at, under a clock.
• complexity-in-interviewsStating it correctly and confidently, including what Big O deliberately ignores.
• the-questions-that-get-askedThe real set, and what a good answer sounds like rather than looks like.notebook
• whiteboard-without-panicThinking out loud is a skill, and it is the one being marked.

The paper everything else quietly assumes you did.

• processes-vs-threadsSaid without the word lightweight, which is where most answers go wrong.
• what-the-scheduler-doesWhy your timing is not reproducible and your benchmark lied.
• memory-you-did-not-allocateVirtual memory, paging, and where the resident size came from.
• interview-questionsDeadlock, scheduling, paging. Reliably these, reliably in this order.

How the bytes get there, and why sometimes they do not.

• what-happens-on-a-requestDNS, TCP, TLS, HTTP, in order. The answer to the most-asked interview question there is.
• latency-you-can-feelWhere the time actually goes, and which fixes are worth anything.
• tls-and-certificatesWhat an attacker on the wire can and cannot see, and why it expired.
• the-network-tabIt answers more questions than any tutorial, and almost nobody opens it.

The theory paper, and the thing your project actually runs on.

• normalisation-for-the-exam1NF to BCNF said in a way you can reproduce under pressure.
• indexes-and-slow-queriesWhat an index is, what it costs on write, and reading EXPLAIN without guessing.notebook
• transactions-and-isolationWhat ACID buys, and the anomaly each isolation level still allows.notebook
• the-n-plus-oneThe most common performance bug in student projects, and in real ones.notebook
• interview-questionsJoins, indexes, isolation, and one normalisation question.
• viva-defenceWhy this table, why this key, why not one big table. Out loud.

Sizing, bottlenecks, and defending a drawing under questioning.

• sizing-before-designingNumbers first. Most bad designs are answers to an unasked question.notebook
• caching-decisionsWhere caches live, what staleness you accepted, and every way it betrays you.notebook
• queues-and-backpressureWhat happens when the producer is faster than the consumer, which it will be.notebook
• the-interview-formatForty-five minutes, a whiteboard, and someone deliberately vague.

Automata, grammars, and what a machine can be asked to do.

• automata-that-matterWhich parts show up again later, and which are exam-only.
• parsing-in-practiceLexing and parsing, and where you meet them outside the paper.
• what-the-optimiser-doesWhy your benchmark disappeared and the loop was deleted.

The subset that shows up again after the exam.

• discrete-for-the-examLogic, sets, relations, counting. The grammar under the theory papers.
• probability-that-shows-upExpectation, distributions, and why an average misleads you about latency.
• linear-algebra-for-mlVectors, matrices, distance. Which is also what an embedding is made of.

React, and the browser it is sitting on.

• state-that-gets-awayUI as a function of state, and what happens when you fight that.roadmap
• effects-you-did-not-needMost useEffect is wrong, including in the tutorial you learned it from.roadmap
• what-costs-a-renderMeasure before memoising, and note the compiler now writes most of it.roadmap
• forms-and-validationWhere everyone fights the framework, and the rule that stops it.
• interview-questionsKeys, reconciliation, hooks rules, and one question about the DOM.

An interface two strangers have to agree on.

• designing-an-endpointNouns, URLs, methods. Getting one right teaches you the rest.notebook
• errors-and-status-codesWhat to return, what to log, and what the caller can actually do about it.notebook
• what-breaks-under-loadConnections, pools, timeouts, and the failure that only appears at scale.notebook
• real-timeWebSockets and server-sent events, and what a deploy does to both.notebook
• interview-questionsREST versus RPC, idempotency, versioning, and one caching question.

The half that gets projects marked down.

• injection-in-three-contextsThe character that breaks each, and the one structural fix they share.notebook
• auth-vs-authorisationChecking permission on every request is the half that gets forgotten.notebook
• secrets-and-where-they-leakGit history, client bundles, logs, error messages. Usually all four.
• interview-questionsXSS, CSRF, hashing versus encryption, and how you store a password.

Someone else's computer, and how you talk to it.

• containers-in-practiceImages, layers, and why yours is 1.2GB.
• ci-that-does-not-lieA green build that means something, and what to do when it does not.
• what-production-is-doingLogs, metrics, traces, and which of the three answers your question.
• cost-surprisesWhere the money actually goes, and the free tier that was not.

What is worth testing, and what is theatre.

• what-is-worth-testingAnd what only makes the coverage number go up.
• tests-that-fail-usefullyA failure should name the bug, not just say something changed.
• flaky-testsAlmost always time, order or shared state. Almost never the framework.

What is actually happening after you press enter.

• how-llms-workTokens, context, prediction, and why confidence signals nothing.
• retrieval-that-returns-the-wrong-thingNearest is not the same as correct. Where every RAG project breaks.
• what-mcp-actually-isA protocol. Your tool exposes functions a model may call, and the rest is plumbing.
• agents-in-practiceA loop: pick a tool, read the result, pick again. And where it goes wrong.
• building-with-claude-honestlyMoving fast with an agent and still answering for every line of it.

The tools nobody teaches and everybody needs.

• git-when-it-goes-wrongDetached heads, bad merges, and getting the work back. It is nearly always there.
• shell-that-pays-offThe dozen worth knowing properly, and pipes that turn them into one tool.
• scripting-the-repeated-thingWhere automation starts, and where it stops being worth it.

The skill nobody is taught and everybody is judged on.

• reading-a-stack-traceWhere the error is thrown is rarely where the mistake is.
• bisecting-a-problemHalving the search space beats staring at it, every time.
• hypothesis-not-guessingOne change at a time, and a prediction before you run it.

Explaining work you did, to someone deciding about you.

• the-viva-testPoint at any line and say why it is there. If you cannot, you do not own it yet.
• explaining-your-own-projectTwo minutes, no jargon, and one defensible decision.
• placement-seasonYou can write it and freeze when asked. Those are different skills.
• what-they-actually-askLifted from our own question bank rather than invented for a listicle.notebook