Bitcoin is called „digital gold,“ because gold is said to be a hedge against inflation. Note that this includes mined fees, which has no comparison in mining for real gold (as we’d have to put previously mined gold back into the ground). And while I’ve never really coded in lisp at all, my understanding is that its biggest problems are all about doing things efficiently at large scales — but script’s problem space is for very small scale things, so there’s at least reason to hope that any problems lisp might have won’t actually show up for this use case. To me, it seems like chia lisp is a better answer to the problem here than the Simplicity language. You could also allow things to be pushed onto the stack that (recursively) can push things onto the stack — the language „Joy“ takes this approach. One of the things people sometimes claim about bitcoin as an asset, is that it’s got both the advantage of having been first to market, but also that if some altcoin comes along with great new ideas, then those ideas can just be incorporated into bitcoin too, so bitcoin can preserve it’s lead even from innovators.

For example, rather than the streaming-sha256 approach in Elements, where you could write: „a“ SHA256INITIALIZE „b“ SHA256UPDATE „c“ SHA256UPDATE „d“ SHA256FINALIZE to get the sha256 of „abcd“ without having to CAT them first (important if they’d potentially overflow the 520B stack item limit), in chia lisp you write: (sha256 „a“ „b“ „c“ „d“) which still has the benefit of streaming the inputs into the function, but only adds a single opcode, doesn’t involve representing the internal sha256 midstate on the stack, and generally seems easier to understand, at least to me. The first lies in the fact that there is a verifiable mathematical link that allows a node to ignore any blocks which do not belong to the chain. This reveals the irrational manipulation that is at the heart of Postel’s Law: it pretends that there is such a thing as a „standard“ to conform to. The thing that’s most appealing to me about bitcoin script as it stands (beyond „it works“) is that it’s really pretty simple in an engineering sense: it’s just a „forth“ like system, where you put byte strings on a stack and have a few operators to manipulate them. Or perhaps you could arbitrarily limit the strings to a max of 520 bytes Click at Xrpbusd a consensus level, and the corresponding Simplicity types to 4160 bits and go from there?

To level-up from that, instead of putting byte strings on a stack, you could have some other data structure than a stack — eg one that allows nesting. Of note is that the supposed „problem at scale“ of LISP is, as I understand it, due precisely to its code and data being homoiconic to each other. BINASG played a significant role when it comes to solving the congestion problem. The problem this company has is they offer an inbound liquidity service, but it is common after a user purchases liquidity, the channel goes unused. This compensates the company for the case where their liquidity is NOT being used. This would mean also being able to pull information about the utxo being spent to obtain its amount and scriptpubkey, which are committed to wit ANYPREVOUT. The idea was to implement a monthly service fee that requires the user to pay a fixed amount if the channel isn’t being used. Since the GC nursery acts as a large buffer of potential allocations, the amount of work done in both cases would be the same, at least until the number of allocs exceeds the nursery size.

DROP` will have similar behavior when allocated at the nursery. However, the banking system builds additional layers of scalability onto those types of settlement layers, so we have things like paper checks, electronic checks, credit cards, PayPal, and so forth. Simplicity requires finite types. FOLD and in exactly the same context, I was wondering what the simplest possible language that had some sort of map construction was — I mean simplest in a „practical engineering“ sense; I think Simplicity already has the Euclidean/Peano „least axioms“ sense covered. I don’t think they’ve solved the broader problem, and thus I think it still makes more sense to stick with bitcoin’s current model here. The last two are extensions that are more food for thought than a real proposal. Because anyone who was ever a delegate can trigger an onchain spend, statechains are designed to use the eltoo mechanism to ensure an onchain spend by the most recent delegate (Carol) can take precedence over spends by previous delegates (Alice and Bob), assuming the trusted third party hasn’t colluded with a previous delegate to cheat. This homoiconicity greatly tempts LISP programmers to use macros, i.e. programs that generate other programs from some input syntax.