 So, when I came on this project, the thing we were trying to deal with was the immediate aftermath of the Dow bug. They put together a smart contract in Ethereum that eventually was discovered to have a bit of a problem, and it cost them hundreds of millions of dollars, and in order to solve this problem they had to completely fork the Ethereum blockchain to recover that money, and part of the reason that this happened was because of the nature of the programming language that they had designed, and so Charles got in touch with me and said, okay we need to design a language where this is not going to happen again, where we're not going to have to fragment a community just to prevent bugs. I mean that's unacceptable, right? You can't fork an entire blockchain just because there are bugs, and so we set out to design a programming language that was much more secure, much safer, and that you could actually do formal proofs about, because when you have hundreds of millions of dollars on the line it would be nice if you could have a machine verified proof that your software is going to do what you expect, and so we designed a pure functional programming language that was that was founded on well-established mathematical techniques for programming, and hopefully people will adopt it and no longer risk huge sums of money on programmer errors. Plutus is really trying to do something fundamentally new, at least in the smart contract world. The standard technique currently, or the standard language currently for writing smart contracts is Solidity, and it's a language that is fairly familiar to a lot of people. It has a lot in common with JavaScript and other imperative object-oriented languages, but as a consequence it's very hard to prove anything about it to reason about it. Software verification for this kind of language, for Solidity, and its related languages is just very difficult, and one of the reasons you might choose Plutus is because it's going to be significantly easier to prove the things you want to prove. You can take advantage of the the last 50 plus years of formal methods and formal verification in functional programming, and you can also take advantage of the fact that it's a much simpler language. It doesn't have a lot of things that languages like Solidity have, which on the surface look convenient and really useful, but that convenience comes at the cost of not being able to reason in the same way. And so you'd pick Plutus because you want to actually be able to get stuff done. You want to be able to prove things without sort of destroying your soul, trying to deal with the difficulties of the language itself. You'd rather spend more of your time devoted to proving that your program works rather than proving that your language does sensible things. Plutus Playground is an interactive website where you can go and write software in Plutus, which at this particular moment is a translation layer from Haskell style syntax and language constructs down into Plutus Core, which is the underlying form of the language, which can be targeted by multiple languages, and you can then deploy that on a mock chain to see what will happen. It's a great way of learning how to use the language. It's a great way of testing your code or just experimenting with an idea without having to actually run it on an actual blockchain and put real money at risk. So Plutus as it currently is structured is designed to work at the settlement layer to control transactions and to determine whether or not a transaction itself is valid. And these transactions, at this level at least, govern who has what currency basically, who has what money or other transferable things. There's another layer, CL, which stands for computation layer, where the more advanced software would reside. And that's where things that are much more like smart contracts live. That's where you start talking about things other than just who has what currency, but rather what sorts of programs are being deployed to control organizations, to control robots in the world, whatever it is that you want to run on the card on a blockchain. Those live at CL. Both of these layers have a version of Plutus for them. The current version that is deployed is primarily for SL because we are looking at many different interesting ways of implementing CL style computations on top of that. One option of course is to go the full smart contract style system like in Ethereum. But there are other models that we're looking at too. We're doing research into something that we're calling the extended UTXO model, where you can actually achieve some amount of smart contract like behavior. Perhaps even all of it, it's an open research question, but some amount of smart contract like behavior using only the standard UTXO model of program behavior. If we can actually figure out how to do this, if it's a real and valid way of encoding things, then what that means is you can maybe get the full functionality that you'd want from a smart contract without having to have a fancy system in the same way that a Ethereum has. So the KEVM and Plutus are sort of both low level platforms, I guess you could say. They're both things intended to be targeted by compilers or at least Plutus Core and the KEVM are. Plutus itself is a high level language which compiles to Plutus Core, but it can also compile to KEVM. And similarly we are developing ways of we're developing compilers that go from solidity to the KEVM and also to Plutus Core. So in principle you can write a compiler that will translate from whatever language you want into Plutus Core. The point of Plutus Core is to be a target for compilation. And so if you prefer other languages such as Haskell or PureScript or Heaven Forbid, Python or JavaScript or less secure languages, you can do that. And in fact Plutus TX, which is the form of Plutus that people will actually be writing, is a flavor of Haskell. It is a variety of Haskell restricted subset of Haskell which compiles to Plutus Core. So Marlowe is a domain specific language that extends work done in the late 90s on early forms of I guess you could say smart contracts, but no one was calling them smart contracts at the time. It was the late 90s people hadn't even thought of these things really. But Simon Peyton-Jones and others worked on a domain specific language for defining contracts that would be run on computers and enforced by computers. But that was in a completely different context. It was way before blockchains and basically you had to trust that the people running these computations were actually running the code you wanted them to run. Marlowe is inspired by that work in the but now rephrased in the context of blockchains where you no longer have trust involved and and you can actually have self-enforcing code. And how you rephrase that is somewhat interesting because you can't take certain things for granted. You have to actually you cannot take for instance you cannot take for granted the idea that someone will actually do something you have to have an entire new construct add entire new ideas to the domain specific language that enforces behavior in some sense that guarantees that someone will actually do something the way that you do that or one of the ways you can do that at least is with a notion called a commitment where you're effectively saying you put some money on the line and if you don't come through and you don't do this thing that you're promising to do you'll lose that money and this is a notion that is completely new to the blockchain era it was absent from from these software based contracts in the late 90s and having a language for talking about commitments that is natural as opposed to sort of hacked together on the fly every time you want to make a commitment is extremely useful and is one of the important features of Marlowe I guess for me what is really exciting about this work is that it's going to have a significant impact on the future of software development as a whole we're not just going to have a cool language that's going to be deployed on the Cardano blockchain this language demands of us that we use more powerful programming techniques and because we're putting this in the hands of so many people those techniques will suddenly be used by many more people than ever before and that means that more people will be learning these techniques more people will be teaching these techniques to one another more people will be exploring the tools that you need for these techniques and and we're just going to see an explosion of formal methods and machine verification of software unlike anything before and so it's it's going to be very interesting over the next 10 years to see what's going to come out of this because it may well be the case that Cardano and Plutus in particular bring about a whole new era of secure verified software it might go down in history as the thing that brought formal methods to the foreign computer science most programmers today don't actually verify their software they don't make sure their their software works lots of research has been done and how to do this but it's confined to academia and suddenly it's going to be unleashed on the world as a kind of prerequisite for writing software and that's going to be really interesting