@jens the problem is that terms conflict, and the naive consumer isn't "simply not process[ing] namespaces they don't understand" -- they straight up don't understand the concept of namespacing.

this is a problem because they will then perform data manipulations that cause all kinds of semantic hell, completely unaware that they are doing anything wrong.

they don't understand that `actor` can mean two different things. for all they know, `actor` ALWAYS means as:actor, even when it doesn't!

@jens the problem is that terms conflict, and the naive consumer isn't "simply not process[ing] namespaces they don't understand" -- they straight up don't understand the concept of namespacing.

this is a problem because they will then perform data manipulations that cause all kinds of semantic hell, completely unaware that they are doing anything wrong.

they don't understand that `actor` can mean two different things. for all they know, `actor` ALWAYS means as:actor, even when it doesn't!

@trwnh What I mean is, don't do LD. Problem solved.

@jens i need to stress that the JSON agent is, in this case, creating the problem where there wasn't a problem before.

as two separate JSON documents, all is fine and dandy.

it's when you naively merge the two JSON documents that you might accidentally produce a resulting document that has errors. this merging is foundational for Web use-cases.

@trwnh You're still in LD headspace.

In basic namespace headspace, "actor" doesn't exist. It's either e.g. "as:actor", which the consumer may understand (should in the context of AS), or it's "foo:actor", which the consumer doesn't understand and doesn't process.

Keep in mind that MIME has existed for decades, and was used in Email *and* HTTP (Until the QUIC crowd forked it [TL;DR]) with this simple a scheme for headers, and there was no semantic ambiguity here.

@trwnh See, this I disagree with. I think rather that JSON-LD didn't sufficiently consider that pure JSON processors would process their documents. But that is not a productive squabble to have, so I won't die on that hill

@jens JSON processors need to be careful that they are processing their document in a way that doesn't shred the underlying semantics, no?

like, the root cause of the problem is that there are multiple documents, and it matters how you dereference a reference. you have semantic consistency within each document, but you can't just smush the two documents together any which way you please and expect others to understand what you did. you'd be changing semantics for everyone else.

@jens think of it as "how can a JSON processor combine two valid documents with different semantics and produce another valid document without altering the semantics"

if you don't take care to preserve the semantics, you will get a syntactically valid combined JSON document but there will be semantic confusion because the semantics weren't preserved. the literal key `actor` means different things in different parts of the combined document.

would an example help? i can try to whip one up rn...

@trwnh No, I understand the problem. I think you're assuming that creating a combined document necessitates pulling more deeply nested keys into an object closer to the root. This is not an assumption I'm making.

Put differently, a "foo:bar" in the root object isn't and shouldn't be the same as a "foo:bar" underneath a "baz:quux" key. The "baz" namespace determines what "quux" means, and the definition of "quux" determines the semantics of finding a "foo:bar" underneath it. It may refer to a...

one approach is to just say "well, plain JSON consumers should just stop being so naive". a valid approach, but not very robust!

our goal is to preserve the semantic boundary between different resources but still allow merging those resources naively (as JSON objects rather than as #JSONLD graphs).

instead of saying that a term will *always* mean the same thing in the entire document, we want to allow the same term to be used in different contexts across semantic boundaries (resources)...

6/?

@trwnh ... more general definition about the key, sure, but the existence under another object determines the relationship.

This isn't very LD like.

You can avoid duplication still by supporting document internal JSON references, if you want. That does require the JSON processor to understand those, of course. You can do *more* than namespaces, sure.

@jens

> The "baz" namespace determines what "quux" means, and the definition of "quux" determines the semantics of finding a "foo:bar" underneath it

ok, but how do you deal with a naive processor that doesn't know what any of this means?

i am describing the case where you see this:

<some activity> <has an actor> <me>.
<some activity> <is a> <Like>.
<some activity> <has an object> <ghostbusters>.

then you dereference <ghostbusters> and get:

<ghostbusters> <has an actor> <bill murray>.

@jens an aware agent can merge these two graphs while preserving context. <has an actor> in the first graph gets qualified with a prefix or namespace.

an unaware agent doesn't know what they're doing. they just blindly copy <has an actor> without qualifying it at all. this is what introduces the issue.

@trwnh As I said: no. JSON-LD is not plain JSON, period. The terms used in one JSON-LD document are only ever valid in this one document. The document is the boundary, you cannot make any assumptions from one document for another one. It's true for all RDF sources, and even laid out explicitly in RDF Syntax and Abstract Concepts. That goes even further: Semantics of one document may change every time you read it (not applicable here, but please just never ignore that JSON-LD is RDF).

@nik JSON-LD is not plain JSON, but it can be parsed as plain JSON. this is a core part of ActivityStreams 2.0 -- and most of fedi takes this approach. fedi largely doesn't care about RDF at all, and will happily ignore that...

@trwnh I *know*. I know that most fedi devs don't understand the Social Web, and I know ActivityStreams explicitly promotes flawed implementations. And I know that everyone and their dog follow Eugen's example of making ActivityPub a zoo of proprietary JSON.

@nik right, i also dislike the fragility of fedi implementations. i'm trying to bridge the gap for the LD haters to at least produce valid documents.

@trwnh What issue?

The issue only exist if you insist on interpreting the merged document (! not knowledge graph!) as linked data.

"has an object" isn't something JSON knows. JSON knows keys that point at values. Your value may be a reference, if you go that way, or it may be any other JSON.

Perhaps the key is "hasObject". Perhaps it's "attachment". Either way, the path ".outer-key.actor" is different from ".actor", so whatever sits there as values doesn't have the same semantics.

@trwnh Thanks for making band-aids.

But maybe get @Gargron to publish his proprietary extensions as RDF-parsable context first instead of letting everyone outside Mastodon guess what his JSON-LD is supposed to mean.

We're making band-aid for things not some small individual Fedi hacker did, but to support corporate decisions of Fedi leaders that get in the way of individual Fedi hackers.

@nik i'm not sure we can expect people who don't understand RDF at all (and indeed don't even *want* to understand it) to suddenly become RDF-friendly good citizens.