The comparison of how code is interpreted and executed and how law is interpreted and executed has parallels. But what people are actually proposing to do has nothing to do with executing law programmatically. The system cannot be so easily replaced. Cryptomaximalists exist, but they are the only version of the problem he is describing that actually does exist. Nowhere else is the thing he is describing even possible, much less extant. The idea that code is dangerous because it can be used to turn norms into laws is true, but only inside the context of non legalist structures, which means the danger is mitigated. And it is not unique to code. Policies that are blindly followed do the same thing. Laws themselves are a hardening of policy intents in that way. Contracts are a hardening of agreements, too. To the extent that code is different from these other hardenings, it is a matter of degree, because of the risk of doing the wrong thing faster, or more automatically, because of a lack of context, or human in the loop. "Speed of execution of code prevents the possibility of reevaluating it's terms." That is it's virtue. It is not without a concomitant risk that we are doing the wrong thing, but faster. But doing the wrong thing faster is an inherent risk that is mitigated by basically all of software development. You cannot take the quality of laws we have now, and assume that they will be automated as-is. Not only is that a terrible idea that no one would support, (not even the cryptomaximalists think we should just automate contracts as they currently are) it is quite literally impossible to do. Natural language are libraries that get imported implicitly into every law and contract, and when you try to encode them, you discover you can't without requiring it because of the absence of a natural language library, among many many other issues. The idea "you have no appeal" of code is true only if you live inside the computer. In reality, the software is owned and used by someone who can be sued. When someone stole a bunch of Bitcoin from an online contract, they were sued. We are also taking the ex post necessity of the legal system and treating it as a virtue. The fact that you have to sue someone and ask a judge to interpret a contact is not a feature. Requiring things to go bad first is an efficiency method that we arrived at because most things go fine, and most things that don't get sorted, and it's only the remainder that actually require attention from the system, which has limited resources. Democracy and rule of law does not arise by virtue of the availability of a referee in the absence of agreement. That is a pathetic, emaciated view of democracy and the rule of law. It arises from the 99% of cases that never require the attention of a lawyer or judge, too, and far moreso. The important distinction between how laws and code are executed is not that one is mechanised and the other is not. It is that one is fault tolerant and self healing while the other is not. Which is why we require so much less of our laws than we do of our code. But increasingly, civil society IS being automated, particularly inside governments. And the disconnect between what the laws are and what the machines need them to be is a huge issue. We cannot pretend that laws don't need to be automated. They plainly do. Jimmy absolutely nails it. There is no absence of ambiguity with code, it is just intentional. And the interesting parallel to that is that intentional ambiguity in law is considered valuable, accidental ambiguity is not. Which gets to the idea that we are treating law as virtuous for requiring interpretation and having so much ambiguity, when that is not the case. Clarity and fairness are better than ambiguity and the right of appeal. Needing to appeal is a failure mode. If it were not possible, that would be awful. But that doesn't mean we should want more of it. Code is different in degree from law, yes, but so is the way we use it. No one user tests a law. No one debugs a law. The people who write laws are not talked with their maintenance, or responsible for errors. Code is different, but that is only the tool. The processes in which that tool is used are also different, and designed to address exactly the risks he is addressing. He seems obsessed with what we can do to programming in order to fix the problems with putting laws into code. He seems oblivious of or indifferent to all the ways that we can improve laws by using the code we already have. The question is not how do we avoid the strong legalistic effect of our code. The question is under what circumstances is that risk appropriately mitigated and worth adopting? And this is where it gets down to brass tacks, for me. The legal system sucks. Most people who need help can't get it. Governments are overwhelmed and underfunded. And raising this spectre of strong legalism in code, while it has the intent of protecting people from harm, is actually being used by -among other parties- a protectionist legal profession to argue directly against one of the most helpful things we could do right now, which is automated legal harm reduction. An automated system can literally be only better than nothing, and justified on that basis, because nothing is what so many people actually have. These arguments about the rules of law and democracy are being used to stifle efforts to get real people real help with real problems because of effectively imaginary risks, or risks we already know how to mitigate. And the horses are so far gone from the barn, they have forgotten it. Governments of sheer necessity are automating laws constantly. Those of us who call for rules as code are merely asking that they do it more consciously, and reusably, with tools designed for the task. Does programming need to change to mitigate these risks effectively? A little. We need tools that are accessible to a much wider variety of people, that have a far smaller semantic gap between the natural language expression of the rule and the computer language expression of the rule, tools that are designed to facilitate human validation of those encodings, languages that are inherently explainable, with sophisticated reasoning, that cite their sources, that name the person whose legal interpretation was modeled, that are accessible, open source, and trustworthy. And those tools needed to be possible to use to test and validate anything else we might like to reduce the risk of. So we don't need to change all of programming, but we do need to add to it.

But you can just stop using them

I don't know, I feel pretty stuck with the languages I use sometimes - for various reasons :)

The reason that his advice is weak, is because he has precluded an actual solution to the problem by conflating it with the problem itself. Rules as Code should have been the prescription, not the problem.

btw, by sharing that I’m not trying to endorse it — I think it is sort of an example of code kinda logics leaking into like…social realtionship