@stefan - 👆how hard would it be to create “server bots” as I describe in this? For mastodon you already have json from public feed via API… was thinking it would functionally be a boosting bot like Newsmast community feeds - such as @breakingnews but be just for each server’s public posts, with admin moderation, etc
@tchambers@stefan@breakingnews Instead of a server wide thing for everyone, why not a personal selection of bots to boost what an individual alone sees? Have a public wide boost just turns it into FB, xitter, et al again.
@r3t3ch@stefan@breakingnews Would need to think of that idea a bit more. For servers it was about curated lists of things already public via RSS and public over the fediverse, but curated by say the server community itself: for instance see this from @chrisaldrich trying to do this via several kudges and RSS.
Better still I propose that each server have a Servebot that boost the public posts of the public feed (with moderation etc)
Curious both if TIm thinks I took the right lessons from his writing....
And very much interested in @evan and his thoughts on the idea as describe in the post. And @jenniferplusplus
As well as what browser tech folks like @jon and @jensimmons would think of my rendition of the state of play and how to move forward on web protocol handler support.
And in terms of feeds standards for the web. This article talks up #Surffeeds from @surf but also @newsmast Newsmasst community feeds, and @Flipboard federated magazines.
I could imagine the same might work with Top WordPress or Ghost content publishers as well, but I'm still understanding the mechanisms for discovering surfacing such content from top federated wordpress blogs or sites, and top Ghost authors. cc'ing @johnonolan and @pfefferle
Right now I could see doing this idea for top Medium.com authors on Me.dm but that is via their http://me.dm server, and @coachtony just for fun I'm making a Surffeed now of top me.dm accounts to play with that idea.
Much of that idea was spurred by this from Piefed on it's potential feed format that can pull in multiple other community fediverse acocunts into one feed:
@timbray@tchambers "at all"? we fetch them using HTTP GET, we communicate using HTTP POST... what makes you so strongly object to classifying them as HTTP resources?
i'm starting to get a little incredulous at the sheer number of times people suggest new protocol schemes and handlers for what is still fundamentally an HTTP resource
if we switched to serving web+activity: or fedi: or whatever, that'd be a horrific regression in UX because clicking/copying links would *break* for most people
the problem is most "fedi" apps are building a web browser inside a web browser. that's the fundamental ux sin. all else stems from that.
Wouldn’t this plus a JavaScript backup greatly reduce the remote engagement current UX issue?
I’m not sure the nature of your objections here are is: I think you may be saying if implemented that this new UX with basically only one prompt and then everything works, isn’t as much an improvement as I’m selling it to be?
@tchambers@timbray@trwnh The Home Assistant project has https://my.home-assistant.io/faq/ to generate redirects to the web/app. It's centrally managed by the Home Assistant project, but it uses local storage to store your 'instance' address and then the home assistant app registers my.home-assistant.io to open. I realize this wouldn't work well with multiple instances and multiple apps, but maybe someone can use this idea to spark other ideas in addition to considering a registered protocol handler.
@kfdm building something like that for the Fediverse is on our todolist, but I am not focusing on it because I know it will cause an outrage about Mastodon wanting to centralize everything and capture all users or something of the sort. For many very vocal people there, it’s better to have a very bad user experience than something imperfect but which works
@tchambers@timbray i’m saying that for anyone who doesn’t support the new scheme, which by default is literally everyone, you will be sending them broken links when you copy or share the rewritten web+ap: instead of https: links. you’d be fragmenting “fedi” from “the web”, since your links would only work with the former and not with the latter. you’re also not accounting for multi-account or multi-server cases.
the root cause of the ux issue is the double-browser pattern, inspired by silos.
@tchambers the rewriting is the issue, because there is a very real and very likely chance that there is no way to handle web+ap: links. they might work for you as a visitor to a mastodon-powered website, but the minute you send them to someone else you are necessarily expecting them to have a protocol handler set up, which they almost certainly will not. we want to preserve https: links in almost every single case. inside the fedi web browser, you can intercept clicks instead.
@tchambers Excellent posts! As a new user just now wading into these waters, this sums up so much of my confusion. I've been trying to figure out how to "do it right" - including the questions of identity and "should my own WP website be federated so content gets auto-posted", Bluesky etc.
The UX (and guides) for this whole thing feels like 2010. When most people are used to modern UX.
I think there is a deeper layer of 'identity management' that could address a lot of the issues.
Cheers Tim for a good post again. I see you're getting pushback on the onboarding server idea. I would argue that had we a good account portability model that solved also post history, there would be no need for a centralized onboarding. Don't like your local community or service provider? Migrate somewhere else. Bluesky does have this slightly better thought out, if not yet practically proven. @tchambers
Yeah - while I'm not entirely a fan of the "fedi is like email" argument (due to public vs private, identity and spam control differences), the migration question, I think, compares to number portability, which is basically 100% transparent across most markets today (though only within countries) and has improved mobile networks for both consumers and operators. Fedi should be less like email, more like mobile networks. @tchambers
FYI, just bumped into the ghost follower UX issue on my own trying to follow @arstechnica folks they follow: 6 followers on the profile, none in the actual link yet. As non-federated. Looking forward to fixing this.
That’s Tim. Fantastic article! I’ll have more to say after I re-read this a dozen times, but I want to get out early with an answer to #3: remote actions…
This is why I built fep-3b86 “Activity Intents” which lets people take remote actions from their home server with one click and zero fuss. No JS, no funny protocols required.
@renchap Thank you for that note. Will think on this more, and see if it can spur ideas... even if it at the end of the day was purely better UX to help explain the problem to users. But appreciate all your notes.
Am thinking of hosting a Github demo of a bare bones example of code working that does Option A, and at least B as a JavaScript backup as I suggested to combine custom protocol handler/JavaScript fallback work.
Would folks be interested, or interested in helping? cc: @funnymonkey
I opened issues with many of the most popular projects. Fortunately, this kind of thing can be rolled out incrementally, starting with adding a few easy records to WebFinger results.
Further down the road, you could enhance it to include other kinds of interactions that aren't possible now (remote Blocks, anyone?)
Andy, what would be my best next step in getting this on the radar at Mastodon?
What you were just touching a bit, but what is maybe also more important, than many think: The lingo is not helping. (And certainly not the people, who are always quick to correct anyone not using it 100% correctly 😉)
Your points are absolutely valid, and I would certainly hope, that somebody finds the time to implement your suggestions. Very nice to know, that Mastodon is already at some.
The thing is, I think right now, #Bluesky is just hotter than #Mastodon & the #Fediverse. But that will change again, and it would be really great, when this stuff is fixed by the time an new wave of incoming people arrives. If we like it or not, many people were thrown away by exactly what you're describing.
Even token support from Mastodon (like adding to WebFinger results) would help this FEP gain traction.
I'm out of my element in Ruby, so I can't supply an actual PR, but I'm happy to support this project any way I can. So if anything comes up, I'll be there to help.
Yes, for sure. Everyone there must be unimaginably busy, so I wouldn't expect it to just jump right into source code any time soon.
But I'd love to get this onto Mastodon's radar somehow.
Mastodon is the tipping point for nearly all improvements to the ecosystem, and I strongly believe this kind of interaction would do wonders for the Fediverse.
So if you have any guidance on how to raise the visibility of this I'd love to know how to proceed.
3. The site queries my WebFinger entry, looking for an link relation matching my request. So, if I clicked "Like", then the server looks for a relation like: "https://w3id.org/fep/3b86/Like"
4. The server replaces necessary tokens in the link and forwards the user to that URL. For our "Like" example, it would be to a page on Mastodon where I could submit the "Like"
5. "on-success" and "on-cancel" values complete the process, closing pop-ups, or returning to the original page
Hey Sebastian, it's awesome that the Social CG is looking into this topic. I scanned your notes, but I'm not totally following your conclusions.
It looks like these are interactions for a C2S mobile app to build stuff on a server. I like the idea of listing out the actions that can be taken on a particular object.
But I don't see how this helps me when I find a URL on the open web. Can you help me understand how this information would be used?
1. User is browsing some site out there and clicks a button to start an activity with that content: Like, Share, whatever.
2. If this is the first time on this site, the site asks them to enter their Fediverse handle (e.g. @benpate). This is stored to simplify subsequent activities.
Custom protocol handlers would be cool if they're built into every browser, and they always work. But that's a dependency that's brittle, and breaks too easily.
FB wins b/c they have one coherent system that all works together. The Fediverse loses b/c it requires far too much technical knowledge. That's the bottom line of Tim's posts.
So, keep up the fight for custom protocols. But let's also do the things we can *right now* that don't wait for Apple, Google, and Microsoft.
phew, yes, but it will get long and snarky. My fear is that masto guys say I am harrassing people when talking about math.
Anyway: We do not want to build monopolies in the fediverse. This was why design decisions in ActivityPub had been clever made before they were destroyed. https://www.w3.org/TR/activitypub/
1) ActivityPub relies fully on URLs not webfinger. I have no clue why we needed to copy and paste the logic of twitter to a wonderful Open Protocol. I do neither understand what is better in "@benpate" than in e.g "benpate.social" or "benpate@mastodon.social" apart from 1 character for free.
2) ActivityPub has a built in "Client To Server" API. The idea is that any client can interact with any server. This is also the reason for the later green boxes and the term "the entirety of the protocol" [overstressed in the Conformance Section] … Not just anyone with mastodon. The idea to create a special own Client API for an Open Protocol still is ridiculous.
@trwnh Why? It would work with all of them too, as long as they had javascrpt enabled and ansered only one prompt. And then set forever for that server.
@tchambers if the javascript performs a rewrite, then the resulting link is useless to anyone who hasn’t registered a protocol handler.
(also, no, we can’t and shouldn’t assume javascript as a requirement for a protocol scheme. even if we did, there are still issues with the proposed “back up” as above.)
@tchambers failure modes: - you don’t have a protocol handler registered - you have javascript disabled or unimplemented - you have multiple accounts or multiple servers
you have two separate components to deal with: 1) authentication: the current website knows who you are, in some limited fashion 2) authorization: the current website triggers an action on your home website
at no point does a custom protocol scheme help with either of these. the problem is more like login or session management
@trwnh Think we are going in a bit of circles here. Every time you say that custom links are dead to users who don't have compatable browsers or choose not to agree to the prompt to do the protocol handler... and I agree, but say that Javascrpt backup handles that use case, I'm not sure where we disagree after that?
even with javascript, you can’t just store an identity “forever”. this is part of what i’ve been trying to describe over and over, which is that the double-browser pattern creates this issue due to your seesion only being established within the inner browser. a proper “social web” would operate on the web without having to be virtualized.
@tchambers just because someone *can* register a protocol handler, does not mean that they *will* or *have* already done so. the vast majority of the population will never register a protocol handler. your custom links will be useless to them.
"Q4 2016, Blockmetry found about 0.2% of worldwide desktop and mobile pageviews had JavaScript disabled... More recent surveys aren’t publicly available, but analytics tools like Google now report “fewer than 0.1%” of Google Search users with JS disabled."
@tchambers how would js handle it? either the links are rewritten (in which case they become useless when copied), or they’re not rewritten (in which case why do you need a protocol handler?)
i have to ask this because i’m not sure: have you tried the current interaction modal in fairly recent mastodon versions? it does something similar to what you describe, but it doesn’t require custom schemes at all. i think it uses webfinger and it has some bugs, but it generally works as you might expect.
@trwnh So that answered your question as to how I suggest to do this, and why would this exclude anyone on the web?
They would see all pubic content fine. And as they aren't fediverse uses, they couldn't socially engage, follow or boost social content in either case, as they aren't fedi users.
@tchambers i read those. the problematic bit is “rewrite all links”. please consider what this entails for non-fedi-users, who vastly outnumber fedi users.
✅ When you use Option A or B that I described in my article to engage with remote content (rewritten to your home server) and then copy/share that rewritten link:
That link points to the version of the post as seen from your own server.
My home server has successfully fetched and cached the public content. So:
For non-Fedi users (not logged in, no account):
The link will work as for all public posts. And for non-fedi users that is all they see anyway.
@tchambers you don’t need to rewrite anything, and the rewrite is harmful when copied. you could at best write two links to the same resource, one https: (for copying and sharing as normal) and one web+mastodon: (for loading the mastodon-specific “authorize interaction” endpoint when clicked, provided you registered it ahead-of-time at a browser and/or os level)
the problem is that you need to explain to users why there are two links, and the web+mastodon: link shouldn’t be copied/shared.
@tchambers if you mean the google doc, i still fail to see how it's "far better ux":
- what you call "option a" would not work without pre-registration, and would be terrible ux outside of browsers - what you call "option b" is basically what mastodon already does, as best as i can tell... although it has issues outside of mastodon [1] [2] - what you call "option c" would not work at all, because localStorage is not shared cross-origin
I do believe that it's part of ActivityPub, because that's exactly the usecase: there's an object you're currently seeing and you want to interact with it.
I'm no AP dev, I have no experience at all, only armchair ideas so my goal isn't to say what you're doing is bad; quite the contrary, you're building stuff so you'ro certainly more relevant ! I'm just commenting on the sidelines.
The thing I like about the idea of AP is that it is about manipulation and exchange of data structures, whereas the APIs are about RPCs. I like that because it makes my data more portable, less dependent on an implementation or an instance.
What I would love to see is the AP concept more widespread for interacting: - when I see content I want to interact with, my user agent can pick the object url in the http headers and/or in a <link> tag if it's presented in an html document - my user-agent allows me to send AP activities, optionally linking to object urls
This obviously requires changes in the browser (which is where Mozilla should put its brain but that's another discussion), but can be first done in an extension. Bonus: it works for *all* AP implementations @tchambers
You mentioning custom protocol handlers reminded me of FEP-07d7 – A Custom URL Scheme and Web-Based Protocol Handlers for Linking to ActivityPub Resources. It feels very related to your FEP-3b86 somehow.
I like your idea of not waiting for browsers though.
I think we are hitting the limitations of AP, but I have high hopes that one day it's rewired to use Fediverse Discovery Providers (or something similar) and stop relying on inbox/outbox
@renchap The main problem I was trying to solve for was accurate visible and being able to browse and manually pick and choose one at a time those one would wish to follow. In that use case if this FEP implemented does the same resource hogging dynamic you describe still have to occur under the hood so to speak?
As always thank you for this discussion! cc: @silverpill
@tchambers It may solve one issue (ensuring the follow is valid), but you still need to fetch all the follower’s account into your instance, which may be a lot of them. Then would you fetch those user's own followers, recursively? You would end up with million of accounts stored (database, profile picture, banner, pinned posts & their media…) on every Fediverse server.
@renchap@silverpill Still thinking: then perhaps limiting it only to the remote followers you have loaded into your view (if they have 3,000 but you have only browsed the first 50 shown to you — and if it only gets those - and NOT recursively their followers followers — would that be possible or tendable from a resource issue under AP and/Or Mastodon?
@tchambers@renchap Server could also load relationship proofs not automatically but upon user's request. Further optimizations might be possible if relationship proofs are signed.
@renchap@silverpill still brainstorming: Perhaps as part of a future FEP or just best practice is purge all such remote followers data from your db unless you follow those accounts - and only refresh remote use data when one manually goes back and looks at their profiles again?
@tchambers And then you would still have all of those accounts (and their data) in your DB, so now you need to refresh them periodically to ensure their data is up-to-date. Or you need to garbage-collect what is in your database to avoid it growing forever with "useless” data (a real problem already, this will make it worse), but this adds again a lot more complexity.
@tchambers Yes, on-demand loading could be done here, but this is quite complex. It will be an asynchronous backend operation that might take multiple minutes (or never finish because the remote server cant be reached), and you will need to have proper UX around this in the client. We are slowly moving towards having some asyncronous background loading in Mastodon, but this adds yet another layer of complexity to everything.
@tchambers This does not have anything to do with an FEP as it does not touch ActivityPub. Software implementors can already do that, but as I explained above it adds a lot of complexity.
For Mastodon, I think this will be a multi-month effort touching a lot of the codebase to allow this. It can be done, but not a priority right now.
People keep pointing out the UX fail of expecting people to have multiple accounts to use all the different fedi services. But that wouldn't be true if every #AP app and server used a general purpose #C2S API, defined in the AP spec (whether the existing one or not).
Then we could, for example, use a Mastodon account to login to a PeerTube service to browse and post videos. Or use a PT account to login to a Mastodon service to browse and post Notes.
That was absolutely true 5 years ago. But it's getting less true all the time. As I say, there are a number of server and app projects with implementations now. Which is producing a lot of feedback about how to improve it for a future iteration of the AP spec.
@Strypey The main reason devs haven't wanted to use the C2S API in the AP spec is network effect. Clients devs don't want to use it because Mastodon doesn't, and servers devs don't want to use it because their services wouldn't work with all the clients following the Mastodon API. It's actually tempting to imagine a vicious circle here: If almost everything has the Mastodon client API implemented, it isn't worth developing dedicated client apps that also cover other servers' extra features.
Instead, the reason why all kinds of server applications have the Mastodon client API implemented is because they absolutely need some phone apps that work with them. Just look around the Fediverse. Almost everyone is exclusively on phones nowadays. And especially iPhone users wouldn't touch a Web browser with a 10-foot barge pole if they don't absolutely have to, so expecting them to use the Web UI means you're stuck in a bubble or a time where smartphones are still a gimmick.
That's why even Friendica has implemented the Mastodon client API. I mean, Mastodon and Friendica are very different, and the Mastodon client API only covers a small fraction of what Friendica can do. It actually doesn't cover some critical everyday features.
At the same time, there's little to no incentive for those who can develop mobile apps to make apps for anything that isn't Mastodon. Many start working on Fediverse apps at a point when they still believe the Fediverse is only Mastodon. Or if they don't, at least they've never heard of Pleroma and its family, Misskey and its family, Friendica and its family (where Hubzilla would require a wholly different app than Friendica, and (streams) and Forte would require a wholly different app than both) etc. Or they genuinely think that developing the umpteenth iPhone app for Mastodon is worth the effort more than developing the first stable dedicated iPhone app for Friendica. It's a miracle that stuff like Aria for the *key family exists.
It seems like of all the server apps that don't do *blogging (purist long-form blogging stuff like WriteFreely excluded), Hubzilla, (streams) and Forte are the only ones that don't have the Mastodon client API implemented. And I can't see them do it. For one, their devs steer clear of all proprietary, non-standard Mastodon technology. But other than that, these three are even less like Mastodon than Friendica, and they work even less like Mastodon. Even using a Mastodon app for stuff like basic posting is out of question because it pretty much requires access to the per-post permission settings, something that Mastodon doesn't have implemented, and therefore, neither do the apps for it.
Now, Hubzilla, (streams) and Forte can be installed as so-called Progressive Web Apps. But only Hubzilla veterans ever do that, and that's for three reasons: One, next to nobody has ever heard of the very concept of PWAs. Two, all that people know is installing apps from the Apple App Store and the Google Play Store. And three, people want native mobile interfaces in the style of whatever phone they use. It doesn't matter how well the Web UIs of these three adapt to mobile screens, especially since 90% of all phone users have totally forgotten that you can rotate a phone sideways.
Hubzilla actually has its own client API, and I think (streams) and forte have their own one, too. But nobody has ever even only tried to build a native mobile app for either of them. Hubzilla's devs even have to admit that they don't know how well Hubzilla's client API works because there has literally never been a sufficiently-featured counterpart to test it against. All there is is an extremely basic Android app built by one of them that's available as a download somewhere, and all it can do is send very basic posts, I think, even only at your default settings. It's just a proof of concept.
@benpate > It’s all speculation in the absence of a C2S API that developers want to use
The main reason devs haven't wanted to use the C2S API in the AP spec is network effect. Clients devs don't want to use it because Mastodon doesn't, and servers devs don't want to use it because their services wouldn't work with all the clients following the Mastodon API.
But there are a bunch of projects now implementing AP C2S. I'm sure I've seen a list somewhere.
Yeah, probably, maybe, possibly, idk. It’s all speculation in the absence of a C2S API that developers want to use. I don’t think I could say what any browser maker might do.. esp if they see AP as a threat to their moats.
I want to focus on what WE can do right now. Move the ecosystem forward. Maybe in a few years the W3C will catch up C2S and we can all build to that, too.
But we can’t wait for that before we fix the UX that Tim laid out.
@Ben Pate 🤘🏻 In the words of a diaspora* developer, if Mozilla and Vivaldi "implemented ActivityPub", they'd actually "implement Mastodon". That'd mean catching more users with less effort than implementing vanilla ActivityPub and implementing features that Mastodon doesn't have. Besides, both used to have or still have a Mastodon server, but they don't seem to be aware that there's a Fediverse beyond Mastodon, much less what it's like and how it works.
In fact, they wouldn't even implement the ActivityPub C2S API at all. They'd implement the Mastodon client API and only the Mastodon client API.