Piero Bosio Social Web Site Personale

of course i forgot to reply to the first post when i deleted the second post https://mastodon.social/@trwnh/115771074450967988

for consistency i am going to fix one arrow but not send a 3rd email to the mailing list

wait shit lemme try that again

in the spirit of the holiday season: fedi uses activities like gift wrap. they unwrap them to get at the side effects inside, then discard them. activitypub is for publishing activities, so it's like gifting someone gift wrap. if they unwrap it, they get nothing. the gift wrap is the gift itself. the type of gift wrap you use says something all by itself. but a lot of people don't appreciate gift wrap. if you gifted someone gift wrap they might be confused and not understand it.

@tedu oh. i have Firefox set to disallow pages from setting their own fonts, so that would explain it.

@menelion is this supposed to be readable by so-called humans? the text is scrambled for me in firefox. i can't even tell what the intended effect is supposed to be -- are readers supposed to run some kind of script to undo the caesar cipher? is there a key somewhere? i don't get it.

they tell you to kill em with kindness but euthanasia is illegal

in conclusion: what we don't have good support for in web browsers is relative links with variable hosts. so we can make do with internal links that proxy to a variable host.

a href=/alice/foo

GET /alice/foo HTTP/1.1

HTTP/1.1 307 Temporary Redirect
Location: https://site1.example/~alice/foo

later, we update the redirect to https://site2.example/users/alice/foo -- and this works as long as the resource name doesn't change.

as long as i understand /my-friend refers to my friend, and that i can redirect using this name in some way, i can make relative references that can be fixed with a single update instead of many.

a similar concept taken from the whole lrdd/xrd/jrd space is that some links can have uris follow a "template" instead of having an "href". we might say that all relative links have a template of {base}{relative}

a base is typically a dns name (more precisely a web origin), but doesn't have to be.

would you consider github.com/trwnh and trwnh.com/github to be the same thing? if you have a bidirectional statement to that effect, sure. or if you have out-of-band knowledge, then sure.

but this can be done for other stuff. you might see uris like /proxy/site.example/foo where /proxy/ will chop off its prefix and serve a redirect to site.example/foo -- this is also fine.

now let's say i assign a name to /my-friend and then start proxying or redirecting /my-friend/foo or /my-friend?ref=/foo

what you map to the current hosts is up to you. did services is only one possible answer.

another answer that has been floating around in my head is to just use http redirects. in effect, you run a local resolver and proxy to whatever the current location is. this basically turns "external links" into "internal links".

something like this is already something people do sometimes. you can get a dns name and CNAME it to something else, or configure your http server to redirect /github to github.

well, the alternative is to use redirects. and actually, in a manner of speaking, this is exactly how at:// works from the outside -- the dns name maps to a did. the data doesn't break; only the link/reference does.

if you use a host-mapping strategy, you no longer have to edit a bunch of links, because the links remain stable. you instead update the host-map and *all* links relative to the host-map can be "fixed" all at once.

as an anecdote, consider a friend who changes their domain name about 6 times a year. a typical uri cast to a string href would break after 2 months on average, so what can we do to maintain an unbroken link to that friend?

at:// says that the dns name should never be used for canonical references, and should always be swapped with a canonical did. this works fine with identity services like did:plc, but not fine for did:web users. also, dns names still leak to the ui/ux layer and get copied...

one of the touted advantages of something like atproto and its at:// uris is that it makes the user the authority. what gets overlooked is that you can already do this with http! dns names can be assigned to people, not just organizations. the weakness of dns names is that they are often the root of identity, so changing the dns name of the host fundamentally changes the identity of all qualified resources on that host. atproto gets around this by substituting with a canonical did: instead.

if we acknowledge this, what does it get us?

well, first of all, variable references would be much more powerful. there is a concept of "internal links" and "external links", usually in scope of a domain or web origin. but if you decompose external links into host and resource, you can make the host itself a variable, instead of the full uri. hosts are often dns names with a default port, inherited from tcp/udp. hosts are often assumed to be machines, but don't have to be...

realizing a lot of datatypes are often confused with something else because of their lexical form

example 1: http. the uri *looks* like a string, and the uri rfc will tell you it has path/query/fragment components, but in http it is more accurately a tuple of (host, resource) and there is no special consideration for path vs query. you just request /path?query as a single string which is the resource name or identifier.

example 2: semver. again, it is a tuple of (major, minor, patch, variant).

@datarama @cwebber well, that would be non-use. i am being somewhat facetious but "use without input" would be like configuring some automated services and then disconnecting everything

@cwebber the most security-critical way to use a computer is without an input device

<thing> seems quite natural if coming from turtle as well. i'm not sure if this is a good thing or bad thing yet; i may want to commonly embed turtle or a similar convention to talk about subjects without necessarily having them be links? also might be tricky to deal with escaping if converted to html?

another thing to consider: # similar to hashtags but generalized to allow any string? #<> could do that. or maybe *<> á la c-style pointers?

no further thoughts yet and about to sleep, so later…

i am aware of the following link syntaxes:
- markdown []
- wiki [object Object]
- html a with href
- rfc uris <>

html is the most unambiguous but also significantly more verbose. if we want to use a microsyntax for links within plain text that can be parsed without ambiguity, then wiki links might also work because double square brackets are not commonly used for anything else like single square brackets are. i suppose <> could be extended to allow more than just uris, but <> might appear as non-links too