If you suspected LLMs may be affecting our critical thinking capacity, you were and there’s scientific research proving it. If you think you’re not affected you’re more likely to have surrendered

There’s a case to be made that storing delegations as opposed to invocations prevents unbound things to store, yet in practice delegations are ephemeral so revocations can be dropped as what they revoke expires.
In web3.storage we used grow only set of revoked UCAN CIDs -nice & easy state to manage

🤔I wish it was clear why UCANs alone not suffice here. Ability to revoke is important, but it would appear that addressing that would be simpler and more complementary.

This isn’t a criticism, it’s desire to seek understanding

I personally look forward to adding @iroh.computer as one of the possible remotes so that even dumb buffer is just a path for resilience as opposed to fundamental requirement

Remotes are like git remotes as in you can (and should) have multiple of them, that way even some of them completely shutting down can not shut you down

Dialog deliberately has no server component because operator of server is ultimately in control. Instead dialog allows replication over git like remotes which are just networked storage locations for keeping hash addressed blobs reachable. Making cloud into a dumb shared buffer inverts control

This is where prolly trees github.com/attic-labs/n... and g-trees.github.io/g_trees/ offered interesting solution allowing us to build shared index (At-proto merkle search trees are also in the same family of probabilistic search trees) which is core of dialog-db

Yet you still need this shared index so clients can query to discover things here they can find locations for content they can read from. But shared index still a challenge who host it who gets to update it etc..

github.com/mikeal had a brilliant idea what if we remove servers and let clients just query index and read from networked storage

Cost of proxying bytes adds up

Experience building web3.storage & nft.storage made it super clear that proxying lot of bytes is pretty costly at large scale.

🎯 Need for shared indexes is what you run against when trying to decentralize. Not only we need shared index, but everyone just need a small slice of it.

This was original motivation of dialog-db, what if we could collectively own shared index that you can query without having to replicate it all

I would never have thought than me and Milla Jovovich would be on the same page in regards to Temporal entity-relationship triples 🤯

vimeo.com/1168468796?f...

Radicle Protocol Guide Sovereign code infrastructure.

@radicle.xyz has it and all of the reviews and issues are stored as git objects radicle.xyz/guides/proto...

Giving this job to LLM agent is still on my todo list

Can someone I know add blake3 to the S3 supported checksum algorithms please. I’d take non AWS blessed support by R2 also. Thanks

Problem isn’t a technology, but an asymmetry of power distribution that this technology is amplifying. Silicone valley had being looking to disrupt & this technology is like no other, unfolding it in front of our eye. Those that benefit are ones on top with no regard to those being disrupted

Was not aware of github.com/fido-allianc... this is really cool demo of it in action

Mind explaining what’s going on there ? Is passkey created in CLI and imported in browser ?

I’m not sure if people are unable to or have no practical experience. I would argue that most people thought that declarative view derivation from state was crazy until it became mainstream with react.

I think we need both. LLMs are like JIT but they need clear input and instruction set to work with. That is to say we need cooperating system™️ they can inhibit which requires system language

I'm inclined to think logic programming languages provide fertile ground - you describe outcomes & constraints without telling how to get there

That is also a reason of my obsession with datalog & www.neilconway.org/docs/dedalus... extension to allow expressing distributed system behaviors

Imperfect analogy, but deterministic builds are still not an industry norm so in some sense outputs aren't completely deterministic yet predictable

This is a stretching it but in some sense hypothetical language can make LLMS into compilers produce non-deterministic code with predictable behavior

Another analogy I’ll make is how say when one write in JS they don’t think about what machine instructions VM generates or how it manages memory necessarily. I think same applies we need different language for modeling problems that LLM can take and generate instructions almost like JIT

The Acorn Theorem Prover Perfectly rigorous mathematics, as simple as possible.

I think acornprover.org is a good example in this direction where how LLM came to prove is not important because expectations are well defined and so are capabilities. However this is very narrow use case and I think we need something like that but more general purpose

I am also inclined to think algebraic effects are part of this equation as a way to narrow down possibility spac and definition constraints more clearly

My working hypothesis is that we need higher level language for domain modeling, one that is more like spec defining expectations and helps you just like type system help you think about all possible states and relations across component.

I do miss work culture in Netherlands where I was actively deterred from staying in office after hours or doing any work outside. I was always told to invest this time into social life. Was young and stupid to appreciate back then

Found myself trying to manifest algebraic effects in rust through docs.rs/genawaiter/l...

Yet still can’t articulate clearly why this is justifiably better than dependency injection at construction

Interesting perspective which I have not considered up until reading this