What it was all about was that you have Cardano assets and settlement. There we go, stroke width, all that stuff, and we'll zoom out just a little bit. There you go, assets and settlement. You have things like Cardano native assets, you have ADA, you have the extended UTXO model, you have Plutus, you have Ouroboros, and other artifacts that exist there. It's a real technological marvel when you look at what we've constructed...

So there are programs like Ouroboros Leios. There are PR programs like Babel fees. Uh, there have been huge improvements made to Plutus in the family of languages that compile into it, like Aiken, for example, which is a community project. Uh, and refinements and iterations to the extended UTXL model and obviously, a lot of discussion around improving the native asset standards...

...you are a Cardano native asset set, maybe you're using Marlowe to do your settlement and manage all your financial logic. Okay, so all of your ownership stuff is managed there, and maybe you connect your off-chain and on-chain stuff with Plutus. Now, what happens when, all of a sudden, you say, "Hey, you know, I want to add a regulation layer to that dapp?" Okay, well, right now, that would probably be...

...asset, make it a Cardano native asset, write all your financial logic in a domain-specific language like Marlowe, do some connecting tissue and Plutus and all your off-chain stuff. What I'd like to see happen is an ecosystem of service chains form and those chains basically provide different views or contexts as different capabilities and every single one of them has different logic behind it, excuse.

...the thing is, this was built to be a tank. Uh, Ouroboros is absolutely extraordinary. Plutus is great, Extending UTXO is great. We're not going anywhere, and with Leios and other things, we're going to make it really fast. That input endorses an agenda, and there's a great roadmap here to make Cardano best in class. There's a whole bunch of great infrastructure here, but just because you...

...different languages and different engineers: almost all these engineers actually come from the Polkadot ecosystem and they work with us. We've been staffing up with more people on the Cardano side, and this actually adds a lot of new, crazy, great capabilities to the Cardano base layer. BLS support, um, fast settlement through Orror Paris, um, enhancements to the Plutus language in general, um, and more use of Zero...

The group is basically m event so you can go from three to five to seven to nine; you can have different terms. The other thing is that the constitution itself enables constraints on the committee via smart contracts. When this was designed, we had no Shelley, no stake pool operators, no Plutus; we had none of these things. So, we had to have some form of bootstrap mechanism to be able to...

They basically take their network and change some things. Uh, the point of CIP1694 is to memorialize and formalize, uh, tradition, and precedent into something that is algorithmically adjudicated. But the thing is, you have to move as your capabilities move. When Shelley came out, we did not have extended UTXL and Plutus. If we had, we'd put a lot of the off-chain stuff that's done...

Then of course, there's the third thread that never stops. There are multiple threads; it's like we're weavers here. That third thread that never stops is improvements to Plutus and the development experience. We're starting to fall in love with Aiken a little bit. The Hydra team actually prototyped some of the Hydra stuff with Aiken and did a cross-comparison to Plutus script, and there's...

The committee can transition from static and hardcoded to dynamic and voted on with a quorum that can be expanded. It's an m of n principle with fixed terms. Also, it allows Plutus scripts to be used, meaning that multiple parties can control one of those keys as opposed to a single organization, for example. It accommodates all kinds of bespoke governance structures and also makes them beholden to an on-chain constitution.

...improves the state of affairs there. There's been about a year's worth of work on that backbone protocol. Big improvements to Extended UTXO and Plutus, BLS support for Plutus is another thing that we've been working on. It should come in Plutus version 3. There's a lot of protocols that rely upon that, especially for cross-chain bridging. We've been doing a ton of R&D on Pluto Eris.

Yes, these things are moving along. Another topic that came up is the projects that didn't work out as well as we had anticipated or hoped. There's been a collection, you know, that I'd like to mention a little bit, because I think sometimes, what people say is unfair. Two, in particular, are the Plutus Application Backend and IELE. So, PAB was our guess about what the development...

...the tooling and experience needed to be in place for when somebody was building an application on Cardano. Our guess was not right, and so what ended up happening over a two-year period is that we, plus the community, built out a constellation of upgrades to Plutus tools and SDKs that basically encompassed the original intent of that. So, it's not like it wasn't delivered, it's just that nobody wanted it....

...to use what that idea was, it so pivoted and turned into things like TX pipe, Aiken, Marlow, uh o, and upgrades to Plutus and you, things like that. So there's still a lot of things to do, but it's very common when you develop a programming language to have an unstable standard library and an unstable development kit for about two to three years. If you don't believe me...

...so that standard stuff starts flowing. In fact, in 2015, Rust came out. Rust was very primitive; no one would dare use it. They'd say, "Oh no, we can't use Rust." Well now, it's the most common programming language in the cryptocurrency space. So, it takes time for languages to evolve, and Plutus has been going through that evolution. You know, every generation, you get improvements to the compiler.

The stuff is completely community-led and built. There's great decentralized governance coming. It’s minimum viable governance through CIP1694, which was completely ratified through a community-led process. There's a great members-based organization beginning to aggregate everyone together for a decentralized product backlog. Plutus has gone through multiple iterations.

...Hydra pivoted a little bit and it pivoted into let's build some middleware that it's going to be really easy for you as a developer to plug into your application work with Plutus to help get a lot of that complex logic that you should not run on the main network but run it on a different network like the batching, the voting, and the event-oriented programming, the event-based programming where events happen and you have to be around 24/7 to pick them up and do something. Multisig, all kinds of stuff that you'd like to run in some sort of other network and you could build stuff on top so what's happened is an open-source ecosystem is forming around that concept and what they're doing is they're building applications and...

To do is simply increase the sophistication of your proof languages and your underlying script language. Now, it takes a while for these things to evolve, and you'll notice that Plutus 1 is a very different animal from Plutus 2. In many cases, there is a 10x reduction in transaction size from Plutus 1 to 2. Something that was multiple kilobytes went down by a factor of 10. Most dapp...

...developers have upgraded to Plutus 2, and you can see those amazing savings in just one generation of the language. Imagine where we'll be in three to five years with the continual evolution of these things. Imagine what will happen when the things on the wire are not just script but complex proofs involving snarks. These proofs will be a roll-up of many off-chain activities. It's exciting to think about how much throughput we will have.

Now, things like BLS for example are a big component of this but there's other constructions that are needed and that's coming in Plutus 3.0, for example, the very next version of Plutus BLS support.

Optimizations is about better resource utilization while on chain. For example, Plutus 2.0 that shipped with Vasil, you'll notice a lot of the DApp developers saying hey we've had a 10x Improvement in terms of the utilization of resources.

So, a script that's a kilobyte now is a hundred bytes. Well, that's crazy, that's a 10x that means just much more efficient utilization of the resources that we have. So, there's lots of iterative optimizations that are being done on the network layer, the block structure, the authenticated data structures that are used, Plutus optimizations and other things which gain meaningful percentages over time.

So these are continuous processes and while they require in some cases hard Forks like adding new versions of Plutus in to support proof structures and also the fast finality is something called Praos that's the next version of Ouroboros after Genesis that basically gives you a finality gadgets at the system so you can have fast settlement on both sides the main chain the sidechain and sidechain the main chain.

Optimizations obviously are happening on a regular basis. For example, you guys saw node 8.0 or the Vasil hard fork with all the Plutus improvements that have happened. So a lot of people have strong opinions one way or the other, and that's why decentralized governance is so important. Those opinions really do need to be included and discussed.

It's easier to draw it, it slows me down a little bit, and also it allows us to have no ambiguity, which is very important. Right now, we have the IO repos, and they're going to move over to the Intersect repos. At Input Output, we have this concept of tribes, and each tribe is connected to a different concept like smart contracts, for example, core technology. Smart Contracts covers things like Plutus, Marlowe, extended UTXO, core technology covers core node, network, consensus, we have tribes like identities, sidechains and so forth.

The basic idea is you establish a technical baseline showing you know how to read and actually work on the code, you establish a baseline for how everybody works together in the system, and then you establish a baseline for how Cardano works under the hood. Network protocol, extended UTXO, how Plutus works, how Ouroboros works, all the APIs etc etc. So, basically these type of things will get you up to speed as a core dev. So, if they are designed correctly, you should be in the position and demonstrate enough technical skill that you should deserve credentials.

That's the point of good governance, that you can get things done but you get wise good things done on a regular basis. What's also super cool about this structure is that this structure can act as a primary secondary concern. What I mean by that is that you have Cardano as your top-level project but then you have these other projects like Hydra for example, Open Prism, Plutus as the language because that's different, Marlowe.

People are actually swapping real time while I'm talking, and it's a Plutus V1. So this I'm in a very efficient contract. Ooh, some scripts. Over here, people are using smart contracts. You got NFTs, smart contracts, DEX transactions.

Now, here's the thing. Every one of those blocks. They're going to get more efficient; Plutus continues. To get more efficient version one, version 2, version three, is on the way. Already a 10X reduction you go from like a KB to 100 bytes. Many cases for things. And Plutus V3 three even more capabilities, like BLS and these things, so more stuff goes in to each block.

For example, BLS support and Plutus is on the horizon. There's a lot of really cool things to announce second-half this year about the side chain strategy and what will come to play.

We look to the future and the vision there's plenty of things we're going to need to do to clean things up. Improve TPS, make transactions a little better, make it easier to write smart contracts. But let's look at how far we've got. Wasn't too long ago that we didn't even have smart contracts in the system. Now we're in version 2, soon to be in version 3 of Plutus, and we've already gotten a 10X improvement in many different categories, and it's much easier to write contracts today than it was just a year ago.

The reality is that we're all working together and we're getting a lot of progress. You know, Cardano is really maturing. Cardano node 8.11 is incredible. Plutus is really shaping up, especially with BLS support on Plutus. Lot of wonderful things happening on the sidechain side, lot of really wonderful things happening with HYDRA.

Then you have Plutus and there's still a lot of scoping right now for V3, there's a lot of optimizations that still need to be done. The question is how much is semantic level, meaning it's hard fork and it's a different version versus tooling like improving the compiler and the tooling and the SDK and these types of experiences. Plutus team hard at work in those definitions, but one real important thing is BLS signature support, because that really opens up a lot of capabilities.

Given Plutus has a limited time budget per blog. So, things like BLS are pretty straightforward. Pasta would not be. So therein lies kind of the rub of of what needs to be done to accommodate heavier, more persistent, event oriented crypto primitives without necessitating field arithmetic conversions. So, conversion like a Pasta to a BLS because it's a very expensive conversion of a of a proof.

So that's why a lot of the dapps and define Cardano are so novel, interesting and innovative, because they've actually had to redesign and rethink their protocols from the perspective of extended UTXO and for Plutus.

That's great, but on the other hand, on the peripheries of it we have a very vibrant, diverse set of opinions, like for example, the programming language side with projects like Aiken. Radically different from Plutus and people are trying to bring TypeScript into Cardano. There are sidechains that will come like flowers, thousands of them blooming over the next 24-36 months.

As you know, we have a long academic legacy here at input output and we have many incredible research fellows and senior research fellows, but one of my personal favorites and a good close friend who we've collaborated with for a very long time throughout the legacy and the Co inventor of Plutus, the programming language of Cardano. Philip Wadler, professor Wadler at University of Edinburgh, has been elected as a fellow at the Royal Society and I just wanted to share my screen real quick for the press release.

Fellows are elected for life on the basis of excellence and silence, and are entitled to use post-nominal FRS letters, Wadler is one of the legends in many things. He created Haskell with many others, and also he's contributed to C#, F#, GO, Rust, Scala and Swift. But for us he's the guy that helped us design and think about Plutus. We're so proud of him and it's a great honor that we have as a senior research fellow, someone who is a royal fellow like Sir Isaac Newton, Charles Darwin and the rest.

Keep chipping away at it. There's obviously a lot more work to do on peer-to-peer, lot of quality improvements to do. Plutus 3 to do. So, there's a whole family of non-governance things that are under heavy development right now in Cardano node, but in terms of Cardano node 8.0, this is a major step forward and obviously there's a few known issues and various things. So, if you take a look at this list, these are some of the known issues.

...actually, I built an incredible Network layer, and I'm really proud of that work. It took a long time to get here though, too long. There are some good questions in this chat now. Uh, where are the best Cardano tutorials? If good tutorials are essential, Cardano has the entire list, but it really does depend on what you're looking for. You know, we have education channels like 'Plutus Pioneers' and these...

...Plutus, like Plutus V3, Plutus V4, and all the advancements that they're doing there, as well as natural iterations of Ouroboros, like after Genesis is out. I'd really like to see Praos and Chronos next year, so you have fast finality gadgets and proper timekeeping. I also really like how Hydra is evolving and I just love the complementarity...

This person right here asked, "What is Plutus V3?" It's the next version of language. So, V2 came with fossil and V3 is the next version. It's just that a lot of these things, you go and talk to app developers, they want a bunch of things, and then you just keep evolving the language. It takes about three to seven years, uh, to get to a good programming language...

It's definitely a priority, and we've thought about it for a long time. We did the Plutus Pioneers program, the Prism Pioneers program, the Marlow Pilators program, and the Haskell classes. By no means are we slouching. It's just that we need a certificate program and we've debated for a long time about whether to try to embed this at a particular university or...

...what's going to have to be done is, uh, an examination of these things to expand the working space and create a semi-persistent layer inside the system. So a lot of that stuff is going on and actually, it's happening at a blinding pace, uh, roughly in parallel, and a lot of really clever things are happening with Plutus version three. Uh, with the upcoming launch of Marlow, uh...

...The Pi cycle, it's really exciting to see how that's been growing. So, we're just firing on all cylinders there. There has never been this volume of work progress, and just diversity of progress, in our ecosystem. Literally, there are major innovations and side chains, governance, consumer software, identity software, off-chain frameworks like Hydra for systems like Mithril, and language design like Plutus...

We really are starting to see all of the metrics looking great, whether it be TVL transaction volume or the programming paradigm itself, really starting to get to that nice maturity now. There are several more versions of Plutus that need to come, and there's a lot more infrastructure that needs to be built. By no means is Cardano a mature ecosystem from the perspective of being easy for...

Immersed in it would be great, so yes, I will actually take you up on that offer. Okay, as for the framework or ad, I think there's actual case support for Plutus because the semantics have been written in K. If not, I'll call Gregorian, we'll get around to it because they did an earlier version of Plutus. It would be nice for Plutus V2 to have K semantics for it, but ultimately I...

Blocks in the Cardinal Network, as you see, each of those little blocks is actually a transaction, and all those outputs are different things happening at the same time. So, if I highlight one of these, you see that it's a script for Plutus, and these are NFTs, and those are Ada being moved. So, that's a single transaction. Look at all the different events that have occurred.

Uh, so yeah, I think it's just a great model and it's built, handling a love for Hydra. It's built, hand and glove, for side chain transactions, Roll-Ups, off chain stuff, and it's very clear how you optimize the UTXO model over time. Ergo's done some great work and we continue to do great work. With every version of Plutus and update UTXO, it'll get more efficient so you can horizontally scale.

"I don't want to read that," they say. "Well, then you don't deserve an answer." Also, we talked to the guys from Clio, Marcus and Robert, who conducted the first Plutus training course. We asked them to assist us in parsing the questions. Once they've parsed, they are basically taking our answers and creating educational material based on that. So, we will create educational material...

If you buy a VIP ticket, you actually get to go to the VIP conference and concert. I think there's just going to be a lot of value there. There will be hackathons, workshops, some of which are going to talk about zero-knowledge proofs, others about Plutus. Some of them are going to talk about many of the engineering principles we use and how to use NYX. There's going to be a crypto puzzle where we're...

We've learned a lot along the way, but you know we're getting there. It's nice to see how quickly things are coming together and how we're able to have great conversations about the work that's been done. I'm really excited to see Shelley come out. I'm also really excited to see Plutus and Marlow come out. There are a lot of cool things there, and I think you guys are going to be really happy with the product, I thank you so much for your time, and I will talk to everybody soon.

...the ledger needs to work for Shelley, covering all the features that Shelley's going to have, like multi-asset accounting. So, when you issue assets, how can you track multiple assets at the same time? There are also extensions to UTXO models so that we can actually implement Plutus and Marlowe into the system, amongst a litany of other little features like, for example, the notion of preservation of value where...

Interactive protocols are not only delivered, but they're also signed by both the sender and the receiver. This is the magic of Marlow and Plutus. A lot of these things involve some degree of complexity around the richness of the semantics of the scripting language, as well as the address structure itself. But how much data can we store in there? What types of attributes can touch the addresses?

Jared, the principal architect of these specifications, will be updating the ledgers based on the UTXO spec throughout this month and next. This update will reflect the reality that we're deviating from the normal UTXO to what's called extended UTXO. This revision is a requirement for Plutus and Marlowe to work in our system. Hence, we kind of have this beautiful team.

They are working on something called a mock chain. It's a kind of fake blockchain that they constructed to test out and verify that their smart contract language works. However, at some point, we have to run Plutus on a real system. The Plutus team is approaching a 1.0 milestone. Plutus Fest essentially showcased Plutus to the world and the general Piell community, and we have received excellent feedback from it.

Now, people using Pluto's playground are actually able to build things, and we recently even saw a course launched on how to use Plutus by members of the community. So that was a huge milestone, a great success for us. But there needs to be a kind of methodical movement of Plutus into our system, and that's going to be done by updating the specification to reflect that within...

The Extended UTXO model has an advantage; the approach we've taken turns out to be a rather mild extension compared to delegation. Thus, it can be added quickly into Ledger post-Shelley, and it doesn't reach the same scale or complexity. Most of the scale and complexity are within the language design. Truly, it's a four-layer model consisting of Marlowe, Plutus, Haskell.

...logic that allows them to solve that set of problems is for programmers who want to live within a certain environment: that's what Plutus is all about. However, when you go outside of that environment and shift to a more general environment, either directly on the system's metal or within some sort of VM like V8 or Web Assembly, then give them the Haskell side and then GHEJS.

WebAssembly side, so we can adequately cover all parts of that triangle: the server, the client, and the blockchain. This is the Plutus paradigm. Now, getting that into Cardano is not very hard because that environment has been custom-built for it. The hard part is deciding what that's going to look like, and we spent two years of research with the best people in the field, like Phil...

...and updating the EV1 API has been extended so that we can cover all the staking related features, and things necessary for Plutus. Then, going beyond that, the team will also be working on getting ledger support for multi-account settings, so that you can manage public keys, like your paper wallets and your ledger devices. The delegation center, these types of mechanics...

The implementations are just wonderful due to recent work, so we chose that model. Basically, with the Plutus side, the way Generation 1 dapp development will work is that you'll write your Marlowe and Plutus code for all of the logic that will go on the blockchain. Then, you'll write something like Haskell for the logic that's going to be on the client side, or you could write that...

...as opposed to one, the nice part about the way we designed Plutus and Marlow is that, because of these things and the use of extended UTXO models, it's much easier to shard them. Moreover, it's much easier to actually understand how to load balance these types of things. So, that's less of an issue for us. But, there's a natural avenue that the entire industry is starting to move towards with ventures.

They finish the Haskell component and they're going to do the Plutus component, and do some cool workshop. Actually, because the IOHK Summit is happening in April, we may actually fly that class out. Because they'll be matriculated at that point, the survivors it is a very difficult class and have them come out to Miami and do a presentation. So, if you guys go to Miami...

So, for the users of our testnet if you've used Mallet to deploy smart contracts to the K-EVM and into Yella, a lot of those concepts and ideas that we have there will be taken and put into Cardano wallet for Plutus as well as the eventually the sidechain connections that we have for Yella and for the K-EVM.

So given that Plutus is embedded within Haskell, if we're going to have a good experience with people deploying these scripts and running those using Template House code on the client side in addition to the blockchain, the server, we need to have a way of getting this into a browser and there's two routes we can take.

It also means that when you write a Plutus style smart contract, your development tools, your development environment, and even the Dapp deployment environment could conceivably be 100% inside the browser or within Daedalus because Daedalus is built on top of electron.

So, the question is, will security tokens be a sidechain or will they be incumbent within the system. The nature of Plutus and Marlowe makes our system uniquely well suited for people to build an asset that will conform to many of the characteristics that just mentioned.

And one of the things we wanted to do before we got there was first have a really deep understanding of how expressive our UTXO model was going to be. So, we needed to create Plutus and Marlowe for that, second, we need to have a really good understanding of how we wanted to handle both delegation and voting. These are the ingredients that go into address complexity.

And the goal there is to try to make that transition as easy as possible. That's reflected with the Plutus mindset with our organization where we see there's just a fundamentally different way to write these types of applications, which is more elegant, more secure, lower cost to maintain and more realistic with how these systems are actually being deployed.

So, we have Haskell, Plutus, Marlowe. It runs the client server and blockchain and there's lots of things we can do within that model, to make those things easy.

If we're right and we think that we'll do for a new paradigm. Plutus will take off and become the successful paradigm and be able to go off and convince people that this is the better way of doing things.

Hi Charles, can you please talk about your plans for Plutus hackathons getting devs on board to learn Plutus. Thanks very much. So, the good news is that Plutus already has a fan base and a user base.

So in my view, when you're trying to prove out an ecosystem and show that an ecosystem can really do something special you invite the best of that party and we felt that by going niche with Plutus in Haskell, this would give us the best opportunity to do that.

Now, I love comments like this, Cardano has no smart contracts it can use today, like blockchains already have. We have 3 testnets. You can run Plutus contracts, you can run EVM contracts, and you can run Yella contracts.

I just returned from my long trip all around the world. I final trip was in Scotland; I was in Edinburgh for Plutus Fest and that was a great degree of fun. I had a chance to finally sit down with the Plutus and Marlowe team.

We've had a huge amount of successes here with the Ouroboros program. I think this is one of the crown jewels. There's really two major crown jewels of Cardano's portfolio, the other being Plutus and Marlowe, and our work with Yella and K and Ouroboros is the other crown jewel.

So we're going to be doing the workshop for IOHK and some of our third-party partners come early January in Berlin specifically about the delegation specification and to finalize that specification, much like Plutus Fest kind of forced us to finalize the specification for Plutus 1.0 and Marlowe 1.0, we'll be doing the exact same with the with the delegation specification, which will also be made publicly available, just like the wallet backend spec was made publicly available.

The delegation work and the rewriting of the entire code base. The smart contract stuff was done by a scholar team and done by a language designing team. The language designing team was led by Philip Wadler and Wilshire Vardy ?????, and they're based at University of Edinburgh, and they had their own group, their own resources and they were following a two-year track and that Plutus track and Marlowe track have now come to a research end, and we've been moving into actual implementation. So none of the Shelley delays from the Ouroboros side and the delegation side cascaded into the language side...

So, there's still a lot more to do. There's still a lot more testing to do, but the concepts like extended UTXO, how Plutus works, how to integrate Plutus, how to integrate sidechains. How to run a sidechain with the Mantis network and roll that over into production code...

Now, because Plutus playgrounds are out, and Yella is out. People are using these things to write interesting scripts and anticipation for the network launching.

Coming home for a little bit, then I'll be in Vegas, and I'll be in Scotland for Plutus fest and then from Plutus Fest I'm going to, I think Abu Dhabi and then after that I'm going down to Uganda where we're going to have a lot of cool announcements about various things we're doing in Uganda and that'll be in December. So,look for those.

But our our Pan-African strategy is really coming together and it's pretty amazing to see how fast things have been growing in terms of Plutus fest, that's going to be really cool. The Plutus team has been working for about a year and a half on Plutus.

And they've really done some amazing things there and Plutus fest is the first opportunity to kind of show this off to the world and we're working really hard to make it easy for people to write test Plutus contracts.

We have this concept called a mock chain and basically the mock chain is making it like a fake blockchain so you can write all these Plutus contracts and you can deploy them on the mock chain and run them and it's an operating environment that's kind of like what you would expect when the Plutus gets integrated into Cardano.

So, so Plutus Fest will be really the first time we open that up and do tutorials. And our hope is to probably have a hackathon or something like that along with a few tutorial sessions. There are going to be two tracks with Plutus Fest.

And that's that's mostly meant for the PHD's and people who care about that stuff and then the other track is going to be for developers. People who are interested in writing Plutus smart contracts and people interested in this extended UTXO model, as well as how does Pascal, Plutus, and Marlowe, How do they all fit together and what does that development experience look like.

So we're going to have a lot of people and you'll have a first-hand chance to meet them. Talk to them. We're going to be giving away free T-shirts, some mugs with the Plutus logo and some other surprises. We're also going to try to get the operational semantics of Plutus on a napkin because back in January of this year in Portugal, we were amused aloud if it was possible to get the semantics so simple that they could be on a dinner napkin.

And they're going to be quite robust and a lot of them will deploy relays in addition to just doing staking services. And there's a strong potential we could layer on top of that a payment channel system and layer on top of that and oracle system and federate these things. So that's going to be a high priority for 2019, especially as we pull Plutus into the base ledger.

Is Plutus going to have dependent types like Idris, ADGA, or COQ, that is a really good question. The closest I think will come to that is probably refinement types. If you're familiar with Liquid Haskell, you should look that up, and those ought to be sufficient for most verification work that you want to do. We could do dependent types, but then it begs the question of. Would it just simply make more sense to write an Idris to Plutus compiler? And then you could just simply write things in Idris. You know, and then you could reuse that ecosystem. But we find that types are certainly something we're interested in. IOHK is going to start investing money into liquid Haskell and making sure that that ecosystem becomes much more prevalent. We're also going to start investing money into GHCJS.

So it would be nice to see liquid Plutus and bring that in. So that's something we'll definitely talk about at the summit.

Plutus fest is coming up in December, and we're going for the first time ever show off Plutus and Marlowe and let people write smart contracts and have a great chance to understand this new innovation that we brought to the space our sidechains research it's really just incredible.

Phillip and Rick, I think are going to do a phenomenal job and we also invited them to come out to Plutus fest, so hopefully I'll be able to meet them in person for the first time ever, and hopefully they'll be able to do some episodes there and interview Philip Wadler, Manuel Chakravarty, and the rest of the people on that team, including Duncan Coutts. So that's all I have to say here.

It's not an end all be all technology, and it's not something we've bet the entire farm on as we have a whole team doing something very different with Plutus. But it is something we feel gives us a really compelling story about interoperability and can bring a lot of mainstream regular everyday developers into our system. Having this almost universal language.

Building manual transactions and offline transactions and extending that API for other parameters like delegation and so forth. We can do that without being on the normal release cycle for for Cardano. So those are going to be near term goals. That we're working towards me and meantime we have three parallel teams working full time on all of the Shelley related stuff, some on delegation, some on Ouroboros Genesis. Other dimensions of that stuff and some on the new Ledger rules You know some on how we're going to extend the UTXO set to include Plutus and Marlowe. It's a humongous amount of work.

The next versions will be on Ouroboros BFT and decoupling of components in preparation for Shelley. And then Shelley testnet next. And then after that, it's basically Shelley. Decentralization. Then very short leader after tackle on the side chains, extended UTXO and yeah, Plutus, Marlowe and then K-EVM and IELE. So lot of stuff is coming soon and long long overdo.

…preserving our principles, it's obviously imperfect, but actually if you look at the productivity of the Ouroboros team as the case study or the Plutus team as a case study, uh, we're moving as faster, faster than our competitors. In fact, in our opinion, we feel we're ahead of Casper and in our opinion we feel that...

Can you explain the difference between Plutus, Marlowe and IELE and the K-EVM? So, you can break smart contracts and financial transactions into kind of two worlds. There is the world of I am sending some notion of value between one actor or group of actors to a another actor or to another group of actors.

So Marlow and to a certain extent, Plutus is about that notion that saying I want to have very rich financial relationships and transactions between Alice and Bob or Microsoft and Google or Goldman Sachs and Chase. I want to have an ability of writing down intent...

So that's the difference between the two. One, it's really all about. I want to write better financial transactions and better assets and these types of things, the whole family of thought. And that's what Marlow is all about. And to a certain extent, Plutus. And then the other side of it is all about, I want to have a that service in that triangle to do something for my application, which is going to run on your computer on a server.

And kind of the utility side of allowing smart contracts in some form in a functional form at the base layer with Monroe and Plutus and the extended UTXO model or if it really ought to be outsourced to a different Ledger that's meant specifically for safe contracts.

Whereas Plutus is a completely new thing and there's a lot of potential execution.

So we've already started some preliminary discussions like we talked around JIT and Nikki wazoo about Liquid Haskell and this idea of introducing refinement types into our own development process and it'd be so cool to have, like liquid Plutus or something like that where we can introduce that notion into our stack.

Bitcoin only covers a small sliver of it, and that's one of the original biggest frustrations that I had and others had with Bitcoin was It only covered a sliver of this beautiful, rich financial ecosystem. So what we decided to do is say, all right, why don't we build an accounting ledger that allows you to represent the types of assets and those types of transactions in the most efficient and parallelizable way possible? 00:20:29 So, you can get these to scale long-term performance, but then you can also do everything that Wall Street is used to doing. So, we created a domain-specific language called Marlowe. We also created a general-purpose programming language that was functional that Marlowe embeds in called Plutus, and we really rigorously thought about the UTXO accounting model. We also came up with a method to issue assets within that model that's interoperable with the Ethereum-style account.

What's really exciting is Plutus and Marlowe, cause that's a totally new thing and we think people are going to really love that. And our hope is to pull that into SL itself if possible, so that you have the absolute best Ledger to issue assets on if that's your desire.

And we're glad to see that there is still some innovation there. We still do learn from ideas that Blockstream has presented. Russell O'Connor's work on simplicity, for example, was very elegant and really helped us think through some ideas about Plutus. We would hope that the Bitcoin core developers take some of our work more seriously, in particular, work on sidechains, and in particular our work on UTXO wallet design.

But we can install IELE, which is a cardano's virtual machine, into this framework and then deploy a test that so that we can begin testing Plutus and solidity smart contracts on the IELE virtual machine so that we can do things like fine tune the gas model and also clean up a lot of the engineering rough edges.