Interesting, I have no use of bots in my messenger at all.

What does the Telegram Bot api have, what Matrixes API doesn't have?

Everything: https://core.telegram.org/bots

Bots are, on a platform level, presented as bots. It's not a courtesy rule of "please name bot accounts as _bot" or something.

You can do actual payments with the API, it's possible to earn money with a bot.

Custom inline keyboards you can use to operate bots instead of parsing commands like ye olde IRC bots. Like a home automation bot could reply with a list of rooms when you ask for a room temperature, then you just tap the button for that room.

Closed source, walled garden yadda yadda, but it just works.

Discord bots are a bit less robust, but can still do a ton of things "natively" Matrix bots can't.

Haven't threads been one of the reason some core util got faster?

Only GNU sort uses threads. There is still some room for improvement there, if anyone wants to take a shot at it. :)

I think I saw the Rust based implementations sometimes used a separate thread for background tasks like statistics reporting. Not much additional in the way of "directly" using threads, but I wonder how many could actually be any faster with direct threading.

I bet you don't know the reason for existence

call me out if I am wrong, but isn't history dependent on the server of the chatroom creator, and doesn't every server have different history settings and does it not handle encrypted messages fully?

Yes, XMPP server implementations typically give admins full control over data retention. Different use cases demand different settings, so it's quite adaptable to whatever needs you have.

I'm not sure what you mean by not handling encrypted messages fully, it handles encrypted messages fine.

> so it's quite adaptable to whatever needs you have.

as a user you cannot, even if you self host, because you are not the one controlling message storage

> I'm not sure what you mean by not handling encrypted messages fully, it handles encrypted messages fine.

you can load encrypted messages (including keys if they are needed to decrypt them if necessary) using a fresh login such that you can read them again?

> As for the second point, Matrix's ever-moving target of a protocol makes selecting a client or server that covers all of your needs a massive pain. Currently, Matrix's primary server software, Synapse (which is also at the base of the matrix.org server many people default to when joining the network), is violating the Matrix protocol, making it impossible to invite users to chat if they are on compliant Matrix servers.

could you expand on this in detail?

This will be referring to enforcing MSC4311 (https://github.com/matrix-org/matrix-spec-proposals/pull/431...) stripped state validation. Synapse announced a 1 year compatibility window to avoid ecosystem fragemtnation: https://github.com/element-hq/synapse/issues/19943. However, due to MSC4311 not better outlining how to handle compatibility, another server implementation chose to enforce the MSC more rapidly, breaking compatibility with everyone who hadn't yet implemented the MSC - including Synapse, which hadn't actually implemented it yet. Speaking as the lead of the Matrix Spec Core Team, we should have handled this better. https://github.com/element-hq/synapse/pull/19723 is the Synapse implementation which is now in the process of landing.

wait until capitalism collapses

Why do people arguing about communism always assume that the person they're arguing against thinks that capitalism is perfect. The world isn't binary.

Still some people don't block ads and people pay for it.

Simple as that.

on the other hand it is trivial to project goroutines onto Rust-tokio async/await:

function func() -> async fn func()

go func -> tokio::task::spawn(func)

func() -> func().await

func_blocking() -> tokio::task::spawn_blocking(||func_blocking()).await

(not sure about cancellation behavior in go though)

so? avoid it where you can

nothing is optimized away, it's just not executed - e.g. the program including semantics of the language is just designed such that it is not executed.

e.g. for Rust/tokio printing B is skipped, because the process exits and cancels the future before the task can print B

That's what I thought. But then what is the point when no other async function is executed while the caller sleeps for 1 second (presumably, or is it ms?)?

how would one be executed when the function is explicitly waiting?

also it's an example to demonstrate the differences of async implementations of languages, not a excerpt of a production code base