Files
ProcessControl/conv/02-part-II.md
T
MatsuneMikuroiandClaude Opus 5 f7fa60ba81 Night-mode styling, French cross-references, and the log through Part VI
- theme.scss and figures draw with the extension's --calc-… tokens; light/dark
  pair plus the high-contrast button; a11y highlight style for html
- figure labels split so none leaves its viewBox in any language
- _quarto-fr.yml: French cross-reference prefixes
- notes extension synced to 2.8.18
- conv/: Parts IV, V and VI logged, pasted terminal output redacted

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-10-06 03:36:51 +02:00

508 lines
27 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Conversation Log — Part II — Cross the Process Boundary · Steps 11–18 (turns 29–44)
<!-- nav -->
> [⬅ Previous: Part I](01-part-I.md) · [Index](../conv.md) · [Next: Part III ➡](03-part-III.md)
>
> All parts: [Setup & Step 0](00-setup-and-step-0.md) · [Part I](01-part-I.md) · **Part II** · [Part III](03-part-III.md) · [Part IV](04-part-IV.md) · [Part V](05-part-V.md) · [Part VI](06-part-VI.md)
<!-- /nav -->
---
## [29] Student
> commit everything before moving to step 11
## [29] Tutor — actions taken
- `git status`: `conv.md` modified; `.setup` (empty, 0 bytes) and `Schedule.md` (7528 bytes) untracked; `main` 1 commit ahead of `origin/main` (the unpushed rename commit `7b3e0f2`).
- Logged this turn in `conv.md` before committing, so the commit includes it.
- `git add -A` and `git commit`, which includes `conv.md`, `Schedule.md` and the empty `.setup`, as "everything" was requested. Not pushed (not requested).
- Result: commit `ad1a1f5` "Add course schedule and update tutoring log through Part I". Working tree clean. `main` is now **2 commits ahead** of `origin/main` (`7b3e0f2` and `ad1a1f5`, both unpushed).
## [29] Tutor — reply
Committed as `ad1a1f5`: `Schedule.md`, the updated `conv.md` (through the end of Part I and this turn), and the empty `.setup` file, since you said everything. Nothing is pushed. `main` is 2 commits ahead of `origin/main`, which includes the earlier `.claude → TUTOR.md` rename. Tell me if you want them pushed.
Step 11 is ready: predict what breaks once each capability runs as its own process, then read README lines 697–730, and send me:
1. your prediction, and whether section 11 confirms it;
2. in your own words, why the README uses the filesystem to carry messages here, rather than TCP or MQTT.
**Progress record**
- Current step: 11 — Separate the Components (Part II)
- Last observed result: everything committed locally (`ad1a1f5`); 2 commits unpushed
- Unresolved problem: none
- Next action: student predicts what breaks across process boundaries, reads section 11, and explains the filesystem choice
---
## [30] Student
> yes, push all
## [30] Tutor — actions taken
- `git push origin main` → `f615bef..ad1a1f5 main -> main`. `main` is now level with `origin/main`.
- Only `conv.md` is modified in the working tree (turns [29] reply and [30] were logged after the commit).
## [30] Tutor — reply
Pushed: `f615bef..ad1a1f5 main -> main`. Both commits (the `TUTOR.md` rename and the schedule/log commit) are now on the remote, and `main` matches `origin/main`. Only `conv.md` has changed since, because it logs every turn.
Back to Step 11: predict what breaks once each capability runs as its own process, then read README lines 697–730, and send me your prediction plus why the README uses the filesystem rather than TCP or MQTT.
**Progress record**
- Current step: 11 — Separate the Components (Part II)
- Last observed result: pushed `ad1a1f5` to `origin/main`
- Unresolved problem: none
- Next action: student predicts what breaks across process boundaries, reads section 11, and explains the filesystem choice
---
## [31] Student
> We need a way to communicate between each process (defined protocol [informations packet, shared file, physical signal]). We will use the file system because we can easily read it
## [31] Tutor — actions taken
- `grep` in the README and `03-static-filesystem/*.java` for `messageBoard`, to find where the message board directory is expected to live.
- Read `03-static-filesystem/FileMessageBoard.java` in full. The root is `System.getProperty("messageBoard.root", "messageBoard")`, i.e. **relative to the directory you run `java` from**. `publish` and `watch` both call `Files.createDirectories`, so the code would create the mailboxes itself if missing.
- Read README lines 1140–1211 (Step 18). Its commands (`rm -rf messageBoard`, `java SensorService.java`, …) are run from inside `03-static-filesystem/`.
## [31] Tutor — reply
*(Not delivered. The reply to this turn was stopped before it reached the student. An undelivered draft had been written into this log and has been removed, since it was never part of the conversation.)*
---
## [32] System note
- The student was told that the previous reply was interrupted and could not be delivered, and was asked how to continue.
**Progress record**
- Current step: 11 — Separate the Components (student has answered; feedback not yet delivered)
- Last observed result: student's Step 11 answer received (need for inter-process communication; filesystem chosen "because we can easily read it")
- Unresolved problem: the reply to turn [31] was interrupted
- Next action: wait for the student to say how they want to continue
---
## [33] Student
> just read step 12, no questions for me
## [33] Tutor — actions taken
- Read README lines 782–863 (Step 13 "Keep the First File Format Ridiculously Simple").
## [33] Tutor — reply
Noted: Step 12 read, no questions. Moving on.
**Step 13 — Keep the First File Format Ridiculously Simple**
**Goal:** decide what a message looks like once it's a file: plain text, no library.
**Do:** read README lines 782–858.
**Look for:** the two-line format, the optional last line, and why that last line starts with `TIMESTAMP: `.
**Tell me (one line is enough):** the README ends with "It is primitive. That is useful." Useful for what, in this tutorial?
**Progress record**
- Current step: 13 — Keep the First File Format Ridiculously Simple
- Last observed result: Step 12 read by the student, no questions
- Unresolved problem: none
- Next action: student reads Step 13 and says why a primitive format is useful here
---
## [34] Student
> Every is kept at it's most basic level, i.e., data type, plain text message, Timestamp (if used), so no salt around it
## [34] Tutor — actions taken
- Read README lines 862–939 (Step 14 "The First Distributed-Systems Problem: Publication").
## [34] Tutor — reply
✅ Right idea. You described *what* is kept minimal, and the README's "useful for what" is the consequence: "There is almost nothing hiding the architecture" (line 858). You can open a message in any text editor, or even write one by hand, so your attention stays on who talks to whom rather than on a format library. The README also postpones Jackson on purpose ("Do not add it yet"). It comes back at Step 64, "Enter Jackson".
Step 13 done.
---
**Step 14 — The First Distributed-Systems Problem: Publication**
**Goal:** see the first problem that only exists because the parts are now separate processes sharing a directory.
**Do:** read README lines 862–935.
**Tell me:** in the five-step protocol, step 4 is "atomically rename it". Why rename a finished `.tmp` file, instead of simply writing straight to the `.msg` name? Use the README's closing sentence, "Writing and publishing are not the same operation", in your answer.
**Progress record**
- Current step: 14 — The First Distributed-Systems Problem: Publication
- Last observed result: Step 13 done (primitive format keeps the architecture visible; Jackson deferred to Step 64)
- Unresolved problem: none
- Next action: student reads Step 14 and explains why the protocol publishes by atomic rename
---
## [35] Student
> We want to avoid the reading of an unfinished msg, for that the courses' solution is to write inside a file (which can take time), then publish it by changing its name. Doing this way there is no risk to read a still writing file
## [35] Tutor — actions taken
- Read README lines 939–1004 (Step 15 "Observe a Mailbox with `WatchService`").
- Read `03-static-filesystem/ActuatorService.java` (watches `consoleOut/inbox`, prints the value of `TEXT` messages) and `Message.java` (record with an optional `timestamp`). `FileMessageBoard.watch` creates its mailbox directory itself, relative to where `java` is started.
- I have not run anything. The expected behaviour below comes from reading the code.
## [35] Tutor — reply
✅ Correct. Two precisions:
- **It takes both sides.** The rename is only half the protocol. Step 5 is "consumers react only to final files": if a reader also picked up `.tmp` files, the rename would protect nothing. Step 15 shows that half.
- **"Atomically"** means the rename is one indivisible filesystem operation. A reader sees either no `.msg` file or the complete one, never a half-written one. That's why the README keeps `.tmp` and `.msg` in the same directory, on the same filesystem. Bookmark: Step 23 is titled "Important: Syncthing Is Not a Shared Atomic Filesystem", so this guarantee gets questioned later.
Step 14 done.
---
**Step 15 — Observe a Mailbox with `WatchService`**
**Goal:** see the consumer half of the protocol working, using the "low-tech injection tool" the README suggests: publish a message by hand.
**Do:**
1. Read README lines 939–1002.
2. **Terminal 1**, from `ProcessControl/`, start a consumer. We borrow `ActuatorService` (Step 16 introduces it properly). It watches `messageBoard/consoleOut/inbox` and creates that directory if needed:
```bash
cd SIN.04028-From-Calling-to-Eventing/supplemental-java/03-static-filesystem
java ActuatorService.java
```
3. **Terminal 2**, same directory, create a complete message as `.tmp` first:
```bash
printf 'TEXT\nHello from a file' > messageBoard/consoleOut/inbox/manual.tmp
```
4. **Predict before continuing:** what should Terminal 1 show after step 3, and what after you rename the file to `.msg`?
5. Then rename it:
```bash
mv messageBoard/consoleOut/inbox/manual.tmp messageBoard/consoleOut/inbox/manual.msg
```
6. Repeat 3–5 with the other format from Step 13 (add a last line `TIMESTAMP: 2026-09-22T10:42:12.123Z`, and use a different file name).
**Tell me:** your prediction, what Terminal 1 showed after each command, and whether both formats worked. Stop the consumer with `Ctrl+C` when done.
**Progress record**
- Current step: 15 — Observe a Mailbox with `WatchService`
- Last observed result: Step 14 done (write ≠ publish; atomic rename + readers ignoring `.tmp`)
- Unresolved problem: none
- Next action: student injects messages by hand into `consoleOut/inbox` and reports what `ActuatorService` prints
---
## [36] Student
> the file is automatically read after the renaming (prediction + what actually happened), already done 6 too
## [36] Tutor — actions taken
- Read README lines 1006–1142 (Step 16 "The Three Services Become Separate Programs", Step 17 "The Mediator Becomes a Process").
- Read `SensorService.java`, `ProcessorService.java` and `Mediator.java` in `03-static-filesystem/`.
## [36] Tutor — reply
✅ Prediction and observation match, and both formats worked. Step 15 done.
What that little experiment shows: **you** were the producer, typing `printf` and `mv` by hand, and `ActuatorService` couldn't tell the difference. It only knows its own inbox, not who writes into it. Egoism survived the jump to separate processes. That's the README's diagram: producer → publish → filesystem → observation → consumer. "The mechanics will later change. The idea will not."
---
**Steps 16–17 — The Services and the Mediator Become Separate Programs**
Both are short, so take them together.
**Goal:** each capability becomes its own program, and the mediator becomes its own process too.
**Naming note:** the files are called `SensorService`, `ProcessorService` and `ActuatorService`, but the mailbox names don't change. Section 16 gives the mapping: sensor = ConsoleIn (`consoleIn/outbox`), processor = ROT13 (`rot13/inbox` → `rot13/outbox`), actuator = ConsoleOut (`consoleOut/inbox`).
**Do:** read README lines 1006–1140. Then open `Mediator.java` next to the other three files.
**Tell me:** section 17 points out something "slightly asymmetric" between the three services and the mediator. In your own words: what is the asymmetry, and what does "no name and no control mailbox of its own" mean for the mediator?
**Progress record**
- Current step: 16–17 — Separate programs / Mediator becomes a process
- Last observed result: Step 15 done (a hand-published `.msg` was printed by `ActuatorService` after the rename; both formats worked)
- Unresolved problem: none
- Next action: student reads Steps 16–17 and explains the mediator's asymmetry
---
## [37] Student
> the other process are launched via the mediator, however the mediator musst itself receive in some way the indication (in this case `from` and `to`), the course choose to do it via argument, but it should be done other way (like having all the mediator's informations inside of a config file, ...)
## [37] Tutor — actions taken
- None new. I compared the answer with `Mediator.java` (lines 1–19, already read), README lines 1128–1140 and Step 18 (lines 1144–1208: every process is started by hand in its own terminal).
## [37] Tutor — reply
**One correction first:** the mediator doesn't launch the other processes. Look at `Mediator.java`: it only watches `from` and publishes copies into `to`. In Step 18 you'll start all five processes yourself, each in its own terminal. Nobody launches anybody.
**The route arrives as startup arguments:** ✅ correct.
**"It should be done another way, e.g. a config file":** a reasonable idea, but notice that a config file is *also* read once at startup, just like arguments. The asymmetry the README points at isn't arguments vs. files. It's this:
- the three services receive their **work as messages in a mailbox**;
- the mediator receives its **route as startup configuration**, and it has no mailbox of its own that anyone could write to.
The README deliberately doesn't fix this yet: "Keep that observation. After you have seen what the distributed mediators cost…". So we don't redesign it now.
**One quick check (one line):** with `Mediator.java` as it is, how would you change the route of a mediator that is *already running*?
**Progress record**
- Current step: 16–17 — Separate programs / Mediator becomes a process
- Last observed result: route-via-arguments identified; misconception "the mediator launches the others" corrected; asymmetry restated as mailbox (services) vs startup configuration (mediator)
- Unresolved problem: none
- Next action: student says how a running mediator's route could be changed, then Step 18
---
## [38] Student
> i should rerun the command from what i see, the argument are just check at the start of the run, so a change means to restart it
## [38] Tutor — actions taken
- None new. Step 18 commands taken from README lines 1144–1208 (already read).
## [38] Tutor — reply
✅ Exactly. The arguments are read once at startup, so rewiring a running mediator means stopping it and starting it again with new arguments. Keep that in mind; it matters later. Steps 16–17 done.
---
**Step 18 — Run the Fully External Local Version**
**Goal:** run the whole chain as five separate processes talking only through the filesystem.
**Cleanup first (destructive, so check before running it):** the README starts with `rm -rf messageBoard`. That permanently deletes the `messageBoard/` directory *in your current directory*, including every message file in it. Right now it should only contain your hand-made test messages from Step 15. Check first:
```bash
cd SIN.04028-From-Calling-to-Eventing/supplemental-java/03-static-filesystem
pwd # must end in .../03-static-filesystem
ls -R messageBoard
```
If that shows only your test files, run `rm -rf messageBoard`. If you'd rather keep them, skip the cleanup. The watchers only react to *new* files, so old ones do no harm.
**Do:** open five terminals, all in `03-static-filesystem/`, and start them in this order:
| Terminal | Command |
|---|---|
| 1 | `java SensorService.java` |
| 2 | `java Mediator.java consoleIn/outbox rot13/inbox` |
| 3 | `java ProcessorService.java` |
| 4 | `java Mediator.java rot13/outbox consoleOut/inbox` |
| 5 | `java ActuatorService.java` |
Then type a line in **Terminal 1**.
**Look for:** where the result appears, and what each of the five terminals shows.
**Tell me:** what you typed, where the output appeared, and what the other terminals displayed. Stop everything with `Ctrl+C` when done.
**Progress record**
- Current step: 18 — Run the Fully External Local Version
- Last observed result: Steps 16–17 done (changing a running mediator's route = restart with new arguments)
- Unresolved problem: none
- Next action: student (optionally) cleans `messageBoard/`, runs the five processes and reports what each terminal shows
---
## [39] Student
> I've type `Hello World` in terminal 1 and the output showed up in terminal 5 as `Uryyb Jbeyq`, the 3 middle terminal didn't displayed anything new
## [39] Tutor — actions taken
- None.
## [39] Tutor — reply
✅ **Observed** matches the README: `Hello World` in Terminal 1 → `Uryyb Jbeyq` in Terminal 5, and nothing new in the three middle terminals. That's expected: the mediators print one "Mediating: …" line at startup, and `ProcessorService` prints nothing at all. They just move files.
Now count, as the README asks: **5 processes** to do what Step 1 did in one `main()` with one line. "Do not optimize this yet. We are not done making it painful."
Step 18 done, and with it **Part II**.
**Milestone check before Part III (one or two sentences):** in Step 8, the topology `ConsoleIn → ROT13 → ConsoleOut` lived in lines 79–85 of `main()`. Where does it live **now**, in the five-terminal version? And who knows it?
**Progress record**
- Current step: 18 done → Part II complete (milestone check pending)
- Last observed result: 5-process filesystem version works (`Hello World` → `Uryyb Jbeyq` in Terminal 5)
- Unresolved problem: none
- Next action: student says where the topology lives in the 5-process version and who knows it; then Part III (Step 19)
---
## [40] Student
> commit & push all the part II, but before that to add more readability split each file by part and add at the begining and the end of the file quick links to go from one part to another one.
## [40] Tutor — actions taken
- Interpreted "each file" as this conversation log. The README and the course sources were not touched.
- Split the former single `conv.md` at turn boundaries into `conv/00-setup-and-step-0.md` (turns 1–7), `conv/01-part-I.md` (turns 8–28) and `conv/02-part-II.md` (turns 29 onward). A turn goes into the part the student's message belongs to.
- Checked the split: the combined content of the three files is identical to the original log (same checksum after ignoring separators), and all 118 turn headings are still there.
- Added a navigation block at the top and bottom of each part file (previous · index · next, plus links to all parts). Turned `conv.md` into an index with a table of all parts and their status.
- Found an untracked `03-static-filesystem/messageBoard/` holding 4 runtime `.msg` files from the Step 18 run (one in each mailbox). It was **not** committed, since it's runtime data rather than Part II work.
- Committed and pushed (result in the reply).
- Result: commit `c5c86e9` pushed (`ad1a1f5..c5c86e9 main -> main`). `main` matches `origin/main`. Only `messageBoard/` stays untracked.
## [40] Tutor — reply
Done, committed and pushed as `c5c86e9`.
- `conv.md` is now an **index**: a table of all parts with links and status, plus the current position.
- The log itself is in `conv/`: `00-setup-and-step-0.md` (turns 1–7), `01-part-I.md` (turns 8–28), `02-part-II.md` (turns 29 onward).
- Each part file starts and ends with the same navigation block: previous · index · next, and links to every part. Parts not started yet appear as plain text in the index and get a file (and nav links) when we reach them.
- I checked the split: nothing was lost or changed. The combined content is identical to the old single file.
- Only the log was restructured. The README and course sources are untouched.
- **Not committed:** `03-static-filesystem/messageBoard/` (4 runtime `.msg` files from your Step 18 run). That's generated data, not Part II work. I can commit it, delete it, or add `messageBoard*/` to a `.gitignore`. Your call.
Back to the milestone check before Part III: in Step 8 the topology lived in lines 79–85 of `main()`. Where does it live now, in the five-terminal version, and who knows it?
**Progress record**
- Current step: end of Part II (milestone check pending)
- Last observed result: log split per part and pushed (`c5c86e9`)
- Unresolved problem: what to do with the untracked `messageBoard/` (student's call)
- Next action: student answers where the topology lives in the 5-process version; then Part III
---
## [41] Student
> commit it, as this i have an history of what we've made
## [41] Tutor — actions taken
- Viewed the 4 files in `03-static-filesystem/messageBoard/` before committing: plain-text `TEXT` messages from the Step 18 run (`Hello World` and `Uryyb Jbeyq`, with timestamps). Nothing sensitive.
- Logged this turn, then committed `messageBoard/` together with this log update. Not pushed (only a commit was requested).
- Result: commit `e079932` "Keep Step 18 message board as a record of the filesystem run" (4 `.msg` files + log). `main` is 1 commit ahead of `origin/main`.
## [41] Tutor — reply
Committed as `e079932`: the 4 message files from your Step 18 run, plus the log. Not pushed. `main` is 1 commit ahead of `origin/main`, so tell me when you want it pushed.
Heads-up for later: the README resets the board with `rm -rf messageBoard` before some runs. Because these files are now committed, that command will remove them from disk but not from git history. `git status` will then show them as deleted, and we'll decide at that point whether to record the deletion.
Back to the check before Part III: in Step 8 the topology lived in lines 79–85 of `main()`. In the five-terminal version, where does it live now, and who knows it?
**Progress record**
- Current step: end of Part II (check pending)
- Last observed result: `messageBoard/` committed (`e079932`, unpushed)
- Unresolved problem: none
- Next action: student says where the topology lives in the 5-process version; then Part III
---
## [42] Student
> you can push, then i'll start PIII
## [42] Tutor — actions taken
- `git push origin main` → `c5c86e9..e079932 main -> main`. `main` matches `origin/main`. This log update stays uncommitted, as usual.
- Read README lines 1212–1291 (Part III start: Step 19 "One Filesystem Is Not Yet Very Distributed", Step 20 "What Syncthing Is Doing for Us", start of Step 21).
- Read-only check: `syncthing` is **not installed** (`command -v syncthing` found nothing). Package `syncthing` 2.1.5-1 is available in Arch's `extra` repo.
- Schedule check: today is 22 Sep 2026. Part III falls in the inferred Parts II–VIII bucket, due by 29 Sep 2026. On time, no lecture.
## [42] Tutor — reply
Pushed: `c5c86e9..e079932 main -> main`.
## Part III — Make It Actually Distributed
**Schedule:** Part III is in the same bucket as Parts II–VIII, inferred due by **29 Sep 2026**. Today is 22 Sep, so you're on time.
The Part II check (where the topology lives in the five-terminal version) is still open. Answer it whenever you like. It comes back naturally at Step 27, "What Does Our Mediator Actually Contribute?".
**Steps 19–20 — One Filesystem Is Not Yet Very Distributed / What Syncthing Is Doing for Us**
**Goal:** go from five processes on *one* computer to processes on *several* computers, still talking through files.
**Do:** read README lines 1212–1286.
**Tell me:**
1. In your own words: why does the README insist Syncthing is **not** a message broker, even though our messages will travel through it?
2. A practical prerequisite for Step 21 onward: Syncthing isn't installed on this machine (`syncthing` 2.1.5 is in Arch's `extra` repo), and the steps need **at least two computers**. What machines can you use (a second PC, a laptop, a classmate's machine, a VM)? Don't install anything yet; just tell me what you have.
**Progress record**
- Current step: 19–20 (Part III)
- Last observed result: pushed `e079932`; Syncthing not installed (observed)
- Unresolved problem: Part II topology check still open (parked until Step 27 or whenever); machine setup for Syncthing unknown
- Next action: student reads Steps 19–20, explains why Syncthing isn't a broker, and says what machines are available
---
## [43] Student
> Sorry, forgot PII last question, each terminal make live a part (t1 the consoleIn, t2 the link between consoleIn and rot13, t3 rot13, t4 the link between rot13 and consoleOut, t5 consoleOut
## [43] Tutor — actions taken
- None. Compared the answer with `Mediator.java` (generic: route only from `arguments[0]`/`arguments[1]`) and the Step 18 commands. Logged here, in the Part II file, because the answer is about Part II.
## [43] Tutor — reply
No problem. ✅ The mapping is right: T1 ConsoleIn, T2 link ConsoleIn → ROT13, T3 ROT13, T4 link ROT13 → ConsoleOut, T5 ConsoleOut.
That answers *which process does what*. The question was also *where the topology lives and who knows it*. One pointer: open `Mediator.java`. Is `consoleIn/outbox → rot13/inbox` written anywhere in it, or in any other `.java` file? If not, where is that route actually written down, and who wrote it?
One line is enough. Answer it together with the two Part III questions (why Syncthing isn't a broker, and which machines you can use).
**Progress record**
- Current step: 19–20 (Part III); Part II check partly answered
- Last observed result: student mapped the five terminals to their roles correctly
- Unresolved problem: "where the topology lives / who knows it" not yet answered; machines for Syncthing unknown
- Next action: student says where the route is written and who wrote it, plus the Step 19–20 answers
---
## [44] Student
> no, it is written by hand when running Mediator.java <from> <to>
## [44] Tutor — actions taken
- None.
## [44] Tutor — reply
✅ Exactly. No `.java` file contains the route any more. It exists only in the commands **you** typed in Terminals 2 and 4. So the one who knows the topology is **the person starting the processes**.
That completes the arc since Step 1:
- **Step 1:** topology inside the capability code (`IO.println(rot13(text))`).
- **Step 8:** topology in `main()`, lines 79–85, as mailbox-name pairs.
- **Step 18:** topology outside all code, in the operator's command lines.
Each time it moved *away* from the capabilities. It never disappeared. (Bookmark: Step 27 has a subsection titled "Let an Orchestrator Supply the Topology".)
**Part II check done.** Still open, for Part III:
1. Why is Syncthing **not** a message broker, even though messages travel through it?
2. Which machines can you use for Syncthing?
**Progress record**
- Current step: 19–20 (Part III)
- Last observed result: Part II check done (topology lives in the hand-typed `Mediator.java <from> <to>` commands; the operator knows it)
- Unresolved problem: machines for Syncthing unknown
- Next action: student answers the two Step 19–20 questions
---
<!-- nav -->
> [⬅ Previous: Part I](01-part-I.md) · [Index](../conv.md) · [Next: Part III ➡](03-part-III.md)
>
> All parts: [Setup & Step 0](00-setup-and-step-0.md) · [Part I](01-part-I.md) · **Part II** · [Part III](03-part-III.md) · [Part IV](04-part-IV.md) · [Part V](05-part-V.md) · [Part VI](06-part-VI.md)
<!-- /nav -->