...longer development cycles of the software, um, required us, as an ecosystem, to essentially learn how to develop within that paradigm. Additionally, there were a lot of technologies we would have loved to have, but they turned out to be better suited elsewhere. For example, IELE in the Cardano service layer, as opposed to being on the main chain, became a sidechain. There were also some really awesome wins like

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...

...there's always something you leave out, which a developer would like to have. If you look at the evolution of things today versus in 2021, when the Alonzo hard fork happened, it has been a day and night difference. Now, IELE is an entirely different animal. Back in the day, I wanted to combine the accounts-based model and the extended UTXO model into one system, because they both do different things.

...people really didn't relish the idea of putting both of these things in one system. They compromised a little bit and introduced pseudo account style features into the system for Stake Pools, rewards, and similar things. You'll see this in the alleged spe, but for the most part, it is an extended UTXO system. IELE and K, they were truly built as a next...

Behold, when we worked with Gregory, who was at the University of Illinois, Urbana-Champaign, we suddenly had something that looked like prior IP. Now, there was a lot to love about IELE. It was a proper development model, a proper virtual machine. There was a lot of great stuff there. Uh, it was register-based instead of stack-based, so it's much more sensible from a programming perspective.

And we could borrow about 20 years' worth of compiler design, so we built up a corpus of things. We started from K specifications, so we had a formal representation of the system. The hope was that with IELE, we would achieve something called semantic-based compilation. Semantic-based compilation basically translates to "if you have one programming language, let's..."

...there, translate it in a way that it could execute on IELE. That was the hope. Now, what this would mean then is, we could take normal programming languages and write subsets of them in K, and then basically have a standard library specifically for that language to support smart contracts. So, normal developers could go and write code in that paradigm. Now, this was an R&D.

We put an enormous amount of money into the project. There were 19 people working full time on IELE for years. Millions of dollars were spent, papers were written, they're called Reachability Logics among other things. We never achieved semantics-based compilation and we never quite got IELE and K to a point where it would make sense to make that the backbone of a...

...it would be nice to see IELE resurrected and K resurrected in a product, but this is the nature of prototypes in computer science. You have a pretty good idea you're pursuing. You spend millions of dollars on it, and it doesn't quite work out the way you hoped. We have many examples of that in technology. For example, HD DVDs versus Blu-ray. You know, it's perfectly...

Fewer people really anticipated the rise of Json the way it moved, and now it's canonical. You have databases based on it. Technology works this way; you have to be agile and move in the right direction. It made a lot more sense to say, if we are going to do something that uses accounts and K and IELE, it probably ought to be done on a side chain.

The science that was done doesn't always work out. This doesn't mean we lied or misled people. I mean, we have the receipts. We hired 19 people and there are research partnerships. We've worked closely with Gregory for years on end, and we have a ton of code that was produced. People were even testing IELE on an EVM style testnet using the scala code, and I still think the repositories are available.

It probably wouldn't have been advantageous to Cardano in its current iteration and form. It would have introduced a lot of problems, and I've come to agree with the architects who disagree with the implementation of an integration of IELE into the layer one. It would be nice to see it though, in K, in a side chain. So that's an example of how these things go, you know, when you...

We did not talk to the Ethereum Foundation. We didn't ask for permission. We didn't have to get right access to their GitHub or something like that. We just took the IELE paper, the documentation of Ethereum, and from that documentation, we were able to build a Scala client from scratch. Fifteen thousand lines of code - it took a while but we did that and that client was able to...

...Ethereum has things that are off spec. You don't need to have a specification done to ship the product. It's just, if you do that, then that means you're basically seeing the code as the specification. For example, when Runtime Verification worked on the KVM project, they found out that the IELE paper was not a complete specification of the design of the Ethereum virtual machine.

Second building that client trained our developers to understand how the Ethereum ecosystem worked. They literally started from nothing, just from the IELE paper and from the documentation and wrote 100% new code in Scala, so that exercise was incredibly valuable, creating a knowledge transfer and bridging the skill gap so that we understood where Ethereum is at and all the things it could do and all the things it couldn’t do. It's easy to be overly academic or to kind of throw the baby out with the bathwater...

You can do that with a control layer and that's what the second layer of our system is and what we've already demonstrated in practice with K-EVM and the IELE testnets. So when our sidechains protocol comes out, if your system is compliant with that protocol, people will be able to move ADA back into your system and out of your system and you'll be able to move your token in your system, to our system and back.

There's not a master slave relationship. It's a firewall relationship, meaning that it's easy to move assets to and from. On the 1st generation of sidechains we launch, will be custom tailored for K-EVM and IELE, as this is for interoperability with those smart contract paradigms, but later versions will include more generalities, so we can wire our system together with things like ETC and Ethereum and future versions of other protocols or potentially even Bitcoin, depending upon where their upgrade path sits and your cryptocurrency as well, just follow an open standard.

So this is a kind of a butchered simplification of the concept, but it is meaningful for us as an ecosystem, because what it effectively means that if we do things in a very careful way with IELE, given that we have the K semantics of IELE. All we will need to do, when semantics based compilation has reached its N??? There is to just simply write the semantics once of a new programming language, and if we ever want to update IELE, we just update the semantics of IELE, but we do not need to update the semantics of any other programming language hypothetically.

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.

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.

OK, so what IELE in K-EVM are about is about following that model of saying I need some sort of replicated engine that I can deploy code to, and the code is going to run and it's going to run in a security model where the output that I get, I have a high degree of certainty to it's got storage, got network capacity that's some computation.

That's the dapp model. Now why IELE? Well, because K and semantics based computation compilation gives us a path over an arc of time to have the best possible tooling to verify these types of programs are written correctly and also gives us the greatest chance to have interoperability with the largest set of languages Java, C++, C JavaScript, Python, Ruby, Closure....

And if we ever update the virtual machine to IELE version two or version three, you have to update the compilers. Because the semantics auto update with your semantics-based compilation.

So along that same token, it's trivial for me to have K-EVM and IELE running in the same system and then maybe iOS or maybe something else? So if there's a particular competitor who's done some great work and they're getting a lot of adoption, I can bring that into my system.

IELE test nuts out the KVM test.

The IELE test that out, and there's probably maybe only 2-3 months worth of tuning and parameterization that we'd like to do and cleaning, we'd like to do before we'd feel comfortable with the 1.0.

Assuming semantics based compilation and you know case rewrite and K to IELE VM is done and so forth.

IELE ellow is more of a logical refinement of everything that Ethereum was about, and just trying to take an old thing and make it better.

So, we felt it was very important for us to invest money into building from the ground up a completely new client from nothing. So we just took the IELE paper, the documentation we borrowed no code, we brought together a great team of Scala developers. We called them the growth team and we said to have fun, and they spent basically a year constructing at the moment the most concise Ethereum client ever built.

They created IELE, which was based on LLVM, a very successful framework funded by Apple. Steve Jobs himself really likedit. The department chair of the University of Illinois Urbana Champagne was one of the builders. We believe this is a powerful tool. IELE alone would be cool, it's pretty easy to write compilers for IELE, because it's like targeting LLVM, and that's very well understood at the moment by language designers.

Now the really cool thing about this is if you upgrade your base layers. Let's say we come up with IELE 2.0 based upon all the lessons and experiences and magic we've learned from IELE. You only update the semantics of IELE. And you change nothing else in the system and you don't have to update any compiler or anything like that.

So that's really cool. And I think there's some magic there so that's kind of a second bucket. There's nineteen people that are working on that. Some are rebuilding the K framework to make it better based on the 15 years of lessons that RV has learned from it. Some are working on semantics based compilation. Some people are working on IELE, the IELE testnet that's actually going to be launching at the end of the month as the first example of it.

So if we wanted to after the IELE testnet is complete, which would only take a few months, we certainly could have a smart contract layer for Cardano.

OK, that layer would be faster and have more capabilities than Ethereum and would certainly have a kind of a better development experience because we probably could be more clever about the surface languages that target IELE.

So after the IELE testnet that's had some time to run, we'll take a look at where we're at, take a look at where our sidechains protocols are at and then we'll make some form of announcement of when we think we can start linking CL and SL together.

We already have an Ethereum version of CL running. It's been running for over a month and the IELE version will be running at the end of this month, so you know all the things you come to know and love with Ethereum you'll be able to do, and then we'll have some new capabilities that we roll out as well.

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.

Currently, they have eight people, and our hope is to more than double the size of that team over an arc of a few months. They have a very rigorous, beautiful work agenda for evolving IELE to make it the finest virtual machine the world's ever seen for smart contracts.