Nickname management is complicated. I like to use the same nickname from multiple IRC clients running on multiple systems. It used to work earlier but not any more. Recovering a nickname after you've forgotten the password is also complicated. If you don't care about nicknames, the issue is moot but maintaining a consistent identity seems important.

Nice article. Thanks! :-) I grew up with IRC and realize that it isn't the same any longer. It isn't the place where everyone is, which some social networks seem to be today. The local communities on IRC, a channel for a town used to be the place to be and meet others.

Same with SMTP and POP. I would routinely send or get email via telnet when I wanted to debug or delete some messages. They're all very simple protocols.

It's a real shame how difficult programming is. I don't mean that it is difficult to write difficult things, but that it is difficult to write simple things. Once upon a time, one could download Visual Studio, click about to make a new project in, for example, Visual Basic, draw a GUI in the GUI editor, and click the run button. One could then start adding simple functionality (e.g., working through a book). Or even longer ago when a computer might dump you practically straight into BASIC when you turned it on or you might get access to a mainframe/minicomputer with programming tools already set up. Nowadays, an "easy" introduction could involve the horrific process of installing and setting up Python on Windows (where it is hard to do things other than input/output text) or editing some HTML/JavaScript files where there are more easily possible interactive things but lots of things are difficult like just drawing things or anything that requires a server side.

If you, like me, were wondering what Libera Chat is, it's the moral successor of Freenode with Freenode now being a shell of its former self.

A number of moons ago, I switched from a company that used IRC for its internal, real-time, ephemeral communication needs to an enterprise shop that used Microsoft Teams to do that (and of course other communication stuff, as the boundaries for what was better kept in Sharepoint, Confluence, Email/Exchange, the legacy Wiki, and/or Teams were never quite clear :)) there.

In the old shop, we eventually had all kinds of important subsystems hooked up to our internal IRC server: Monitoring and alerting. Source control and Wiki activity. The deployment pipeline. Ticket activity reports. All these services were pretty much effortlessly set up to provide useful, real-time status information broadcast to topic-specific channels users could idle in. Everyone could stay informed on topics of their interest, in real time, with no barrier to entry. It was really good, and the implementation completed in a few hours total, for all use-cases, due to IRC's incredible simplicity.

Due to the benefits I had reaped from that setup before, I tried to implement parts of it on/for the MS Teams platform at the then-new job. Getting the Teams Python SDK to implement a bot-like entity running alone proved to be a days-long ordeal, and whatever followed wasn't much more pleasant.

In the end, we let someone set up two email-to-teams-channel-forwards which kinda worked, but suffered from obnoxious, multi-minute relay delays.

As a consequence of the tedious bringup and the latency shortcoming, the "effortless notification" initiative never really got traction.

Not only because of this particular experience I am a firm believer that software/system simplicity is a virtue that can neither be overstated in importance, nor substituted by anything else.

In the beginning was the command line. Then the work of the bright people of Xerox PARC was used to hide from users the reality that lied underneath their beloved GUI: computers are just passing around strings of text. Now we yearn for a time when we are just one `INT` and several `MOV` away from putting a pixel on a screen, instead of downloading a multi-GB IDE to fiddle for a weekend before we can show a simple window.

Speaking of simplicity, this blog has a fantastic design. The CSS is only ~30 lines and is largely just applying spacing/padding. No JS, no custom font, etc.

I'd say it's in the same general box as the simplicity of 8-bit computers booting into Basic interpreter, and the simplicity of Legos.

It's wonderful when you can have your toys in a sandbox where you use and develop them mostly for fun, and for scratching your own itch, away from well-moneyed interests. No need to carefully identify participants. No need to encrypt, or otherwise complicate the implementation. No need to efficiently serve millions of users. No need to add bling to attract more of those who barely cares. (The latter is not the case with Legos lately, though.)

This is why I think that a lot of innovation starts in the fringe, and looks like mostly useless toys, until one of these toys proves very useful for "real world" needs.

As an aside, can I just say how refreshing this website is? It's 100% content, just text. Now view the HTML source, and be amazed. I daresay the author actually wrote the HTML by hand. I suppose it could be a very conservative and conscientious site generator that even respects line length, but I'd be surprised. Short CSS file for minimal style tweaks, and readable markup. Fitting that the article is about simplicity. When I first learned html (late 90s) this is what it looked like. Very nice.

Usenet too. Getting news and discuss stuff "offline" and fetching/sending the messages once a week it's magical and resting.

I used IRC for gaming around 2004 - fond memories!

I recently tried Discord to find programming communities but I just don't get it. When you join a server you are automatically subscribed to all the channels. And apparently you can't leave them, you can only 'silence' them by manually doing that for each channel. After a few days I just gave up as I could not keep up with all the notifications.

I find Matrix a fine substitute for IRC. Very simple to write clients and bots for. And you get modern features IRC either lack or does not do well.

I never used IRC growing up, to my knowledge, though I'm sure I used it by proxy in software that used it under the hood.

Instead, I grew up with AOL Instant Messenger, and then MSN Messenger which later became Windows Live Messenger, then Skype, Xfire, Pidgin and Trillian as clients, then back to Skype again, and now Discord, which is where I still reside most of the time today.

When I thought about existing chat protocols I wanted to use in game engines and websites that would allow one to connect through existing clients without having to join the game or navigate to the website in question directly, I thought about IRC.

But it seems like people use Matrix now, and it just hasn't caught on to my circle of friends. If I'm not mistaken, it almost seems like FOSS Discord.

I was recently introduced to it by a member of a community of very friendly Quake Mappers. I wonder if there is primarily first a cultural barrier to these technologies and not a technical one. As usually I find more technical people on IRC than on Discord.

I've never really played around with IRC, but I've definitely had the experience the author talks about with Matrix. The server (like mentioned about IRC) is complicated, but interfacing with it as a user or a bot is mostly a few REST endpoints. I've started using Matrix as my go-to interface for new projects. You get I/O for free, plus authentication, user accounts, and multi-device; leaving just the fun stuff.

Yeti,

You don't understand what happened at Xerox PARC or what their "GUI" was. Smalltalk wasn't a language. It wasn't a GUI. It was an environment. Its whole point was that it didn't hide anything! It was a completely different paradigm to how computers and their programs are architected today. A Smalltalk system was always meant to be so simple that one could understand, and change, everything about it.

That's why I've said that their work was used, not that they did it.

Somehow I never heard of Matrix until now. I'm now running Element with a bridge to the Libera IRC network. Thanks!

Everyone should write an IRC client as an exercise in network programming due to its simplicity. The other IM protocol for which I've written a client is early MSNP, which is also text-based and not immensely more complicated than IRC. IMHO all the newer web-based stuff is a horrible mess of abstraction bloat. TCP, and TLS if you want encryption, should be a sufficient base to build upon.

I use Matrix and bridge in IRC, and third-party platforms whenever necessary. So much less cognitive load having it all in one place.

In addition to `ALIS`, there is also a web search for finding channels and their servers: https://netsplit.de/channels/.

To find new channels, I also found it helpful to aggregate the lists of all channel participants with an Irssi script named `jalso.pl` from https://github.com/andre-st/irssi-scripts.