User:Hhhippo/Flow/Flexibility

Background

The main difference between Flow and classic talk pages is that Flow stores text on a per-post base instead of the per-page base we're used to. While this data model opens up many new possibilities for software support of structured discussions, it also comes with some challenges, since it doesn't naturally support edits with a scope wider than the content of a single post.

In order for Flow to be able to replace the existing talk page system, it needs to enable and support everything that's currently done on talk pages. We can live with some exotic use cases becoming more cumbersome, but common tasks should be as easy as or easier than they are now. Ideally, there should not be one specialized software function for each use case, but rather a set of a few general-purpose tools which together support a large number of use cases. If this tool-set is made flexible enough, it will reduce or even remove the immediate need for additional workflow modules within Flow.

In my view, making Flow flexible enough to enable everything we do on classic talk pages requires at least these three major components:

• a wiki-style environment within each post,
• tools for refactoring a discussion, and
• tools for adapting the layout of posts.

Wiki-style posts

While Flow posts are already now composed in wikitext, there's a couple of minor and less minor details that need to be investigated/implemented:

• Restrictions due to the use of parsoid need to be evaluated.
• The restricted width of Flow posts needs to be revisited.
• Support for categories (this is probably more relevant for board or topic headers than for individual posts)
• Support for substituting templates (do we need proper transclusion as well?)
• Editing posts must be generally possible, also for other editors than the original author. Where needed, this can be limited by protection (which could optionally not affect the original author). Turning it off entirely, as it is now, blocks major use cases.

Refactoring discussions

There are various common types of talk page edits that affect more than one post. Many of those are in principle possible even in Flow by removing and re-creating the posts in question, but this would be unreasonably cumbersome and defeating the auto-attribution feature. Therefore a couple of functions are needed which together provide easy access to all common use cases.

Splitting posts

This could for example be initiated by inserting a magic word like <split>. All (two or more) posts resulting from the split would be attributed to the original author, be marked as edited by the splitting editor, and share the post history up to the split entry. Existing replies would be attached to the last part (unless moved afterwards).

Using a magic word instead of a UI feature will retain the flexibility that comes with wikitext. For example, this magic word could be part of a substituted template that allows to start an RfC by submitting a single post, which upon saving turns into separate posts holding the framework for the RfC, including the outline of the question to be discussed and several subsection headers, each of them comprising one 'post'.

As additional bells and whistles one could think of gadgets for semi-automatically inserting split tags, e.g. around subsection headers or in front of bullet points. The latter would simplify interleaved responses as they are common for reviews.

Moving posts

'Moving' here means assigning a reply to another parent post. This can be necessary after accidentally using the wrong reply-link, to move a side-chain under a newly created subheading, or to assign a reply to a different part of a split post. Moving will leave an entry in the post history which links to the old and new parents, and mark the post as edited by the mover.

Undo

One of the strengths of wikitext is that (nearly) every action can be easily undone, so Flow should support that, too. For actions within a post that's easy (though not yet implemented), for cross-post actions it's a bit more tricky. A possible solution could be to represent such complex actions internally by a bunch of simple actions, linked to by one meta-action. For example, splitting a post in two would be composed of (a) creating a new post with the first half of the original content, and (b) editing the original post to remove that part. Undoing the split would be composed of (a) moving all reply chains to the second half, (b) adding the content of the first half to the second half, and (c) hiding the first half. With some more fine-tuning, this should allow one-click undo and redo functions with full history, as we have them now.

Changing post layout

For many use cases Flow's current post layout is unfeasible and in particular far too space-consuming, an obvious example being simple polls with very short single-line replies. (Another example: an easy way to implement subsection headers could be to allow posts which by default only show just that header and the "..." menu, but nothing else.) Instead of designing a specific workflow for each of these use cases, we should have the possibility to change the layout of individual posts. Like for splitting posts, this would ideally be controlled by magic words within the post's wikitext (comparable e.g. to the existing __NOTOC__) rather than by UI elements like the "..." menu. These magic words could again be put in templates, allowing for on-wiki development of specialized tools from the basic toolset provided by Flow. Such layout changes should be optionally inheritable, meaning that a parent post can set defaults for all its children (replies), which the children then can individually override if needed.

Possible candidates for such layout changes are

• hiding of metadata elements like author, timestamp, etc. (they could be made visible when hovering over the post's "..." menu)
• changing the placement of elements (e.g. to show keywords like "keep", "delete" or "support" prominently as the first item in a post, and the author later)
• showing additional elements (e.g. an edit form for replying to a subsection, placed below all existing replies, removing the need to scroll up to reply to a popular poll after reading the existing !votes)
• setting sidechains to "collapsed by default" (see Compact nesting), optionally with a custom hatnote
• setting background colors or borders (together with hiding the reply-links, this could replace and customize the currently hard-coded "close" feature)

Example: a top-level "post" within an RfC topic could show "Support" as a <h3>...</h3> heading without author or timestamp, set the default layout for replies to a compact one-line form, and activate a [Reply to "Support"] field below all replies. The standard [Reply to "topic title"] field could at the same time be hidden by a magic word in the topic header.

To achieve this, one could think of

• Magic words like __NOTOC__ that hide UI elements, namely
  • The post header (containing the author and the "..." menu, the latter would move to the end of the post content box if the header is hidden)
  • The post footer (containing "reply", "thanks" and the timestamp(s))
  • The topic's "reply" editbox.

The actual post contents and the "..." menu can't be hidden.

• Magic words like __TOC__ that add UI elements at the place within the content box where the magic word is used.

The combination of the two would allow for re-arranging UI elements, for example moving the author name to the end of the post. This way of inserting elements is hard to make inheritable, but not impossible: One could specify an inheritable magic word <wrapper=...>, which passes all text in the children's content box through a specified wikitext template (or Lua module), which then, in the example above, returns that text with the author element added.