This is something that's been requested and worked on for a very long time, and should help a lot with the consistency of tags that people use on topics. It's also another significant feature that's been added by an open-source contributor: Shane Moore (whose Tildes username I actually don't even know) has been working on this on and off since last July, and has put up with me being slow to review and requesting some major changes to it over that time.

It applies to both the tagging field for new topics as well as the one for editing existing topics' tags, and the list of tags that show up for autocompletion are the 100 most commonly-used tags in each individual group (so the suggestions are different between ~tech and ~music and so on). This is just based on pure frequency at the moment (as in, the 100 tags that are on the most topics in that group), but in the future we could probably improve this to specifically include tags that have been getting used more recently, instead of looking at all time.

The interface can probably still use some work, and it's likely that there are some bugs and other issues with it, but as I've said before, Tildes is supposed to be in alpha! I haven't been adding nearly enough frustrating issues or breaking things, and we're all getting complacent with having a site where most things work!

Let me know what you think of it, and if you notice any issues. And thanks again for all the work and patience, Shane!

We've had an experimental method of avoiding deeply nested comment threads in effect for a little over a week now, and while I think it's useful in some ways, it's definitely also pretty confusing in some cases (as multiple people have pointed out to me).

I've made two changes to it now that should help quite a bit:

1. The flattening will now only happen when there won't be any "sibling" comments after the flattened thread.

   This is to avoid what seemed to be the most confusing case (it's a bit difficult to explain, but I'll try): Previously, you could have a thread where a comment has a few replies ("A", "B", "C"), and the first one has a string of single replies ("A2", "A3", "A4"). If the flattening applied, you would have all 6 comments displayed on the same level, in the order of A, A2, A3, A4, B, C. It was very difficult to tell where the "A subtree" ended and it went back to siblings of A—you had to look for where comments stopped having the "(Reply to above comment)" note on them.

   Some people suggested that we use a more obvious indicator of the flattened threads (which might still be a good idea), but this case should now be avoided entirely, which should reduce a lot of the potential confusion when threads are flattened. This also means that the flattening will apply in fewer cases overall, but it should still work for the most common and impactful case of a long string of single replies going back and forth.

2. As mentioned in the original announcement, one of the nice parts of managing to do the flattening entirely in CSS means that it could easily start at higher thresholds on larger screens, so that threads aren't flattened as early on desktop/laptop-size screens as they are on mobile. I've applied this now, and it should now be very rare to see a flattened thread if you're using the site on a PC.

   If you want to see this in action, you can go to a thread where flattening would apply (the ~tildes.official thread about "source info" is still a good one), and try resizing your browser window to see how the flattening kicks in and adjusts at different sizes. If you're using Firefox, an easy way to try this out is to press Ctrl-Shift-M to go into responsive design mode, and you can easily resize the viewport or set it to specific sizes.

Other than these changes to the flattening behavior, I've also merged in another open-source contribution that adds alternate sorting methods on the user page. These only appear when you're on the Topics or Comments listings (not the default "mixed" page), and allow you to sort by the other methods available, such as "most votes". Note that since those Topics/Comments pages are only available to logged-in users, viewers without a Tildes account won't be able to use these alternate sortings. Thanks for the work on this, JediBurrell (whose Tildes username I don't know either)!

Let me know what you think of these changes and if you notice any issues with either of them.

One of the difficulties with a nested/tree commenting system is finding a way to deal with threads that get very "deep", when people continue replying back and forth under the same threads. The deep threads end up getting indented very far, and this looks bad, can be hard to follow, and wastes a ton of space (especially on smaller screens like phones).

I'm not a huge fan of any of the ways that I've seen other sites try to handle this, so I've been trying to figure out if there might be any other possibilities that would work well. I've noticed that in most of the cases where a thread gets very deep, a lot of the depth comes from back-and-forth replies, where there's only one comment on each "level". So I'm testing a method that will flatten those sections out and just put a note on each comment that it's a direct reply to the comment above it.

Specifically, the current method (which is now live), works like this: if a comment is at least 4 levels deep and only has a single reply, don't indent the reply any further. Instead, keep the reply at the same indentation and add a note at the top of it indicating that it's a reply to the above comment.

I managed to implement this entirely through CSS, by writing what's probably the worst best chunk of CSS (really, SASS) of my life, which I want to show off here. If you don't know CSS and can't read this, trust me, you're better off:

.comment:not([data-comment-depth="0"]):not([data-comment-depth="1"]):not([data-comment-depth="2"]):not([data-comment-depth="3"]) {
  &[data-comment-replies="1"] {
    & > .comment-tree-replies {
      margin-left: -1px;  // compensate for border

      & > .comment-tree-item > .comment > .comment-itself {
        & > .comment-text::before,
        & > header > .is-comment-deleted::before,
        & > header > .is-comment-removed::before {
          content: "(Reply to above comment)";
          font-size: 0.6rem;
          font-style: italic;
          margin-right: 0.2rem;
        }
      }
    }
  }
}

One of the really interesting things about implementing this entirely in CSS is that we can easily change what level it happens at based on screen size. So I have it set to always start at depth >= 4 right now to help with testing and deciding whether it works well or not, but if we decide to keep it I could easily change the threshold to higher on desktop and keep it lower on smaller screens.

As an example of how it works, the previous ~tildes.official thread works really well. @Amarok and @cfabbro had a long discussion about music metadata that went very deep. The thread ends up 16 levels deep, but this new change makes it so that it only indents by 5 levels instead of 16. Here's a comparison between how the end of the thread looks on my phone: before this change vs. after this change (yes, something's not quite right with the indentation lines yet).

Let me know what you think. I'm mostly concerned that this might make it a little harder to follow long threads since the information from the indentation is lost, but I think we need to test it out in real threads for a while to see if that actually ends up being significant or just takes a bit of getting used to.