The folks at Matrix interviewed me about this: https://twitter.com/YousefED/status/1488161520198561798?s=20&t=v8VxdJDLQhOLoZst0Ya5fQ. Also features a quick demo of TypeCell

Do you have a version of this video hosted on the web (vimeo or youtube or whatever)? I'd love to reference it, along with the current stuff from Primitive, on my codex.

thanks Ivan Reese - here you go: https://youtu.be/40ua8NRyrro

That's pretty neat. I have been pondering what a graphical logic programming language would looks like (I though something akin to Unreal's blueprint to compose logical statements could maybe work ...) and a-la-scratch blocks seems to be a good match

Ok, this helps me understand it much better! It's for law the way lisp is for AI. Alternative elevator pitch for it: Prolog with a natural language syntax.

❤

One idea I've often thought about is including test scenarios in laws. Like, consider the usual tired debate about income tax rates. One side wants to tax more as income grows, one side wants to tax less, both sides are obscenely self-interested, and the result is a raw negotiation without good faith. Lost is any sense of how best to build our society together. What if instead we pinned down a few criteria:

• A family of 4 making X should be able to have a budget that looks like Y.
• A single parent raising children on food stamps should be able to have childcare.
• ...

I think it'll probably be much easier to agree on these tests, and might make for a better foundation for debate. And if the laws start with scenarios, it'll make it easier to update them as well. We just ask if the tests are still passing, and if not we think about ways to rebalance our portfolio. Or we might ask if a refactoring of laws makes any of our scenarios break.

I'm well aware of how naive all this sounds. I just like thinking about it 🙂 One problem I can anticipate is that the negotiation may then happen over which scenarios we permit to be included..

Another related idea: what if we included tests in Ethereum code? It would add legitimacy to code changes and forks when bugs are discovered.

Sorry, probably off-topic for this thread. But you've gotten my imagination to soar 🙂

I'd take Kartik Agaram idea one step further: let politics vote for specifications, formulated much like the tests but with added weights for each criterion. Then let specialists-plus-computers work out detailed rules that fulfill the specifications as far as possible, and let politics accept them or not. Or choose between multiple rule sets that imply different trade-offs.

The idea is to move the political discussion away from the rules and towards the rules' outcomes.

Some of this is a little far-fetched, but not all. The effects of legislation are regularly encoded in governments for the purpose of economic microsimulation to predict the effects of policy changes, in order to see whether or not the proposed rule changes do the things that the policy designers wanted to have happen, or not.

Those encodings, though, happen in languages that are not accessible to the policy developers, and legislative drafters, and where the sections of code don't have any one-to-one relationship with the sections of law.

An encoding in Blawx would allow for small-scale microsimulations in a language that non-programmers could actually access, so that the tools would be accessible to policy people, legislative drafters, economists, and anyone else, and could be re-used to power applications, or generate tests for encodings written in other languages.

Arguably, Konrad Hinsen, legislation is already a specification language for software, it's just a bad one. In the short term, we need to make it possible to check whether or not software is compliant with the specification by having a way of encoding the specification that the people writing it can trust. And they can trust Blawx because they can read it, and they can use it.

Getting people to the point where they are willing to say "we don't care what the rules are, we care what they do", is an attempt to completely change the basic infrastructure of the legal system. I'm not optimistic that's within the realm of the possible. We can, however, get to the point where we can give people tools that allow them to say "I think we should rewrite this rule, because if we implement it this way, this test case strikes me as unfair" and be able to give people a link to an interactive tool that allows them to explore how the rules might change to avoid that outcome.

Kartik Agaram Testing, both in the small scale (one scenario at a time) and in the large scale (using this code to generate or test microsimulations), are the exact sort of use-cases that it is pointed it. It's just going to take me a while to get there.

"Prolog with a natural language syntax" is not far off, except that it's not standard prolog, it's goal-directed answer set programming. A more authentically "Prolog" alternative is something called "Logical English", which is being developed by Logical Contracts. But they are still imagining that it would be a typed language, which I think is a bad idea. Controlled natural language is easy to read, but hard to write. Blawx is aimed at sacrificing some legibility to simplify drafting.

Sorry, I'm using "typed" in the sense of "ascii" not in the sense of "type safety".

Blawx has a lot in common with things like Ergo, from the Accord Project, which "compile" to blockchain, but are themselves platform independent. So there is a lot of overlap with smart contract technology. But that's where the overlap ends. If you wanted to use Blawx in order to verify the legal compliance of Ergo code written for Ethereum smart contracts, you could, I suppose. But I can't see any direct relationship to blockchain.