 So, we are here in Edinburgh at the Plutus Fest, which is the first conference that we've organised on Plutus and Marlowe, our smart contract platforms. So I'm going to be talking about our assurance strategy, how we're making sure that Cardano in general reaches the assurance standards that we're aiming for, and talk a little bit about how we do that. So my involvement with Plutus and Marlowe these days is relatively minor. I was quite heavily involved at the beginning with getting both Plutus and Marlowe set off in the right direction, figuring out the strategy, what we wanted them to be. But since we've hired quite a significant team of really top-notch programming language and compiler experts, I've been able to take a back seat, and those guys have just run with it. So it's really nice. I can actually concentrate on other things, which is great. So Plutus and Marlowe are our premier smart contract platform. It is based on, it's a contrast with the EVM and Ethereum and Solidity model, which we also support, but that's our other platform. Plutus and Marlowe are our platform that's based on decades of functional programming and programming language research into how should you build programming languages. And we have a whole team of experts who, that is their background, how should programming languages be designed, and they're applying those ideas, that body of work, to how should we design programming languages that run on the blockchain. And so it's based on the ideas of functional programming, declarative programming, and so we can achieve shorter programs, higher assurance programs, and it applies a whole range of great ideas that have previously been lacking from the smart contract space. So let me contrast Plutus and Marlowe with Solidity, for example, because that's the standard language that people are familiar with at the moment. So Solidity was really designed without the benefit of 50 years of programming language research. There was this enormous body of work on how should programming languages be designed, and it was designed without the benefit of any of that at all. So the consequences of that have been things like all the kind of various hacks that we've seen in smart contracts. And that's partly you can blame it on the programmers who wrote their smart contracts, but really the language design did not help those programmers to make their contracts right, and they had a very little way of assuring that they were right or checking or proving that they were right. So by using a much better language, the practical benefit is that we should have fewer DAO hacks and things like that. So we should be able to make our programs or smart contracts shorter, easier to understand, easier to assure that they do what we want them to do, and that means fewer hacks. The smart contract does what you want. That's the key advantage. So Plutus Marlowe fit into both the SL and the CL. So we will have Plutus Marlowe integrated into the SL, but it may be a somewhat restricted version that runs on the SL. And then once sidechains are working, we will have a separate CL that runs Plutus Marlowe as well. And that will be the same language, but it might have fewer restrictions, or you can write more complicated, longer running programs, smart contracts, than you can on the SL. We will be integrating Plutus Marlowe into the Cardano code base after the Shelly release, after we've finished the delegation implementation. So it'll be coming along in terms of integration a little bit later. But it's already there's a Plutus playground that's available, and there's also something similar from Marlowe, and at some point those two will in fact will be integrated together. So you can already go and try out Plutus and Marlowe and see how they work and start to understand them. And then further down the line, they'll be integrated into Intitas Nets and then into the mainnet release. Plutus Marlowe fit into cover different areas. Plutus is our general purpose, functional style, smart contract language. And it's general purpose in the sense that it lets you do everything. You can write any program in it, in principle. And that has advantages and disadvantages. And Marlowe, by contrast, is what we call a domain-specific language. It's designed specifically for one class of problem. And the nice thing is to contrast the two. What are the advantages and disadvantages there? So if your problem fits into that smaller class, which in this case is financial contracts, then Marlowe makes it really easy to write those things. And they're much simpler, they're shorter, they're easier to understand, they're easier to analyze, they're easier to check what all possible things it can do are. Whereas Plutus is completely general purpose. You can do anything. You can do the things that Marlowe can do, but you can do everything else as well. And the advantage, of course, is that you can do everything. But the downside is that your programs are a bit bigger. More powerful language is harder to analyze, is harder to reason about. Simpler languages are easier to analyze, easier to reason about. So that's the main contrast. Marlowe is domain-specific, smaller problem. And then if your problem fits that, it's perfect. And if it doesn't fit that, then you use Plutus, which is the general purpose language. So where is Plutus and Marlowe going over the next year? The main thing is that we will see them fully developed and integrated into the SL and CL. In the longer term, we're going to see more development tools, better development environments, more libraries. We may in future, this is further down the line, I said that Marlowe is a DSL. We can have multiple DSLs for different areas, different kinds of problems. You could have one for games, whereas Marlowe at the moment is a DSL for financial contracts. So Plutus will always be the general purpose language. But there may be multiple DSLs, all of which actually compile into Plutus. And Marlowe compiles into the same underlying core language as Plutus.