Reading, writing and answering a debate

A debate starts with one contribution and grows downwards. Every answer hangs on the sentence it answers, so what you read is not a list of postings but a tree.

What a debate is made of

• Segments. On publication every contribution is split into segments — roughly one per sentence, plus one per heading and per list item. A segment is the smallest thing anybody can answer or link to. Where exactly a segment ends is explained under Writing a contribution.
• Parties. Everybody taking part in one debate does so as a party, identified by a short role-token: a for the party that opened the debate, then b, c, d ... in the order they joined; after z they continue with two letters, aa, ab and so on. One account is one party per debate, and its role-token holds for that debate only.
• Keys. Every contribution has a key that spells out where it hangs: a2b1c reads as "the party c answers segment 1 of the contribution a2b, which is party b's answer to segment 2 of the opening contribution a". The key stands at the top left of every contribution, with its last letter — the party — in bold. An answer to several adjacent segments is written a5-7b (party b answers segments 5 to 7 of contribution a), one to single words inside a segment a7_4-8b (words 4 to 8 of segment a7). Both are counted on the text file in the repository, not on the rendered page, so that anyone can check what a word reference points at by reading the file.

Reading

A debate opens folded: you see the opening contribution and nothing else. The counter in the header bar says which level is currently unfolded, e.g. 0/4 — level 0 of a debate that is four levels deep.

• « and » in the header bar unfold one more level or fold one back. The arrow keys ← and → do the same.
• Clicking a segment unfolds exactly the answers to that segment, and opens a small bar above them. The bar names the segment, the level of the answers below it, and how much is going on there (see the next section). It also holds Copy link — the link points at this one sentence — and Reply. The x closes the segment again.
• Selecting words inside a segment brings up Copy and Reply, and the reply then refers to exactly those words rather than to the whole segment.

Each contribution carries a label at its top: key, party, the account behind it, and two chips on the right — one copies the contribution's text with a link to it as the source, the other leads to the integrity page, where the fingerprint of this contribution and the commit chain of the debate can be checked.

The activity marker

At the end of every segment that has been answered sits a small red mark. It is a stack of rows, and it tells you how much is going on below that segment without your having to unfold it:

• one row per answering party — at most three, the longest row on top;
• the length of a row — how many answers that party wrote below this segment. Four lengths: one answer, a few (2-3), several (4-7), many (8 or more).
• a thin line under the stack — there is a fourth party, and possibly more. It does not say how many.
• how dark the red is — how deep the branch below the segment goes. The darkest shade means four levels or deeper.

So the total amount of ink is the volume of the discussion, and the shape says how it is distributed: an uneven stack means one party is doing most of the talking, an even one that the parties are answering each other.

Green instead of red means something else entirely: an unpublished draft of your own is sitting below that segment. Only you ever see that.

The same three numbers are written out as a triple (p|a|d) — answering parties, answers, depth — in two places: in the tooltip of the segment itself, and as a chip in the bar that opens when you click the segment. (2|5|3) therefore means: two parties, five answers, and the deepest of them sits three levels below this segment.

Two things worth knowing about these numbers:

• Folding does not change them. They say what is down there, whether or not it is on screen — otherwise they would jitter while you unfold.
• The party filter does change them. A party you have switched off is not part of the debate you are looking at, so its answers stop counting, and the marker disappears altogether once nothing visible is left below the segment.

The triple in the debate's header bar is the same idea for the debate as a whole, but counted differently: there the opening party counts too, and the depth is the absolute level of the deepest answer.

Narrowing the view

Under the debate title stands the party legend, one entry per party. Clicking an entry hides that party's contributions, clicking again brings them back. Every party label in the debate offers the same in words:

• show only answers from this party — the whole debate reduced to one party in a single click;
• hide answers from this party — the opposite;
• show only this answer — narrows the view to one contribution and the chain it hangs in, with everything else folded away;
• invert swaps hidden and shown parties, show all undoes all of it.

context: on (the default) keeps the contributions that hidden parties wrote but that visible answers hang under — dimmed, as scaffolding, so an answer does not lose the sentence it answers. context: off hides them together with everything below them.

The opening party cannot be hidden, and your own party is marked (you) so you do not switch yourself off by accident. All of this is local: it changes what your browser shows, is stored there, and nobody else sees it.

Answering

Answering needs an account; reading does not.

1. Choose what you answer. Click a segment and then Reply. Or select text: the small bar that appears always offers Copy, and offers one of two ways to answer, depending on what the selection covers. Inside a single segment it is Reply, and the answer refers to exactly the words you marked. Across segment boundaries there is no such exact reference, so the bar offers to round the selection up to whole segments instead — and writes out which ones, for instance Reply to a3-6, so you can read what you are about to answer before you press. A selection that cannot become a reference at all, because it reaches into another contribution's text, offers no answer button; mark a different stretch. The same range can also be had without selecting: click a segment, then Shift+click a second one of the same contribution. Selecting every word of a segment is not a third thing: it refers to the segment, exactly as clicking it does.
2. Write. The text is markdown — see Writing a contribution, which also explains how to force a segment break where the automatic split gets a sentence wrong.
3. Create the draft. Nothing is saved before you click Create draft. The draft is visible to you alone; other readers see nothing at all.
4. Publish. Publish on the draft, or Publish all in the bar at the bottom of the page if several are pending. Publishing writes a commit into the debate's repository. A published contribution can no longer be edited or deleted — while it is still a draft, Edit draft and Delete are open to you.

Two rules follow from the shape of the tree:

• One answer per party and reference. If you have already answered a segment, change that answer instead of writing a second one. As long as it is a draft, Edit draft does it; once published, a correction is an answer to yourself. Two different references to the same segment are two answers and stay allowed — a reply to a few words of it says something else than a reply to all of it.
• Answering yourself is allowed and is marked as a self-reply. It is the intended way to correct or qualify your own contribution afterwards — see the rules of engagement.

Which party you write as is decided when you first contribute: in a debate you have not taken part in yet you join as a new party and are given the next free role-token; after that every further contribution of yours in that debate carries the same one.

Creating a debate

New debate in the main menu, or /new/, asks for three things:

• a name. It becomes part of the URL and is prefixed with an id, so "Speed limit!" turns into something like d42-speed-limit. The name need not be unique — if it already exists you are told so and can confirm.

• the access mode. Five of them, each with an icon of its own next to the debate's title:

  • Public (open floor) (globe) – listed and readable for everyone; any logged-in user can answer.
  • Public (panel) (globe over a bar) – listed and readable for everyone; only the parties and the people you invite can answer.
  • Hidden (open floor) (crossed-out globe) – not listed, readable for everyone with the link; any logged-in user can answer.
  • Hidden (panel) (crossed-out globe over a bar) – not listed, readable for everyone with the link; only the parties and the people you invite can answer.
  • Private (padlock) – only the parties and the people they invite can read and answer (see below).

  Only moderation can change the mode afterwards. On a debate page, help mode explains the icon of the debate at hand. - the opening contribution, in markdown. It becomes contribution a, and you become party a of the debate.

The debate is created as a draft: it exists, but nobody else can read it until you publish that first contribution. That is the moment the debate's repository gets its first commit — and from then on, everything above applies.

Inviting somebody into a private debate

A private debate is readable for its parties only, and a party comes about by writing — so somebody who is meant to answer there has to be let in first. The party that opened the debate finds Invite someone to this private debate on its page. It hands out a link: whoever opens it is shown what accepting means and, after accepting, can read the debate and answer in it. It does not make them a party: the role-token — the letter that marks every contribution of a party and cannot be given back — still follows from the first answer they write.

One link, one person. Accepting spends it, so a link forwarded after that admits nobody. Invite three people and you create three links, each revocable on its own. Hand out one per person, then a link that goes astray costs at most that single invitation — and until it is accepted, whoever holds it can use it, so treat it like a key and not like an address.

This is where private and hidden part company. A hidden debate is readable by everyone who has its address, and an address travels without limit and leaves no trace. A private debate is opened account by account: each admission spends an invitation that a party had to issue, the parties see who is inside, and they can remove a reader who has not written yet. What none of this can undo is reading itself — whoever has read the debate has read it, which is why private is a decision about who is let in and not a guarantee of secrecy (see the terms of use).

Who may invite. During the beta phase, the opening party and the moderation — not the other parties. That is the one place where the parties of a debate are not equal, and it is a deliberate bound rather than a ranking: somebody who is let in and writes becomes a party themselves, so a right to invite held by every party would let each admission widen the circle that admits the next one. Held by the party that opened the debate, the question of who let somebody in has an answer that does not run down a chain. As another party, ask them — or the moderation, which can issue an invitation too. Moderation can read every private debate anyway, so this grants it nothing new to see; what it is for is the case where the opening party cannot be reached. Who issued an invitation and who accepted it is recorded either way.

Panel debates. The same links open a debate in one of the two panel modes – there for answering, since reading needs no invitation. The opening party finds Invite someone to answer in this debate on the debate page; everything above about one link per person, revoking and removing applies unchanged. Removing an invited person takes the right to answer away again, as long as they have not written.

Writing a contribution¶

Contributions are written in Markdown. The segments described above are cut out of that text when it is published, so the way it is written decides where they end — and with that, what anybody can answer on its own.

Where a segment ends

Every heading and every list item starts a segment of its own. Inside a paragraph or a list item a segment ends at ., !, ? or : — but only if a space follows, or if the paragraph ends there. That holds inside bold or italic text as well: a bold paragraph of two sentences is two segments, while one sentence with a highlighted word in it stays one.

Some dots deliberately do not end a segment, because they usually do not end a sentence:

• a dot directly after a digit: until the end of 2026., 3.14, 24.12.2026, v1.2
• a dot with no space after it: example.com
• common abbreviations: e.g., i.e., cf., vs., z.B., vgl., u.a. — also when written with a space (z. B.)
• etc., usw., o.ä. and their kin end a segment only when the next word begins with a capital letter

Forcing a break: \@

Sometimes such a dot really is the end of a sentence. Write \@ directly in front of it and the segment ends there after all:

... until the end of 2026\@. Any dilution of the target ...

Without the marker both sentences form a single segment, and nobody can answer the second one on its own. The marker works in front of !, ? and : as well, and it overrides an abbreviation too: z.B\@. ends the segment.

The marker is not visible in the published contribution — it is removed when the text is rendered. It stays in the stored file, where it shows why the segment ends at that point.

Preventing a break: \~

The other way round: a dot that ends a segment although it should not. The list of abbreviations above is short and will stay short — Prof., Fig., Sec. and most others are not in it, and every entry added to it is also one more reason for a real sentence end not to break. Write \~ directly in front of the dot and the sentence stays together:

Prof\~. Miller has said so.

Like \@ the marker has to touch the punctuation mark, it works in front of !, ? and : as well, and it disappears when the text is rendered.

Markdown

• *emphasis* and **bold**
• headings: #, ##, ###
• lists: - item, or 1. for a numbered one — a line starting like that begins a list, even directly below a paragraph
• links: [text](https://example.org)
• `code` inline, and a code block between two lines of three backticks (```)
• a quotation: > quoted text
• a horizontal rule: ---

Other formatting may be dropped when the text is rendered — if something does not appear on the page, that is the reason.

HTML tags are not allowed, apart from <b>, <strong>, <i>, <em>, <a>, <code>, <br> and <img>. A contribution holding another one cannot be sent; you are told which tag it is. Inside inline code or a code block, HTML is just code and fine.

When something is unclear

Every page has a help mode: the ⓘ symbol in the header, or the i key. In it, clicking any element explains it, and ← / → step through the explanations one at a time. i or Escape leaves it again.