Wouldn’t that be better? Let me see if I can explain what I mean. Here on the fediverse each server is kind of restricted to what the user can post.
@Mastodon@mastodon.social is for notes
@pixelfed@pixelfed.social for photos (wouldn’t be surprised if it used a note too)
Lemmy only for article objects.
Peertube for videos.
You get the idea.
This way of developing the #fediverse where each server only receive one kind of the objects accepted by #ActivityPub makes it more fragmented it, right? A server should send and receive all kinds of objects and should be up to the client to how to processes those objects.
If an user wants an Instagram-like app just create an account on any service and use and app with that UI, of lager they wanted to see more kinds of objects they should just use another client that supports Note, Article, etc. with the same account on the same server.
Ideally all server should have a shared API.
This fixes #fragmentation, the need to have multiple accounts if you are into multiple kinds of objects/content.
No. The various Fediverse server applications are too different in how they work.
First of all, it isn’t all just about object types. The architecture of various Fediverse server applications is vastly different, including how they handle objects, and how they distribute them.
For example, on Mastodon, a thread is just a loose string of posts and more posts which, technically, are identical in properties. Mastodon doesn’t know conversations, and Mastodon doesn’t know groups. You receive the posts from those whom you follow plus, by default, the posts that mention you.
Friendica does know conversations, and it knows groups because it has them implemented. On Friendica, a thread is one (1) post plus comments, just like on Facebook or on blogs. You receive the posts from those whom you’re connected with, but not their comments on other people’s posts. Plus, you receive all comments on posts from those whom you’re connected with. Receiving posts from those whom you’ve mentioned is optional but off by default AFAIK.
Forte is like Friendica, but with nomadic identity. That obviously isn’t a client thing.
Hubzilla and (streams) are like Forte, but with wholly different protocols that were made for nomadic identity in the first place and with ActivityPub as an optional extra.
Lemmy, Mbin and PieFed are all about conversations and groups. You literally can’t follow Lemmy users (something that Mastodon users will never understand), you can only follow Lemmy communities (something that’s totally alien to many Mastodon users).
There are many more differences.
Mastodon’s HTML sanitiser that rips out most text formatting is on the server side AFAIK. If you make Mastodon the gold standard, say buh-bye to numbered lists, horizontal lines, tables etc. (And I’m not kidding, there are places in the Fediverse that support these. In posts.)
Character limits are server-side. Since the huge majority of Fediverse users and many Fediverse devs think the Fediverse was made as a Twitter replacement, they also think that there has to be an arbitrary character limit, otherwise it wouldn’t be microblogging, right? Welll, then Friendica, Hubzilla, (streams) and Nomad can wave good-bye to their unlimited character counts and 100,000±character posts.
Filters are server-side. And they work vastly differently on different Fediverse server apps. Some import filtered content and then delete it. Others reject it.
Permissions are server-side. Permissions are absolutely essential and integral parts of Hubzilla, (streams) and Forte, but the entire rest of the Fediverse doesn’t even know they exist. Of course, it’d be great if everything down to mastodon.social implemented the (streams)/Forte permissions system, but it’d completely overwhelm those who came to mastodon.social in search of Twitter without Musk.
Another feature that Friendica and Hubzilla could kiss good-bye if there was only one unified server backend are multiple profiles per account. Speaking of which, it’s farewell to multiple channels (identities, like accounts everywhere else) on one account/login for Hubzilla, (streams) and Forte. Unless everything else is willing to implement both.
Lastly, Hubzilla has absolute literal shit-tons of features on top of even Friendica. Both have built-in file spaces, but Hubzilla has one with WebDAV connectivity (as do (streams) and Forte). Both have federated event calendars, but Hubzilla also uses it as a frontend for its built-in CalDAV calendar server (which is headless on (streams) and Forte). Hubzilla, (streams) and Forte have an optional CardDAV addressbook server. Hubzilla also has optional stuff like non-federating long-form articles, “cards” that work similarly, a simple built-in wiki engine for multiple wikis per channel with multiple pages each, support for simple webpages (the official Hubzilla website is on a Hubzilla channel) and so forth. I’m not even remotely kidding with any of this.
If you want to unify Fediverse servers, they’d all have to become Hubzilla, but with nomadic ActivityPub.
One (small) issue is that it assumes there *is* a client outside of the server. Most server apps have both a web UI and an API, and it’s even possible to build an ActivityPub server with no client API at all (microblog.pub was like that, IIRC). I think the ActivityPub C2S API was intended for servers that worked just like you’re describing, but IDK if anyone ever really implemented it properly.
Hmmm. Speaking of Fediverse interoperability, platforms other than yours (Pandacap) typically arrange things so that
https://pandacap.azurewebsites.net/was the domain, and something likehttps://pandacap.azurewebsites.net/users/lizard-sockswas the user, but Pandacap wants to usehttps://pandacap.azurewebsites.net/for both. Combined with the fact that it doesn’t seem to support /.well-known/nodeinfo means that no other platform knows what software it’s running.When your actor sends something out, it uses the id
https://pandacap.azurewebsites.net/, but when something tries to look that up, it returns a “Person” with a subtly different id ofhttps://pandacap.azurewebsites.net/(no trailing slash). So there’s the potential to create the following:https://pandacap.azurewebsites.net/sends something out.- Instance hasn’t heard of that, so looks it up, and creates a new user in its database, with the returned ID (
https://pandacap.azurewebsites.net/) https://pandacap.azurewebsites.net/sends else something out. Instance looks in it’s DB, finds nothing, so looks it up and tries to create it again. The best case is that it meets a DB uniqueness constraint, because the ID it gets back from that lookup does actually exist (so it can use that, but it was a long way around to find it). The worst case - when there’s no DB uniqueness constraint -is that a ‘new’ user is created every time.- Repeat step 3 for every new thing you send.
If every new platform treats the Fediverse as a wheel that needs to be re-invented, then the whole project is doomed.
Imho, ActivityPub is a bad protocol that tries to accomplish everything, and ends up being bad at all of it. The spec is also ambiguous in a lot of areas. And major implementations don’t always follow the spec. All in all, it’s a miracle the fediverse even works as well as it does.
Instead of being “bad,” I consider ActivityPub as not being mature yet.
Other internet protocol like HTTP or email are also really basic on its early inception, but it later adding so many features and capabilities to be more modern and flexible.
Give it enough time, and ActivityPub will be mature enough for varied use cases.
I didn’t say basic. I said bad. HTTP 1 is a good protocol. ActivityPub is not. Read both the specs if you don’t believe me. I have.
There’s not a single point in HTTP 1 that I thought, “what the fuck does that mean?” There are several in ActivityPub. ActivityPub also has several areas that are ambiguous. Ambiguity is bad in a specification.
ActivityPub tries to support everything, and has no defined behavior for when a client doesn’t support whatever thing it just received.
It also uses JSON-LD, which isn’t necessarily bad, but defeats the purpose of JSON by making it too complicated to easily write by hand.
This is not easy to write, read, or parse, or build:
{ "@context": { "name": "http://xmlns.com/foaf/0.1/name", "homepage": { "@id": "http://xmlns.com/foaf/0.1/workplaceHomepage", "@type": "@id" }, "Person": "http://xmlns.com/foaf/0.1/Person" }, "@id": "https://me.example.com/", "@type": "Person", "name": "John Smith", "homepage": "https://www.example.com/" }
I’ve been working with some smart people on something to hopefully become a “federated account” that can be used with any service, and is 100% compatible with OIDC, so its easy for systems to implement as the authentication vehicle: https://fedid.me/
Just presented it at IIW and interest is building thus far, so my hopes are high 😉
That sounds really interesting! We’re building an OIDC server for indies with Weird – please feel free to come by and chat with us: https://blog.muni.town/muni-town/
There have been some platforms that combined form factors like Friendica and mbin
Mbin is so cool, it’s what I’m using.
I think piefed.social/pyfedi (which is slowly implementing support for all such objects) should get a mention here as well
For clarity, it’s not Lemmy that uses ‘Article’. I can’t remember what does, friendica maybe?
Lemmy uses ‘Page’ for posts, and ‘Note’ for comments.
Mastodon uses ‘Note’ for both, with ‘inReplyTo’ used to distinguish whether Lemmy would call it a ‘Page’. It uses ‘Question’ for polls.
Pixelfed also uses ‘Note’, with an ‘Image’ type attachment (I thinks Loops is similar, just with a ‘Video’ type attachment).
PeerTube uses ‘Video’.
Funkwhale uses ‘Album’ and ‘Playlist’
CastoPod uses ‘PodcastEpisode’There’s no one universal ActivityPub server because the Fediverse is based on a broken promise: i.e. that you should be able to use whatever service, to interact with whatever other one. You very often can’t, because ActivityPub hasn’t been implemented by each platform as some universal thing, it’s been co-opted by each to serve it’s own purposes. Lemmy best federates with other Lemmy instances, following Lemmy’s way of doing stuff, but a good chuck of the Fediverse follows a different model, and is receiving their activity and quietly discarding it because it doesn’t know what to do with it. If all the Lemmy instances suddenly chose to use a different protocol than ActivityPub, most people wouldn’t notice the difference.
The only problem that I see with this is that images and especially videos take up vastly more space than plain text.
And does ActivityPub include client APIs? I haven’t looked at it, but my completely unfounded impression has been that it only handled server to server communication.
That is a fair point, and I don’t have the answer. Maybe use technics that @peertube@framapiaf.org uses like torrenting (or another way of decentralized storage), I guess you could use a cdn/object bucket?
I haven’t developed anything with #ActivityPub, but have read a little bit of the spec. I would love to hear the take from developers making use of it.
(Sorry for the mention in any case)
@silverpill@mitra.social
@hongminhee@fosstodon.org
@dansup@mastodon.social
@thisismissem@hachyderm.io
Agree with the article, same idea. Despite the opinions each one of us may have regardless #nostr and #bluesky, they have cool ideas we could borrow.
While I think fragmentation can grow into being a problem, trying to standardize things too much can be problematic too, as the developers would be bloating the software for features that the community may use very little, as well as, by consequence of the bloating, the devs being either limited to a design that needs to take into account the quirks of all object formats, or to make some frankenstein monster design to include those different formats.
A more reliable path, I think, is what Kbin (RIP) and its successor Mbin do, to have a section for articles and one for notes. While it’s still more load on the developers and the servers, at least it shouldn’t be as much as having to make sense of multiple formats together, since the two sections don’t directly interfere with each other. This, on a final point, is, to my understanding, and with their respective proportions, what happens with the Linux family of operating systems, where it’s also pretty fragmented, but every once in a while a way to put two different environments together appear, like Wine and Xfce translating Windows and QT5 programs, or AppImage and Flatpak trying to be as universal as possible by depending on as little default dependencies from the host system as possible.
This is what I also think, would make the #fediverse much more viable this way.
