I agree that long forms should be shown with some care. There is also a readability issue: showing an article among other small notes in an endless scroll is a mess and devalues the content.
But I also think it is important to promote this kind of content in generic clients, because they are definitely the ones with a higher effort factor, so they usually have interesting value. As a basic suggestion, I would list them in the user profile in a separate view (e.g., "blog"), and always open them in a dedicated view.
Clients could then implement an opt-in and per user option to alert about new long form content, such as including an abstract in the feed (rss style) or showing a mark on the user's profile.
/cc nostr:npub1jlrs53pkdfjnts29kveljul2sm0actt6n8dxrrzqcersttvcuv3qdjynqn nostr:npub1acg6thl5psv62405rljzkj8spesceyfz2c32udakc2ak0dmvfeyse9p35c
Of course kind 30023 should never been showed. Editing a document is mostly an internal affair, tracking real-time changes is a quite specific need that should require a dedicated tool.
Replaceable events are stupid, that is the root of the main problem here. That aside, I agree with nostr:nprofile1qythwumn8ghj7cnfw33k76twv4ezuum0vd5kzmp0qyt8wumn8ghj7etyv4hzumn0wd68ytnvv9hxgtcprpmhxue69uhkv6tvw3jhytnwdaehgu3wwa5kuef0qqs8hhhhhc3dmrje73squpz255ape7t448w86f7ltqemca7m0p99spgk7dgad that a way to announce or advertise a blog post would be better than picking the posts up directly.
yes, there's this amazing technology called "diffs" that would be more appropriate
Thread collapsed
I don't understand why you hate them so much. What is your proposal? To do "delta" events? I don't think that would work at all unless you assume you're always getting all the events in order, which you definitely can't in Nostr. What do you think?
Not to mention the bandwidth and storage issues that come with this, and client-side costs of processing a big chain of diffs all the time live.
Of course replaceable events are not theoretically perfect, but they work pretty well as long as you don't overuse them.
Yeah, it's just that they break the event sourcing paradigm. If you stick with that, everything else can be solved using some optimization or other. Reactions are far worse bandwidth-wise than diffs or edit events. It would have been better to do some sort of edit event, but that ship has probably sailed.
nostr:nprofile1qyd8wumn8ghj7urewfsk66ty9enxjct5dfskvtnrdakj7qgmwaehxw309aex2mrp0yh8wetnw3jhymnzw33jucm0d5hsz9thwden5te0wfjkccte9ejxzmt4wvhxjme0qqsrhuxx8l9ex335q7he0f09aej04zpazpl0ne2cgukyawd24mayt8gfnma0u I re-broadcasted my note. To actually answer your question, probably the best solution would be a full in-place "update" event as a separate kind with an `e` tag pointing to the original "create" note. This way you you don't have to trace a chain of diffs, just look at the timestamp, and you get verb semantics. This would only be a problem if a blog post had a million revisions, like if a client spammed a live draft as revisions. 5-10 revisions is a lot for a blog post, and easy to process.
I do still think there's a place for "annotations" that clients can display in a privileged position (the use case being updates at the bottom of a blog post, corrections, etc). Diffs are way more complex, and dependent on each other, but also probably unnecessary for blog posts.
I like this idea. I previously worked on graph systems and this is how we handled revisions- changes were stored in new nodes with edges back to the original. this model works well with event sourcing.
Thread collapsed
Imagine you're browsing a feed and your client fetching metadata for all those people on the fly. You can either fetch an event for each or you can fetch 20 events for each and reduce them to a metadata object by applying diffs locally. Do you really think the second is the best solution in the real world?
Also, since you're just fetching random people's profiles you cannot ever be sure (or how could you be?) that their sequence of diffs is complete. You would actually need a blockchain to be sure.
We already can't make it work with replaceable events, imagine having to fetch an unreliable stream of events from an unspecified location.
Thread collapsed
I wouldn't use diffs, I would just grab the most recent event and use that. You might occasionally miss the correct one, but with caching you'll eventually find it and hang on to it. DVMs can do a lot of the heavy lifting with bigger caches for stuff like this to reduce computation and bandwidth client-side. In my mind, DVMs are just nostr clients that run on a server.
Thread collapsed
Thread collapsed
How is doing "update" events any different than bare replaceable events? You still get a single event in the end that replaces the previous ones, right?
Yes, but you have an event id that serves as the handle, rather than an `a` tag. Replies would tag the update event, which tags the create event. Since the updates don't replace the create, the create is still accessible, so you can pull all events, or just events for a given revision. No data is being deleted, so clients don't have to guess. Right now, replies that only tag the `e` tag of a given revision get lost when the post is updated.
NIP-28 used this approach, which I believe I had a big part in developing there at the time. Now to me it looks ugly, dirty, disgusting, a very bad idea. I still don't get why referencing an initial event is better than using the "d" tag. Both are arbitrary strings ultimately.
About not losing history, again, that's the same point from before: it has costs.
Also if these multiple versions were treated the same way normal events are today it would break the relay query language, as if you wanted to fetch multiple statuses from people, for example, you would end up getting multiple old status for the same person and none from some others that hadn't updated in a while -- and so on.
And then again it's not very clear what we're getting from this.
For example, in the "update" event approach the same problems of contact lists remains: one client can overwrite an update event from another client and people lose part of their contact lists.
In the case of "delta" events then you must ensure that you have the full history, which means you must know the exact relays to where a person is publishing their deltas -- but if you are diligent enough to know that and you have successfully written more complex software able to handle that, then why can't you do the same for replaceable events today and fetch the damn last-updated contact list from a relay that you know will always have the last version before replacing it?
I think your suggestion of having replaceable events + delta events (I don't remember the details) could have been a better approach actually, as it would preserve the best aspects of all worlds, but I'm not sure about the implementation complexity of it.
Your point about queries getting duplicates which crowd out some desired results is a good one. You could technically send one filter per pubkey with limit 1.
Lists should not have create/update like blog posts, they should instead have set/add/remove, which combines diffs and replaces in a conflict-free way.
From the perspective of event sourcing, projections should be a different layer from events. We have all this weird awkwardness because we have only one layer. I'm planning to work on some basic layer 2s via DVMs in the next month or so.
Thread collapsed
Thread collapsed
Thread collapsed
Thread collapsed
Thread collapsed
Nothing prevents relays from storing all revisions of a replaceable event today. Would you want to do it if you were running a relay? I wouldn't, unless the user was being charged for each post individually. Would the average user be happy to pay for storing every single edit they made in a post or on their profile or every time they switched to listening to a new song and that updated their NIP-38 status?
I think a history of statuses over time would be cool. I didn't even realize that was a replaceable event. A history of profile edits would be less useful, but how often do you update your profile? The ratio of kind 1's to kind 0's would be probably around 100.
Replaceable events are "good" for infrequently updated things, because otherwise you run into collisions from multiple devices updating the same list or what have you. Which means the volume isn't significant. But if the volume is, replaceables start to break.
I agree, but that is very different from "replaceable events are completely stupid", which was your take yesterday.
Thread collapsed
Thread collapsed
Thread collapsed
Thread collapsed
Thread collapsed
Personally, I don't dislike replaceable events, they seem a fairly logical transposition of "revisions".
I suppose replaceable events are less fragile than a diff chain; all it takes is one missing event in a chain and the update is aborted, or am I missing something?
Instead with replaceable events we can loose old updates (casual or by relay pruning) and still have the final version.
However my perspective for now is too theoretical, I need to deal with more edge cases.
Thread collapsed
Thread collapsed
Replaceable events are hard to deal with. But I don't know of an alternative that isn't worse.
Thread collapsed
hm. long form event announcement link. that makes alot of sense.
Thread collapsed
Thread collapsed
Thread collapsed
