Skip Navigation
News from fediverse @fedia.io infinite love ⴳ @mastodon.social

idk where to really put this (might turn into a blog post later or something). it's what you might call a "hot take", certainly a heterodox one to some parts of the broader #fediverse community. this

idk where to really put this (might turn into a blog post later or something). it's what you might call a "hot take", certainly a heterodox one to some parts of the broader #fediverse community. this is in response to recent discussion on "what do you want to see from AP/AS2 specs" (in context of wg rechartering) mostly devolving into people complaining about JSON-LD and extensibility, some even about namespacing in general (there was a suggestion to use UUID vocab terms. i'm not joking)

1/?

96

You're viewing part of a thread.

Show Context
96 comments
  • the challenge in closed-world systems is how to scale communication and coordination as the number of implementers grows. without a central authority, it almost inevitably leads to power coalescing in the hands of the few most popular or largest implementations, who become the "de facto" standard and get to mostly do what they want, and everyone else mostly has to follow if they want to be compatible.

    sound familiar? it should, because this is the model that the #fediverse follows today.

    12/?

    • indeed, the #fediverse is more closed-world than open-world. you see this in the so-called "rejection" of json-ld among presumably the majority of fedi implementations. because for the most part, AS2 lets you ignore json-ld. it only matters for extensibility, and (specific criticisms of json-ld aside) json-ld also mostly allows you to ignore it.

      so why do people still complain about it?

      well, there is the concept of "context" in json-ld, which represents shared understanding.

      13/?

      • when i say "john knows sally", there are several ambiguities. we can solve ambiguities by disambiguating. one way to disambiguate is to be explicit about what any term or symbol means. one way to be explicit is to use uniform identifiers.

        in particular, http/https uris have some convenient properties

        • they have authority, so you can qualify an id based on who's assigning it.
        • you can use the authority component as a namespace
        • you can fetch the uri and it might return something useful

        14/?

        • so let's say john is example.com/john and sally is example.com/sally

          what do we use for "knows"?

          well, there are multiple senses of the word "knows":

          1. is aware of the existence of
          2. is familiar with
          3. is having sexual intercourse with

          we mean definition 1. so we might use example.com/vocab/knows/1

          now we have the statement:

          <example.com/john> <example.com/vocab/knows/1> <example.com/sally>

          this is unambiguous, but we can go one step further: we can provide definitions at the uri

          15/?

          • say some random person sees the statement above. they don't know who john or sally are, and they don't know what "knows" means in this context.

            well, if we do a little work upfront, they actually can know what all of these terms mean, without ever asking us directly

            we put a resource on example.com for each of these terms, and each resource describes the subject of that identifier -- it is a "resource descriptor".

            the resource for knows/1 can define itself explicitly with a schema

            16/?

            • so at minimum we have the following schema for knows/1

              - how to represent it in plain text: "knows"
              - how to define it: "is aware of the existence of"

              the RDF Schema gives us label and comment, as defined by the RDF Schema.

              - :label "knows"
              - :comment "is aware of the existence of"

              but we need to know what "label" and "comment" mean as well! not to worry, we qualify those terms with the rdfs namespace:

              - rdfs:label "knows"
              - rdfs:comment "is aware of the existence of"

              17/?

              • now at this point you're probably wondering what this has to do with social networking. and on a practical level, if you're just interested in building a "social networking protocol", this is mostly all extraneous.

                the part that implementers have to deal with is the notion of "context" and, more specifically, how json-ld handles it, and even more specifically, what to do when two shorthand terms conflict.

                remember, the open-world solution is namespacing. what does closed-world do?

                18/?

                • well, let's look at actor. in AS2 terms it refers to the entity that performed an activity. but in schema.org terms it refers to someone playing a role in a movie or other performance.

                  in a closed-world sense, you don't want to be aware of context. you don't want to have to deal with it. but even so, you still have an "implicit context" that you are using, based on how you define each term in your own understanding, what you hardcode into your software.

                  19/?

                  • what json-ld does, or what it allows you to do, is explicitly declare a @context@mastodon.social that is equivalent to your "implicit context".

                    this works fine if there is only one declaration that is shared exactly between two parties, but it gets complicated when the "implicit context" differs or isn't an exact match.

                    this means that there cannot ever be a singular #fediverse network, because the "implicit context" differs between each software project. the only guaranteed overlap is the AS2 one.

                    20/?

                    • but it's not like AS2 didn't think of this. they wrote in this requirement: https://www.w3.org/TR/activitystreams-core/#extensibility

                      > Activity Streams 2.0 implementations that wish to fully support extensions MUST support Compact URI expansion as defined by the JSON-LD specification.

                      note, you aren't required to implement all of json-ld. you just need to handle the bit where you can identify the equivalence between a uri and some arbitrary string.

                      but #fediverse mostly decided this is too hard, and ignore context.

                      21/?

                      • now there's a few thoughts i have here:

                        #fediverse culturally seems to ignore a lot of other things as well. they ignore http caching for example. they ignore http status codes like 301 Permanent Redirect. these requirements are arguably more important than context, and they still get ignored.

                        in fact, most fedi software is mostly just reimplementing Web browsers, but with what they consider to be the "bare minimum" of compliance. and the web they let you browse is smaller than the Web

                        22/?

You've viewed 96 comments.