Pretty much all the opcodes in the first section are directly from chia lisp, while all the rest are to complete the «bitcoin» functionality. One approach is to just define a new version of the language via the tapleaf version, defining new opcodes however we like. EVICT with a similar recursive approach. 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. 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. 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. Granted, I’ve only really been looking at chia lisp for a bit over a week, but it really seems to me like a case where it might be worth putting that philosophy into practice.

Seems worth looking into, at least. 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. And remember to start with small amounts for the sake of learning and practicing. If the community likes the proposal and decides to move ahead with it, Ethereum core developers will start working on the implementation to be included in a future upgrade to the network. First of all, if either CryptoCorp proceeds according to plan or CryptoCorp fails and some competitor decides to take charge, nearly every address will start with a ‘3’. The way CryptoCorp is designed is as a highly modular «verification oracle» service that anyone can plug in. Both those essentially give you a lisp-like language — lisp is obviously all about lists, and a binary tree is just made of things or pairs of things, and pairs of things are just another way of saying «car» and «cdr». 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.

You may go through advertising as it is important to have creative people at the service; however, www.youtube.com it must come with creative ideas that appeal the people. However, whether you do or don’t support that softfork, as far as the rest of the script is concerned, the expression will either fail entirely or evaluate as zero; so anyone who doesn’t support the softfork can just replace it with zero and continue on, treating it as if it had costed «cost» units. The other is to use the «softfork» opcode — chia defines it as: (softfork cost code) though I think it would probably be better if it were (softfork cost version code) where the idea is that «code» will use the «x» opcode if there’s a problem, and anyone supporting the «version» softfork can verify that there aren’t any problems at a cost of «cost». If the risk score is higher, the server can ask for a standard two-factor confirmation via Google Authenticator or by sending a code as a text message to the user’s phone number. A particular advantage of lisp-like approaches is that they treat code and data exactly the same — so if we’re trying to leave the option open for a transaction to supply some unexpected code on the witness stack, then lisp handles that really naturally: you were going to include data on the stack anyway, and code and data are the same, so you don’t have to do anything special at all.

Anyway, since that time, both markets: precious metals and cryptocurrencies moved in a rather synchronized manner. 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. Of course, «defun» and «if» aren’t listed as opcodes above; instead you have a compiler that gives you nice macros like defun and translates them into correct uses of the «a» opcode, etc. As I understand it, those sort of macros and translations are pretty well understood across lisp-like languages, and, of course, they’re already implemented for chia lisp. By contrast, chia lisp has fewer opcodes than Simplicity’s jets, has feasible approaches to low-impact soft forks to increase functionality, can be used with only two levels of abstraction (lisp with macros and the opcodes-only vm level) that seem not too bad to understand, and (in my opinion) doesn’t seem too hard to implement/maintain reasonably. Consumer wallets will all be 2-of-3 multisig, sharing the keys between either a low-security local-storage key, a high-security key in a safety deposit box and a central provider, or two central providers and a low-security key.