I've had certain forum software sometimes as a side project, sometimes as my man full time project, during the last 7 years. So yes there's lots of work. But in my case lots of time was "lost", in learning web development / React.js / Angular / Dart / other stuff, and porting from the-wrong-technology, to another the-wrong-technology, and building the wrong things that no one wanted.

I think the Discourse (forum software) team were a few people, like, 3? and they spent some year(s) developing the initial version of Discourse. So ... yes some weeks/weekend? for the initial version, and ... >= 3 years ? for a "real" version :- P

Is your software anywhere online, e.g. GitHub?

IIRC, Jeff Atwood of Discourse said it takes at least three years for a project to finally approach the objectives that it set out to achieve (or something). I'm sure he was referring to his experience with Discourse and Stack Exchange at the very least.

I might have butchered that, but three years has been my experience as well. I chuckled when I read that post because the three year mark was finally when I looked back on my forum, felt somewhat content with it, and went "holy shit, that took a while".

My forum had active users from day one since I was porting vBulletin to my own stack. I actually used Clojure + Datomic for the first iteration and rewrote it to Node + Postgres a year later.

As developers it's easy for us to go "3 years? Psh! What are you doing all that time!" because we like to pretend everything is just a pure technical problem and consistently underestimate the work. I certainly wasn't working on my forum for 3 years full time.

It was a hobby balanced on community building and creating a compelling experience for my users. It took a week to build the initial release where people could actually register and post. From there I'd burst a week of full-time development work into it every 1-3 months.

I'm glad I experienced this journey, though bless my poor users that had to wait on me to implement basic conveniences over the years. I can say with certainty that I will never go "hah, that looks easy!" ever again.

Curious - why did you move from Clojure/Datomic to Node/Postgres?

I had used Datomic on my previous hobby project, so when I had to pick a database for my forum rewrite, it was what I was most comfortable with and it was also just fun to use.

For example, I figured I could use its transaction querying for post edit history. Datalog made it trivial to jump arbitrarily through any relationship. And transactor functions were trivial to write at a time when I had never written a Postgres trigger function.

I didn't apply much professional due process here because I looked at my forum rewrite as a hobby project. It's not like I was being paid.

However, over the course of that year, my forum suffered due to my hobby-level understanding of Datomic.

For example, I had the forum application, the Datomic transactor, and the Datomic client running on one Linode machine. I told myself I'd figure out how to host Datomic on AWS in the future, but of course that never happened.

As the forum grew in size, I started dreading restarting my application because the Datomic client would have to sync with the database. It started to take many minutes. And I didn't have enough information to know why -- is this just I/O limitations of loading info into the process? Or was the fact that hundreds of users were F5'ing the server? I never made myself a real deploy system either. I would manually ssh in, `tmux a`, `git pull`, and manually restart my processes. Very amateurish, but it was so easy to say that I'd fix it in the future.

I also made mistakes like having zero insight into my application. My application was growing slower over time, but I didn't know why. I had some really slow database queries and I was still using LIMIT/OFFSET for pagination at this time.

I also found out that Datomic isn't made for massive blocks of text like forum posts. When I saw that Datomic had full-text search, I assumed that meant otherwise.

A year went by and I started to get stressed out about the forum. I had this crippling guilt that I even tried to build a forum from scratch instead of just using Xenforo. Felt bad for my users who were hanging in there or just leaving out of frustration.

One of the reasons I rolled my own forum aside from thinking that it would be easy was that it would also be cheaper. I was spending like $500/mo on the forum when I was using vBulletin and I was frustrated that I couldn't do much to change that. By my hand-rolled forum cost 1/5th of that, so at least I had that going for me.

During all this, I started working with a friend on a different project and he refused to use Clojure. We ended up with Node + Postgres and he was a Postgres pro who I learned a lot from.

Before long, I had a full Node + Postgres application under my belt and decided to rewrite my Clojure + Datomic forum. I could have swapped out Datomic for Postgres instead of throwing the baby away with the bathwater, but I wasn't convinced that that would be any less work.

I also decided to host my rewrite on Heroku this time to force myself to rewrite the forum in a more stateless way. For example, my Clojure forum had a hard dependency on the filesystem. Not to mention having the database on the same machine meant I'd never be able to spin up another application server.

Of course, any time you rewrite something, you have the opportunity to fix your legacy mistakes from day one which I did. For example, I finally optimized pagination away from LIMIT/OFFSET. I got to clean up a lot of cruft. I also used RDS for Postgres which solved all my database problems. I really had no business using Datomic since I had such a weak understanding of its trade-offs.

I think the lesson here is to stay away from frameworks as much as possible.

It was other things than frameworks too — also databases, and (to some degree) programming languages. For example, I started with using only file based storage. Then I switched to Oracle — because I needed to learn Oracle better, beause of some contracting work I did, and then from Oracle to PostgreSQL. & I tested Dart (a programming language) too (and Angular-Dart).

Actually now in the end, I've found some frameworks that I like (love?) and ... without them, I'm afraid everything would instead have beeen a terrible mess. These frameworks help me structure the code and reduce my total amount of code: React.js, and Play Framework, and Nginx + some Lua (instead of doing everything in the app server).

My personal lesson is ... Do use frameworks but not the wrong ones :-) and it can take long to undo a use-the-wrong-stuff decision.

Well this @mention is a bit more complicated than what one might think. For example: If someone creates a post, without any @mention, then edits it, and adds a @mention — then, do you detect this, when looking at the edits, and send a @mention notification now? And what if s/he edits the post again, and removes the @mention, then, do you remove the notification? Cancel the email if it hasn't been sent yet? And if the email has been sent, and the user clicks the link, and views the post — but the @mentioned user sees no @mention because it was removed, then ... this is not good UX. Should you do something about this? Explain that the @mention got removed? Or just leave the user slightly confused?

Also, do you really want to send an email for a @mention immediately? What if the user who writes the post, keeps editing it, after having saved it? Should you wait for a minute or two, until s/he seems to be done editing it? And then generate the @mention email? Or directly, even if then an early out-of-date version of the post will be included in the email.

What if the @mentioned user is in do-not-disturb mode, then you need to schedule the notification for later.

And what if the @mentioned user is already online and sees the post with the @mention in, diriectly? Then maybe you needn't generate any notification at all. But how do you determine what s/he is reading currently?

There's a lot to think about (more than what I mentioned above) that one might not think about, ... before one starts implementing everything. — And this is just for @mentions. ... Kind of goes on like this, with every small seemingly simple feature you want to add.

It's a forum. Read the thread and don't have any such concept as a "mention". If you get quoted, you'll see it as you go through the pages. If you're really lazy just namesearch your handle (which may or may not change, may or may not be unique, etc) but basically participate don't just cherrypick.

I hate most modern forum software with a passion.

Right, but you would just be one of the rare users that turns the system off. Which is fine, but don't let it blind you to what the typical user wants.

"Just use the /search feature to find replies" isn't something I can say with a straight face to the sort of users I have. I would just leak them to competing forums that have good UX. It's no ideal for someone to be unaware that a thoughtful reply was made to a post they invested in.

If they were so invested they'd be reading the thread for people who are communicating about the topic. For people who are referring to comments or quoting other posts or didn't specifically @mention to drag a person back to look STRAIGHT AWAY lest they lose engagement.

@mentions on forums are good UX in the way that twitter @mentions are good UX - they drive clicks and opens - not engagement. They don't push good content, good conversations, good experiences. They allow people to sandbox discussions, to talk across each other. To skip volumes of content to just get their little piece.

Having the feature degrades the forum community imo, irrespective of who does and does not use it.

I'm a guy who likes old school forums though, so, you know, my opinion is probably not worth that much ;)

Seems you've had a bad experience with mentions. Maybe people have been using them in the wrong way, where you've seen them.

At work, we were using Slack, and @mentioned each other "all the time", and I'm fairly positive we would have abandoned Slack if people couldn't mention each other. Mentions are like going to the other person, and saying, "Hi, look there, you knowledeg & help is needed over here a short while". And then the other person takes a look, replies with help or status update for example.

Our mentions were related to none of driving clicks or opens or engagemenet — instead, it was about getting work done, directly rather than ... some day later when the person happened to maybe see the relevant comments.

Then you're now talking about Slack instead of a forum. They're distinct entities, with distinct purposes.

Or not, maybe the line is so blurred by now that people can't handle actual forums anymore. If I wanted a chatroom though, I'd be in a chatroom.

Exactly. Great post.

Can someone @mention (and thus notify) everyone on the forum in one post? Of course not, just take the first 6 unique mentions.

But what if they edit their post and @mention 6 different people? Easy, edits don't trigger notifications. Well, what if someone forgot to mention someone or typo'd someone's name and they just want to make that edit. Seems pretty lame that they can't fix their mentions.

So if you want to allow the latter but not the former, you need to start tracking historical mentions per post in the database. Which you needed anyway so that someone can't @mention, delete the @mention, and then @mention again to trigger dupe notifications.

And what does the notification actually look like if someone edits a one-week-old post to add a @mention? It's kinda confusing for a user to see "Foo mentioned you in post #123", click the link, and see that the post is a week old. They report it as a forum bug. So maybe you now have some logic that sends a notification with "Foo edited post #123 to mention you." Yet another if-statement.

We both could go on and on.

And this is how every feature goes. They are hard problems without a best solution, only trade-offs.

At least if you're building a generalized forum like phpbb, you're solving a problem that will compound across thousands of users deploying your forum software. Meanwhile my forum was completely bespoke for my community and I couldn't shake the feeling that I was wasting my time.

So then it was tempting to wonder if I should work on generalizing my forum so others could use it. Well, now you're even in the bigger hell of generalizing software in a pond with dozens of formidable competitors in a world where you're pretty certain that traditional forums are slowly dying. Good luck with that.

What if the @mention user decides to change his/her display name, now you need to parse @mention into a unique id and save that in the database with comment body and then translate it back when you serve it to the currently chosen @mention name...

Why would you allow users to change their display name? It's a forum, not social media.

Of course it's social media. The username and avatar is one's social identity on a forum. I think you have a very narrow experience with forums if you find it surprising that someone wants to change their username if you accept that they would also want to change their avatar.

Checkout Remarkbox, I generate them a random display name when they sign up and then allow them to change their display name later.

Regardless of the type of application, why would you not want a user to be able to change their display name?

If I was able to change my display name on hacker news, I think I would.

If you want requirements you gotta write 'em yourself~

Adding more complexity to the example - what about offering a digest-format where a user opts in to only receiving one email a day.

I don't think OP said his project was slow or bloated: just that it was a lot of work to implement the extra little features.

A good example of "the devil's in the details" is the decision chart of how Slack decides whether to send a notification for a particular message.

I mean, how complicated could it be, if the user is in the channel and he doesn't have notifications turned off, then send it, it's just a simple nested if statement, right?

But, it turns out that when you map out all of the decision points, it's quite a bit more complicated.

https://twitter.com/mathowie/status/837735473745289218

Nice but misleading graph.

If you count the situations that lead to "No" you'll realize that all the "No" cases can be easily checked for, and if you're not in a "No" case then you're in a "Yes" case.

Can probably be implemented in a regular function with about 30 lines of code?

It's not hard to implement the logic when you have the rules. It's hard to define the rules.

> It's not hard to implement the logic when you have the rules. It's hard to define the rules.

Software development in a nutshell.

You're glossing over the fact that in order to have all of those complicated notification rules that users expect, you have to allow the user to set all of those complicated notification settings. You have to give them the ability to subscribe to threads, set notification preferences for a variety of items (channels, username mentions, keyword mentions, @here mentions, etc), set DND and exceptions, etc.

And maybe write test code for "all" possible combinations of settings.

Which is exactly the point the original poster was making. Software development on "simple" consumer apps is death by a thousand cuts.

It seems amusing that developers, of all people, wouldn't realize the power of exponentiation: https://en.wikipedia.org/wiki/Wheat_and_chessboard_problem :)

Lots of small things can add up to a lot of work though. A few extra percent per feature of complexity will ramp up quickly.

> If you count the situations that lead to "No" you'll realize that all the "No" cases can be easily checked for,

I think you might be under-counting the "No" cases.

I counted at least 30 (and then stopped, with plenty still to go) so I don't think you'll get it in 30 lines of code unless you have some very long lines with rather impenetrable logic.

How did you count 30? Are we looking at the same picture?

I counted 9.

- channel is muted and message not in a thread the user is subscribed to

- user in dnd-mode and there's no dnd-override

- this is a @channel mention but @channel mentions are suppressed

- message is for a thread user is subscribed to but channel notification perf is nothing

- notification preference for device is set to "never"

- @here mention but user is not active (not here)

- highlighted word in a thread message the user is not subscribed to

- channel notification preference is set to nothing

- I couldn't understand this condition (@mention in a comment on a file not owned by user?)

You can check these conditions sequentially and if any of them match, return false.

The last statement in the function would just `return true`.

The function needs a struct representing user preferences and a struct representing what's being currently parsed as inputs.

It's really not that complicated.

> How did you count 30?

Counting paths from the first node to the "NO" node rather than just counting total edges leading to the "NO" node.

Many of the conditions you mentioned are themselves determined based on various other conditions, and/or only triggered if certain paths (but not others) are followed.

> You can check these conditions sequentially and if any of them match, return false.

Not so.

For example, you could have the 'notification preference for device set to "never"', but there are paths through the flow diagram that evaluate to "YES" without ever going through the path that checks for the global device notification preferences.

Therefore if you are just sequentially checking each of the conditions you mentioned, then you'd be returning false (because that one statement matched) instead of true (because the flow should never go down that path).

> It's still a simple thing for one person to handle in a couple of days.

I don't disagree, I just think it's more effort than the 'regular function with about 30 lines of code' you first mentioned.

I guess it is complicated compared to all the features mentioned before: complicated is not the right term, but extending users sessions with notification/messaging support is probably more code than the rest of the forum combined (in every language).

Suddenly there are a lot of things (on top of user sessions, which most web languages/environments have plug and play solutions for) hitting your database and effecting your caching strategies.

This person said only that there is a lot to do, not that it is complicated.

A modern forum system is a culmination of all these features and many more.

And each feature always seems trivial on the surface. That you pick on this feature as an easy one makes me chuckle and shake my head slowly as I recall the hubris of my past self.

I once made the mistake of thinking that building a forum would be easy, so I can relate.