This is sort of how ActivityPub is a thing, but it underpins multiple, sorta-but-not-really interoperable systems like Lemmy and Mastodon.
That you can claim to support Willow, or be Willow-compatible, without actually having to interoperate with your competitors. See e.g. the usage history of x509 in the nineties.
For example, SSH only works if both sides support and can agree on the same cryptographic algorithms, which is something that SSH is parametrized over.
In that sense it is even more high level and abstract than parameterized protocols like SSH.
GET / HTTP/1.1
Host: example.com
Could have the same semantics in any format: {
"method": "GET",
"version": "1.1",
"headers": [{"name": "Host", "value": "example.com"}]
}
Of course a server accepting the former won't be able to communicate with the latter, but that's just an implementation detail that Willow does not want to commit to at this stage, and does not make it any less complete. Just a bit impractical.True, but the industry has been moving away from "you have to configure both ends" towards autonegotiation.
e.g. RS-232 you had to configure data rates (e.g. 9600 baud) and encoding (e.g. 8N1 - 8 data bits, no parity bit, 1 stop bit), and if you didn't have the same config at both ends, communication wouldn't happen. USB, the primary successor, determines stuff like that by negotiation. Or similarly, with Ethernet autonegotiation, you no longer have to worry about manually configuring speed/duplex on each end–which I can remember being a big drama 20 years ago.
Probably not the best example, I just happened to have the PTP spec open at the time!
Say that I want to implement something Figma-like for designing drug-runner operations, Willow seems to be an excellent building block (Yes, the example is kinda out-there but it's meant to indicate that genericity intended here).
As far as I can tell, this is primarily a crypographic specification, like Noise (http://www.noiseprotocol.org) except for a stateful key-value store instead of stateless connections
"higher order" is some nonsense, and would make me shy away from using it...
So, perhaps it is strong language, but I think it is a reasonable reaction.
A protocol has the property that it is implementation independent, but that it has a defined interface (i.e. it is immediately usable).
This is neither (not a defined interface, implementation dependent). If it doesn't share either property with a protocol, then you can't claim that it is truly a protocol, "higher order" or otherwise.
This confused verbiage is what should be cause for concern - note that I can claim a "higher order" protocol with JSON or gRPC - its all the basic building blocks for a protocol, just both sides need to implement the same stuff!
Except, neither JSON nor gRPC are crazy enough to claim to be a "higher order" protocol, which to me puts this in the rubbish bin of over-complicated technologies looking for a problem, like SOAP, JavaBeans, OSGi - all of these could also be claimed to be "higher order" protocols as well.
The term is meaningless, and so I assume, is this project.
This part looks useful.
But is it useful to be a "willow" family of protocols? Probably not.
Their claims on the front page are extraordinary. Extraordinary claims require extraordinary evidence, and heading the page with nonsense is not a good start.
You can make two data structures with a const parameter.
If the parameter is not the same, they are not compatible (not the same type). The parameter can be tuned according to the specific needs of the application.
More practically/less absurdly: is SSL useless because side A doesn't support the same ciphers as side B.
Perhaps a Willow negotiation protocol would be needed to reconcile, but it's a bad idea from a security perspective because it enables downgrade attacks.
A protocol is allowed to have presumptions, and then provide an interface.
Its not allowed to have no interface at all and no presumptions (A void).
As a construction kit, it has value for people who want to make protocols where they'll control both ends, but don't have to re-implement basic table stakes.
> This makes Willow a higher-order protocol: you supply a set of specific choices for its parameters, and in return you get a concrete protocol that you can then use. If different systems instantiate Willow with non-equal parameters, the results will not be interoperable, even though both systems use Willow.
Help me out here - isn't the point of a protocol that two independently developed systems don't have to agree on how to implement the protocol? What value does Willow have if two systems that both purport to be "Willow-compatible" aren't compatible with each another?