Kacam.net

Observe the world

Interview drills: one stock question, five layers down

The prompt is the exact sentence an interviewer opens with — "what's the difference between a process and a thread", "TCP versus UDP". The textbook definition isn't the finish line, it's the start: it records the version you already have memorised, drags you down five layers, then makes you say it again in sixty seconds.

These prompts only exist in 简体中文 for now.

How to use this

This set interrogates rather than teaches. It is a mock interview: running out of answers is a normal outcome, and it will not cover for you or finish your sentence when you trail off. If you want to understand a topic rather than rehearse for an interview, go to Computer systems, Databases or Algorithms — those guide you instead.

How one stock question fills forty minutes: the five-layer ladder

  • L1 · Definition — what each term means, list the differences. Can't answer: you never learned it.
  • L2 · Mechanism — which structure, which step actually produces that difference. Can't answer: you memorised the conclusion only.
  • L3 · Numbers — by how much? How many microseconds, how many times, how many I/Os. Can't answer: you've never done it hands-on.
  • L4 · Choice — given a concrete scenario, which one, at what cost, and when is that choice wrong. Can't answer: you can't apply it.
  • L5 · Limits — under what conditions does everything you just said stop holding. Can't answer: you know it all, but you don't really understand it.

The bar: L4 is what passes an interview, L5 is what counts as really understanding it, and anything that stops at L1 is recorded as memorised.

Six scenes — the first and last are unique to this set

  • In scene one it does not interrupt, comment or hint. You deliver the version you already have, start to finish, and it records that as your baseline. The silence is deliberate — it is listening, it just isn't correcting you yet.
  • The middle four scenes work down the ladder; scene three, mechanism and numbers, is the main battleground.
  • The last scene puts sixty seconds on the clock and makes you deliver it again, side by side with your opening version — because what an interview asks you to hand over isn't "I understand it", it's a sentence you can actually say out loud.

How to start

  1. Pick one, open it, copy the prompt.
  2. Paste it into a brand-new conversation, say nothing, and wait for its first question.
  3. Then answer like you would in an interview: deliver your memorised version in one go. It's fine if it's rough — that's the baseline it compares against at the end.
  4. After that it starts pressing. Running out of answers is a normal outcome: this isn't study material, it's a mock interview.

Five commands you can call out at any time

  • 跳过 move to the next scene now
  • 提示 give me a hint, not the answer
  • 直说吧 spell the full answer out
  • 重讲 jump straight to the last scene, re-record the sixty-second version and compare it with the opening one
  • 复盘 jump to the wrap-up and print the review card

Three traps

  • The prompt you copy has the answer key at the end — don't read it first. One of its columns is the "recital fingerprints": the exact sentences you're most likely to blurt out. Read them and there's nothing left to drill.
  • Don't hand over adjectives where a number belongs. "Much faster", "barely any overhead" — it stops you and asks for the figure. A conclusion you can't put an order of magnitude on is recorded as memorised.
  • The last two groups are language-bound: do the Java group if you write Java, the Go group if you write Go. They are not translations of each other — each picks its own questions — so there's no need to do both.

Interviewing for a backend role next week? Take process versus thread, TCP versus UDP, why B+ trees, isolation levels, the three cache failure modes, and idempotency — the six most frequent, with almost no overlap. Been hammered in interviews and want to find the gaps? Start with "from URL to rendered page": it exposes every weak spot horizontally, and you can pick your next ones from what it turns up.

Operating systems and concurrency

进程和线程的区别
「进程是资源分配的最小单位,线程是 CPU 调度的最小单位」—— 然后呢?
★★★☆☆ · about 45 min
同步、异步、阻塞、非阻塞
「同步就是要等,异步就是不用等」—— 这句说完,问题才刚开始。
★★★★☆ · about 40 min
死锁:怎么产生、怎么破、怎么查
四个条件背得滚瓜烂熟 —— 那你们代码里真的破了哪一条?
★★★☆☆ · about 40 min
乐观锁和悲观锁
「乐观锁假设不会冲突」—— 那你说得出你们那张表的冲突率吗?
★★★☆☆ · about 35 min
线程池的参数怎么定、满了会怎样
参数表说得出来的人很多,说得出这几个参数谁先谁后的很少。
★★★☆☆ · about 40 min

Databases

四种隔离级别、幻读到底是什么
「可重复读解决了幻读」—— 真的解决干净了吗?给个反例。
★★★★☆ · about 40 min
MVCC 是怎么实现的
「多版本,读不加锁」—— 那「多版本」具体存在哪儿?
★★★★☆ · about 40 min

Caching and messaging

分布式锁怎么做才对
「setnx 加个过期时间就行」—— 然后它会一个一个坑问过来。
★★★★☆ · about 40 min

Distributed systems

限流:三种算法和真实部署
三种算法都说得出来 —— 那你那个阈值是怎么定的?
★★★★☆ · about 40 min

Java and the JVM

HashMap 的原理、它的线程不安全表现在哪
「数组 + 链表 + 红黑树,负载因子 0.75」—— 那容量为什么必须是 2 的幂?
★★★★☆ · about 40 min
synchronized 和 Lock、锁升级四个状态
锁升级四个状态背得出来 —— 那每一级到底省了哪一笔开销?
★★★★☆ · about 40 min

Go and its runtime

GMP 调度模型
「G 是协程、M 是线程、P 是处理器」—— 那为什么非要有 P?
★★★★☆ · about 40 min
channel 的底层和 select
「无缓冲 channel 会阻塞」—— 它是一个长度为 0 的队列吗?
★★★★☆ · about 40 min
defer、panic、recover
「defer 延迟执行、后进先出」—— 那它的参数是什么时候求值的?
★★★★☆ · about 35 min
These prompts are open source They live in the public kacam-net/hero-prompts repo. If one of them doesn't press hard enough, or its answer key is missing a line, go and change it — whether it ships here is a separate call, made by the catalogue on this side.