Learning

Follow the questions, one step at a time.

Find content in Writing; use this page for reading order, Projects for architecture, Labs for protocols and evidence, and Build for hands-on exploration.

0 / 59 · Your reading progress, stored in this browser only.

Choose your first path below.

Build / AI Applications

Java, HTTP and JSON basics

Published reading order · 17
  1. Build · Beginner

    Calling an LLM with Java 8 — from one request to a conversation →

    After reading: Send a request, parse the answer and pass conversation history.

    Prerequisites: Java, HTTP and JSON basics

    Project · Java LLM Practice →

    Next: Java LLM Practice II: How to validate model JSON after HTTP 200 →

    15 min
  2. Build · Intermediate

    Java LLM Practice II: How to validate model JSON after HTTP 200 →

    After reading: Separate transport, JSON structure and business acceptance.

    Prerequisites: Calling an LLM with Java 8 — from one request to a conversation

    Project · Java LLM Practice →

    Next: Java LLM practice 3: don't let a failed request change conversation history →

    16 min
  3. Build · Intermediate

    Java LLM practice 3: don't let a failed request change conversation history →

    After reading: Commit a whole turn atomically without leaving partial history.

    Prerequisites: Java LLM Practice II: How to validate model JSON after HTTP 200

    Lab · A1 / The chat-history commit boundary →Project · Java LLM Practice →

    Next: Java LLM IV: which concurrent response may commit? →

    10 min
  4. Build · Intermediate

    Java LLM IV: which concurrent response may commit? →

    After reading: Use version tickets for first-committer-wins and contrast serialization.

    Prerequisites: Java LLM practice 3: don't let a failed request change conversation history

    Lab · A2 / Concurrent history commits →Project · Java LLM Practice →

    Next: Java LLM V: why can a timed-out tool keep running? →

    8 min
  5. Build · Intermediate

    Java LLM V: why can a timed-out tool keep running? →

    After reading: Bound tools, arguments and budgets; distinguish timeout from termination.

    Prerequisites: Java LLM Practice II: How to validate model JSON after HTTP 200

    Lab · Tool failure recovery experiment →Project · Java LLM Practice →

    Next: Java LLM practice (8): should an interrupted stream enter conversation history? →

    8 min
  6. Build · Intermediate

    Java LLM practice (8): should an interrupted stream enter conversation history? →

    After reading: Separate streamed previews from a complete, committable answer.

    Prerequisites: Java LLM Practice II: How to validate model JSON after HTTP 200

    Lab · Java LLM practice (8): should an interrupted stream enter conversation history? →Project · Java LLM Practice →

    Next: Java LLM practice (9): why can a cancelled answer overwrite a new conversation? →

    11 min
  7. Build · Intermediate

    Java LLM practice (9): why can a cancelled answer overwrite a new conversation? →

    After reading: Compare three session policies and reject callbacks from superseded requests.

    Prerequisites: Java LLM practice (8): should an interrupted stream enter conversation history?

    Lab · Java LLM practice (9): why can a cancelled answer overwrite a new conversation? →Project · Java LLM Practice →

    Next: Java LLM practice (10): why is the reader still running after cancellation? →

    10 min
  8. Build · Intermediate

    Java LLM practice (10): why is the reader still running after cancellation? →

    After reading: Distinguish local cancellation, transport shutdown and remote termination.

    Prerequisites: Java LLM practice (9): why can a cancelled answer overwrite a new conversation?

    Lab · Java LLM practice (10): why is the reader still running after cancellation? →Project · Java LLM Practice →

    Next: Does TypeScript validate model output? A 32-case comparison with Java →

    11 min
  9. Build · Intermediate

    Does TypeScript validate model output? A 32-case comparison with Java →

    After reading: Explain why static types do not replace runtime validation of external responses.

    Prerequisites: Java LLM Practice II: How to validate model JSON after HTTP 200

    Lab · TypeScript / Output boundary comparison →Project · Java LLM Practice →

    Next: Inside AI Radar — from an RSS response to a published page →

    11 min
  10. Build · Intermediate

    Inside AI Radar — from an RSS response to a published page →

    After reading: Trace collection, deduplication and publication, distinguishing historical and current settings.

    Prerequisites: Java, HTTP and JSON basics

    Project · Hohoo’s AI Lab →

    Next: Java history and request windows: can a trimmed fact return? →

    12 min
  11. Build · Intermediate

    Java history and request windows: can a trimmed fact return? →

    After reading: Follow narrowing, commit, restart and expansion to separate durable conversation history from one request context.

    Prerequisites: Java LLM practice 3: don't let a failed request change conversation history

    Lab · Java history and request windows: can a trimmed fact return? →Project · Java LLM Practice →

    Next: Java retries: three timeouts are not one deadline →

    9 min
  12. Build · Intermediate

    Java retries: three timeouts are not one deadline →

    After reading: Seven local HTTP conditions separate retryability, Retry-After, attempt limits and elapsed-time budgets.

    Prerequisites: Java LLM practice (10): why is the reader still running after cancellation?

    Lab · Java retries: three timeouts are not one deadline →Project · Java LLM Practice →

    Next: Durable Java turns: what survives a process crash? →

    9 min
  13. Build · Intermediate

    Durable Java turns: what survives a process crash? →

    After reading: Checksummed append records, 142 truncated prefixes and three halted JVMs distinguish local recovery from remote exactly-once execution.

    Prerequisites: Java history and request windows: can a trimmed fact return?

    Lab · Durable Java turns: what survives a process crash? →Project · Java LLM Practice →

    Next: Java idempotent retries: no reply does not mean no effect →

    9 min
  14. Build · Intermediate

    Java idempotent retries: no reply does not mean no effect →

    After reading: Distinguish a lost reply from an unknown effect; reproduce concurrent deduplication and crash gaps.

    Prerequisites: Java retries: three timeouts are not one deadline · Durable Java turns: what survives a process crash?

    Lab · Java idempotent retries: no reply does not mean no effect →Project · Java LLM Practice →

    Next: Durable idempotency: commit identity and result together →

    11 min
  15. Build · Intermediate

    Durable idempotency: commit identity and result together →

    After reading: Use a framed journal, process crashes and 99 truncated prefixes to explain durable idempotency.

    Prerequisites: Java idempotent retries: no reply does not mean no effect

    Lab · Durable delivery and history recovery →Project · Java LLM Practice →

    Next: Outbox delivery: local durability is not remote exactly-once →

    10 min
  16. Build · Intermediate

    Outbox delivery: local durability is not remote exactly-once →

    After reading: Compare keyed and unkeyed receivers to separate lost replies, missing receipts and duplicate remote effects.

    Prerequisites: Durable idempotency: commit identity and result together

    Lab · Durable delivery and history recovery →Project · Java LLM Practice →

    Next: Conversation recovery: reconcile intent, receipt and whole turn →

    10 min
  17. Build · Intermediate

    Conversation recovery: reconcile intent, receipt and whole turn →

    After reading: Halt the JVM at three commit boundaries and rebuild whole-turn history from durable facts.

    Prerequisites: Outbox delivery: local durability is not remote exactly-once

    Lab · Durable delivery and history recovery →Project · Java LLM Practice →
    10 min
Future topics · unpublished
  1. Build · Planned topic

    Tool Calling

  2. Build · Planned topic

    Spring AI introduction

  3. Build · Planned topic

    Agent workflows

  4. Build · Planned topic

    Evaluate, record failures and iterate

  5. Build · Planned topic

    AI application observability

  6. Build · Planned topic

    Production

  7. Build · Planned topic

    AI Coding

  8. Build · Planned topic

    Codex

  9. Build · Planned topic

    MCP

  10. Build · Planned topic

    Skills

  11. Build · Planned topic

    Harness Engineering

  12. Build · Planned topic

    Testing

  13. Build · Planned topic

    Performance

Understand / LLM

Python, arrays and matrices; mechanism experiments use an untrained toy model

Published reading order · 18
  1. Understand · Intermediate

    KV Cache explained — why send the conversation history again? →

    After reading: Estimate K/V payload and distinguish conversation context from computation reuse.

    Prerequisites: Python, arrays and matrices; mechanism experiments use an untrained toy model

    Next: LLM mechanics I: should changing future tokens affect earlier outputs? →

    10 min
  2. Understand · Intermediate

    LLM mechanics I: should changing future tokens affect earlier outputs? →

    After reading: Test causal masking with a future-information leakage counterexample.

    Prerequisites: KV Cache explained — why send the conversation history again?

    Lab · L2–L4 / Attention and cache mechanics →Project · Java LLM Practice →

    Next: LLM mechanics II: what does KV caching save, and how do we verify it? →

    8 min
  3. Understand · Intermediate

    LLM mechanics II: what does KV caching save, and how do we verify it? →

    After reading: Compare full and incremental computation step by step.

    Prerequisites: LLM mechanics I: should changing future tokens affect earlier outputs?

    Lab · L2–L4 / Attention and cache mechanics →Project · Java LLM Practice →

    Next: LLM mechanics III: why is a four-slot cache not four-token recomputation? →

    8 min
  4. Understand · Intermediate

    LLM mechanics III: why is a four-slot cache not four-token recomputation? →

    After reading: Preserve position semantics after sliding-window eviction.

    Prerequisites: LLM mechanics II: what does KV caching save, and how do we verify it?

    Lab · L2–L4 / Attention and cache mechanics →Project · Java LLM Practice →

    Next: LLM mechanics (4): when a prefix changes, is the old KV cache still valid? →

    8 min
  5. Understand · Intermediate

    LLM mechanics (4): when a prefix changes, is the old KV cache still valid? →

    After reading: Identify invalidation conditions after model, position or input changes.

    Prerequisites: LLM mechanics III: why is a four-slot cache not four-token recomputation?

    Lab · L5 / Prefix-cache invalidation →Project · Java LLM Practice →

    Next: LLM mechanics (5): after editing history, can we recompute only the changed suffix? →

    9 min
  6. Understand · Intermediate

    LLM mechanics (5): after editing history, can we recompute only the changed suffix? →

    After reading: Match the longest valid prefix and compute the remaining tokens.

    Prerequisites: LLM mechanics (4): when a prefix changes, is the old KV cache still valid?

    Lab · LLM mechanics (5): after editing history, can we recompute only the changed suffix? →Project · Java LLM Practice →

    Next: LLM mechanics (6): why can a larger prefix cache still get zero hits? →

    10 min
  7. Understand · Intermediate

    LLM mechanics (6): why can a larger prefix cache still get zero hits? →

    After reading: Budget array bytes in LRU and explain zero hits when the working set does not fit.

    Prerequisites: LLM mechanics (5): after editing history, can we recompute only the changed suffix?

    Lab · LLM mechanics (6): why can a larger prefix cache still get zero hits? →Project · Java LLM Practice →

    Next: LLM mechanics (7): why is caching slower even when it saves computation? →

    11 min
  8. Understand · Intermediate

    LLM mechanics (7): why is caching slower even when it saves computation? →

    After reading: Evaluate numerical equivalence, saved work and measured time separately.

    Prerequisites: LLM mechanics (6): why can a larger prefix cache still get zero hits?

    Lab · LLM mechanics (7): why is caching slower even when it saves computation? →Project · Java LLM Practice →

    Next: Does moving an answer into the middle make a model miss it? An interrupted controlled trial →

    12 min
  9. Understand · Intermediate

    Does moving an answer into the middle make a model miss it? An interrupted controlled trial →

    After reading: Separate planned, attempted and valid calls, including rate-limited incomplete runs.

    Prerequisites: Python, arrays and matrices; mechanism experiments use an untrained toy model

    Project · Java LLM Practice →Lab · L1 / Context position: an interrupted trial →

    Next: LLM experiment II: make the comparison valid before interpreting position →

    12 min
  10. Understand · Intermediate

    LLM experiment II: make the comparison valid before interpreting position →

    After reading: Audit 24 real paired calls and explain a ceiling effect.

    Prerequisites: Does moving an answer into the middle make a model miss it? An interrupted controlled trial

    Project · Java LLM Practice →Lab · L1 / Context position: an interrupted trial →

    Next: After 24 correct answers: designing a more discriminating context experiment →

    16 min
  11. Understand · Intermediate

    After 24 correct answers: designing a more discriminating context experiment →

    After reading: Inspect a 128-case offline protocol without claiming model results.

    Prerequisites: LLM experiment II: make the comparison valid before interpreting position

    Project · Java LLM Practice →

    Next: Profiling KV reuse: saved work versus added overhead →

    10 min
  12. Understand · Intermediate

    Profiling KV reuse: saved work versus added overhead →

    After reading: Profile 909 queries across signatures, lookup, copying and continuation, including the remaining slowdown.

    Prerequisites: LLM mechanics (7): why is caching slower even when it saves computation?

    Lab · Profiling KV reuse: saved work versus added overhead →Project · Java LLM Practice →

    Next: Tiled attention: preserving results without a full score matrix →

    9 min
  13. Understand · Intermediate

    Tiled attention: preserving results without a full score matrix →

    After reading: Derive online softmax from a failing block-average baseline and separate smaller temporaries from measured speed.

    Prerequisites: LLM mechanics II: what does KV caching save, and how do we verify it?

    Lab · Tiled attention: preserving results without a full score matrix →Project · Java LLM Practice →

    Next: KV quantization: how many bytes, and at what error? →

    9 min
  14. Understand · Intermediate

    KV quantization: how many bytes, and at what error? →

    After reading: Compare tensor and row-wise int8 quantization, including scale bytes and attention error under outliers.

    Prerequisites: Tiled attention: preserving results without a full score matrix

    Lab · KV quantization: how many bytes, and at what error? →Project · Java LLM Practice →

    Next: KV quantization axes: why Key and Value need separate reasoning →

    9 min
  15. Understand · Intermediate

    KV quantization axes: why Key and Value need separate reasoning →

    After reading: Choose quantization axes from outlier structure and independently recompute output error and scale overhead.

    Prerequisites: KV quantization: how many bytes, and at what error?

    Lab · KV quantization axes: why Key and Value need separate reasoning →Project · Java LLM Practice →

    Next: Packed KV groups: what does 4-bit actually save? →

    10 min
  16. Understand · Intermediate

    Packed KV groups: what does 4-bit actually save? →

    After reading: Store real nibbles and audit group-scale overhead, padding bytes and attention output error.

    Prerequisites: KV quantization axes: why Key and Value need separate reasoning

    Lab · Packed KV, residual windows and block cost →Project · Java LLM Practice →

    Next: KV residual windows: do recent tokens deserve higher precision? →

    10 min
  17. Understand · Intermediate

    KV residual windows: do recent tokens deserve higher precision? →

    After reading: Compare early-focused and recent-focused attention to explain unequal gains from the same float32 window.

    Prerequisites: Packed KV groups: what does 4-bit actually save?

    Lab · Packed KV, residual windows and block cost →Project · Java LLM Practice →

    Next: Block KV decoding: less workspace, more time →

    10 min
  18. Understand · Intermediate

    Block KV decoding: less workspace, more time →

    After reading: Separate cache payload, work arrays and observed runtime, retaining 810 timings including slower block decoding.

    Prerequisites: KV residual windows: do recent tokens deserve higher precision?

    Lab · Packed KV, residual windows and block cost →Project · Java LLM Practice →
    10 min
Future topics · unpublished
  1. Understand · Planned topic

    What is a token?

  2. Understand · Planned topic

    Context Window

  3. Understand · Planned topic

    Embedding

  4. Understand · Planned topic

    Attention

  5. Understand · Planned topic

    Transformer

  6. Understand · Planned topic

    LLM Evaluation

  7. Understand · Planned topic

    Sampling / Inference

Explore / Getting started with embodied AI

Python basics; teaching simulations use MuJoCo and a Cartesian gripper

Published reading order · 22
  1. Explore · Beginner

    Embodied AI Practice I: Pick up a cube in MuJoCo, then deliberately miss →

    After reading: Run contact-based pickup and preserve failed trajectories.

    Prerequisites: Python basics; teaching simulations use MuJoCo and a Cartesian gripper

    Project · Hohoo Embodied Experiments →

    Next: Embodied practice II: if the grasp failed, skip the transfer →

    18 min
  2. Explore · Intermediate

    Embodied practice II: if the grasp failed, skip the transfer →

    After reading: Validate grasp before transfer and stop on failure.

    Prerequisites: Embodied AI Practice I: Pick up a cube in MuJoCo, then deliberately miss

    Project · Hohoo Embodied Experiments →Lab · E2 / Confirm the grasp before transfer →

    Next: Embodied practice III: a confirmed grasp still needs monitoring →

    12 min
  3. Explore · Intermediate

    Embodied practice III: a confirmed grasp still needs monitoring →

    After reading: Monitor slips during transfer, not only at its start.

    Prerequisites: Embodied practice II: if the grasp failed, skip the transfer

    Project · Hohoo Embodied Experiments →Lab · E3 / Contact monitoring during transfer →

    Next: Embodied practice IV: messages arrive, but observations expire →

    14 min
  4. Explore · Intermediate

    Embodied practice IV: messages arrive, but observations expire →

    After reading: Judge missing and stale observations by capture time.

    Prerequisites: Embodied practice III: a confirmed grasp still needs monitoring

    Project · Hohoo Embodied Experiments →Lab · E4 / Observation freshness and sampling →

    Next: Embodied practice 5: communication is back—may transfer resume? →

    14 min
  5. Explore · Intermediate

    Embodied practice 5: communication is back—may transfer resume? →

    After reading: Revalidate after communication recovery before continuing.

    Prerequisites: Embodied practice IV: messages arrive, but observations expire

    Lab · E5 / Revalidating recovery →Project · Hohoo Embodied Experiments →

    Next: Embodied AI VI: what do recovery gating and replanning each solve? →

    12 min
  6. Explore · Intermediate

    Embodied AI VI: what do recovery gating and replanning each solve? →

    After reading: Separate recovery gating from replanning effects.

    Prerequisites: Embodied practice 5: communication is back—may transfer resume?

    Lab · E6 / Recovery gate and path ablation →Project · Hohoo Embodied Experiments →

    Next: Embodied AI Practice VII: Why a Transfer Rule Stops Normal Lowering →

    14 min
  7. Explore · Intermediate

    Embodied AI Practice VII: Why a Transfer Rule Stops Normal Lowering →

    After reading: Choose phase-specific checks instead of applying lift-height rules during lowering.

    Prerequisites: Embodied AI VI: what do recovery gating and replanning each solve?

    Lab · E7 / Grasp contracts during lowering →Project · Hohoo Embodied Experiments →

    Next: Embodied AI VIII: what should the gripper do after a drop alarm? →

    13 min
  8. Explore · Intermediate

    Embodied AI VIII: what should the gripper do after a drop alarm? →

    After reading: Explain physical consequences of hold, stop and retreat after an alarm.

    Prerequisites: Embodied AI Practice VII: Why a Transfer Rule Stops Normal Lowering

    Lab · E8 / Post-alarm exit actions →Project · Hohoo Embodied Experiments →

    Next: Embodied AI IX: a release command is not verified placement →

    9 min
  9. Explore · Intermediate

    Embodied AI IX: a release command is not verified placement →

    After reading: Validate release through contact and a stability window.

    Prerequisites: Embodied AI VIII: what should the gripper do after a drop alarm?

    Lab · E9 / Post-release completion verification →Project · Hohoo Embodied Experiments →

    Next: Embodied AI X: why can a recovery budget stop a recoverable task? →

    9 min
  10. Explore · Intermediate

    Embodied AI X: why can a recovery budget stop a recoverable task? →

    After reading: Bound revalidation time and retain the reason for termination.

    Prerequisites: Embodied AI IX: a release command is not verified placement

    Lab · E10 / Bounded recovery and cooldown →Project · Hohoo Embodied Experiments →

    Next: Embodied AI practice (11): placement completed, but is it still valid? →

    9 min
  11. Explore · Intermediate

    Embodied AI practice (11): placement completed, but is it still valid? →

    After reading: Record historical completion separately from current validity.

    Prerequisites: Embodied AI X: why can a recovery budget stop a recoverable task?

    Lab · E11 / Completion and current validity →Project · Hohoo Embodied Experiments →

    Next: Embodied AI practice (12): what should the gripper do after recovery is exhausted? →

    11 min
  12. Explore · Intermediate

    Embodied AI practice (12): what should the gripper do after recovery is exhausted? →

    After reading: Test exit actions after abort rather than equating a state label with safety.

    Prerequisites: Embodied AI practice (11): placement completed, but is it still valid?

    Lab · Embodied AI practice (12): what should the gripper do after recovery is exhausted? →Project · Hohoo Embodied Experiments →

    Next: Embodied AI practice (13): where should recovery resume after interrupted lowering? →

    12 min
  13. Explore · Intermediate

    Embodied AI practice (13): where should recovery resume after interrupted lowering? →

    After reading: Connect phase checks, recovery budgets and exit actions.

    Prerequisites: Embodied AI practice (12): what should the gripper do after recovery is exhausted?

    Lab · Embodied AI practice (13): where should recovery resume after interrupted lowering? →Project · Hohoo Embodied Experiments →

    Next: Embodied AI practice (14): does landing in the bin mean the task is complete? →

    13 min
  14. Explore · Intermediate

    Embodied AI practice (14): does landing in the bin mean the task is complete? →

    After reading: Distinguish physical placement, current validity and qualified completion.

    Prerequisites: Embodied AI practice (13): where should recovery resume after interrupted lowering?

    Lab · Embodied AI practice (14): does landing in the bin mean the task is complete? →Project · Hohoo Embodied Experiments →

    Next: Reading OpenVLA — from an image and instruction to robot actions →

    13 min
  15. Explore · Intermediate

    Reading OpenVLA — from an image and instruction to robot actions →

    After reading: Trace the OpenVLA action interface without claiming a completed training run.

    Prerequisites: Python basics; teaching simulations use MuJoCo and a Cartesian gripper

    Lab · Action representation study →

    Next: A second MuJoCo scene: why does the actuator overshoot? →

    12 min
  16. Explore · Intermediate

    A second MuJoCo scene: why does the actuator overshoot? →

    After reading: Compare mass and PD damping in a planar force-controlled actuator, separating target crossing from stable completion.

    Prerequisites: Embodied AI practice (14): does landing in the bin mean the task is complete?

    Lab · A second MuJoCo scene: why does the actuator overshoot? →Project · Hohoo Embodied Experiments →

    Next: MuJoCo obstacle clearance: a point path is not a body path →

    9 min
  17. Explore · Intermediate

    MuJoCo obstacle clearance: a point path is not a body path →

    After reading: Six contact trajectories compare direct, edge and clearance paths while separating geometry from controller tracking.

    Prerequisites: A second MuJoCo scene: why does the actuator overshoot?

    Lab · MuJoCo obstacle clearance: a point path is not a body path →Project · Hohoo Embodied Experiments →

    Next: Delayed MuJoCo feedback: can an old observation predict now? →

    9 min
  18. Explore · Intermediate

    Delayed MuJoCo feedback: can an old observation predict now? →

    After reading: Twenty-four paired traces compare delay, position noise and constant-velocity prediction, retaining incomplete recoveries.

    Prerequisites: MuJoCo obstacle clearance: a point path is not a body path

    Lab · Delayed MuJoCo feedback: can an old observation predict now? →Project · Hohoo Embodied Experiments →

    Next: MuJoCo velocity estimation: smoother signals can mean worse control →

    9 min
  19. Explore · Intermediate

    MuJoCo velocity estimation: smoother signals can mean worse control →

    After reading: Derive finite-difference noise amplification and audit smoothing lag, force clipping and stable completion.

    Prerequisites: Delayed MuJoCo feedback: can an old observation predict now? · A second MuJoCo scene: why does the actuator overshoot?

    Lab · MuJoCo velocity estimation: smoother signals can mean worse control →Project · Hohoo Embodied Experiments →

    Next: MuJoCo controller tuning: best candidate is not a passing controller →

    11 min
  20. Explore · Intermediate

    MuJoCo controller tuning: best candidate is not a passing controller →

    After reading: Select on 54 development episodes, then check position error and stable completion on 36 held-out episodes.

    Prerequisites: MuJoCo velocity estimation: smoother signals can mean worse control

    Lab · Planar control tuning, observation loss and transfer →Project · Hohoo Embodied Experiments →

    Next: MuJoCo observation loss: zero force is not a stop →

    10 min
  21. Explore · Intermediate

    MuJoCo observation loss: zero force is not a stop →

    After reading: Compare stale feedback, zero force and fading in 27 episodes to distinguish timeout from physical braking.

    Prerequisites: MuJoCo controller tuning: best candidate is not a passing controller

    Lab · Planar control tuning, observation loss and transfer →Project · Hohoo Embodied Experiments →

    Next: MuJoCo mass transfer: can the same gains still work? →

    10 min
  22. Explore · Intermediate

    MuJoCo mass transfer: can the same gains still work? →

    After reading: Compare fixed and mass-scaled gains in 36 episodes, including lower mean error without a velocity-contract pass.

    Prerequisites: MuJoCo observation loss: zero force is not a stop

    Lab · Planar control tuning, observation loss and transfer →Project · Hohoo Embodied Experiments →
    10 min
Future topics · unpublished
  1. Explore · Planned topic

    What is embodied AI?

  2. Explore · Planned topic

    Understand perception, decisions and actions

  3. Explore · Planned topic

    Read a paper with a question in mind

  4. Explore · Planned topic

    VLM and VLA

  5. Explore · Planned topic

    Action Space

  6. Explore · Planned topic

    Embodied Benchmark

Retrieve / RAG · Retrieval-augmented generation

Java, HTTP and JSON basics; distinguish retrieved candidates from evidence sufficient for an answer.

Two offline practices are published: a BM25 retrieval baseline and citation checks for closed fields. They do not establish real-model answer quality or constitute a complete blog Q&A system.

Published reading order · 2
  1. Retrieve · Intermediate

    Java LLM VI: validate retrieval evidence before judging RAG answers →

    After reading: Recompute BM25 retrieval and false hits on unanswerable toy queries.

    Prerequisites: Calling an LLM with Java 8 — from one request to a conversation

    Lab · Retrieval quality comparison →Project · Java LLM Practice →

    Next: Java LLM practice (7): a real citation can still support a wrong answer →

    8 min
  2. Retrieve · Intermediate

    Java LLM practice (7): a real citation can still support a wrong answer →

    After reading: Validate claim–evidence correspondence without claiming semantic entailment.

    Prerequisites: Java LLM VI: validate retrieval evidence before judging RAG answers

    Lab · Retrieval quality comparison →Project · Java LLM Practice →

    Next: explore the research plan →

    9 min
Future topics · unpublished
  1. Retrieve · Planned topic

    Freeze the corpus, then compare chunking

    Build traceable documents and relevance labels, separating development and held-out questions.

    Prerequisites
    Complete the BM25 baseline; distinguish documents, chunks and citations.
    Research question
    Which questions lose answer context under fixed-length versus heading-based chunks?
    Planned deliverables
    Corpus snapshot, document versions and sources, labeled answerable/unanswerable questions, two chunkers and per-query retrieval logs.
    How to validate
    Hold tokenization, retriever and top-k fixed; report Recall@k, split-answer failures and duplicate hits. Do not tune on the held-out set.

    Previous step ↑ · Next step →

  2. Retrieve · Planned topic

    Choosing BM25, dense or hybrid retrieval

    Compare lexical matching, dense retrieval and fused ranking on identical questions.

    Prerequisites
    A frozen corpus and relevance labels; basics of embeddings and similarity.
    Research question
    How do aliases, exact identifiers and mixed-language queries fail under each strategy?
    Planned deliverables
    A local vector index with a pinned model version; BM25, dense and fused results with ranks and timings.
    How to validate
    Compare Recall@k, MRR, index bytes and query time with identical chunks and candidate budgets; retain hybrid regressions.

    Previous step ↑ · Next step →

  3. Retrieve · Planned topic

    Reranking and assembling the context

    Select evidence with answer coverage and limited duplication under a fixed context budget.

    Prerequisites
    Complete retrieval comparisons; understand token budgets and citation IDs.
    Research question
    Which evidence improves or disappears through reranking, deduplication and truncation?
    Planned deliverables
    Candidate and reranked lists, a context assembler, citation maps and budget-truncation logs.
    How to validate
    Ablate one stage at a time; compare ranking, evidence coverage, duplication and time. Improved ranking alone is not improved answer accuracy.

    Previous step ↑ · Next step →

  4. Retrieve · Planned topic

    From retrieved evidence to answer quality and abstention

    Measure retrieval hits, claim support and abstention on missing evidence separately.

    Prerequisites
    Complete context assembly and citation contracts; freeze the scoring rubric first.
    Research question
    Which answers improve with retrieval, and which merely add unsupported citations?
    Planned deliverables
    Continue retrieval-eval: paired no-retrieval/retrieval outputs, model and prompt versions, human support labels, and missing/conflicting-evidence failures.
    How to validate
    Protocol first; real-model runs are pending. Report correctness, citation support, false abstention and unsupported answers separately, with per-query outputs and usage. Paid calls need separate authorization.

    Previous step ↑ · Next step →

  5. Retrieve · Planned topic

    Updates, permissions and retrieval injection

    Prevent withdrawn, stale or unauthorized documents from becoming current answer evidence.

    Prerequisites
    Versioned documents, source IDs and traceable contexts.
    Research question
    Can stale chunks and caches leak or mislead after index or permission changes?
    Planned deliverables
    Update, deletion and revocation regression cases; index/cache invalidation logs; local fixtures containing malicious retrieved instructions.
    How to validate
    Check access before evidence reaches the model; never label stale versions current. Retrieved text cannot expand tool permissions. Passing local cases is not a general injection-defense guarantee.

    Previous step ↑ · Next step →

  6. Retrieve · Planned topic

    Integration: traceable blog Q&A

    Connect retrieval, evidence, answers and failure handling in a reproducible minimal application.

    Prerequisites
    Complete the evaluation and trust-boundary stages; confirm cost and product scope.
    Research question
    Can readers verify sources, recognize missing evidence and continue reading when the system fails?
    Planned deliverables
    A minimal hohoo-ai-lab application, pinned corpus and versions, setup commands, evaluation report, and source/no-evidence/error states.
    How to validate
    Reproduce indexing through answering from a clean environment, including failures and abstention; keep secrets server-side. Not deployed or counted as a completed product.

    Previous step ↑

Engineering foundations

Java · Python · TypeScript · HTTP · JSON

AI applications and engineering →

Reading list · Research overview · Build