...and then, every time that network makes blocks, it's paid to ADA holders. How is that bad for the broader ecosystem? I think it's more just fear of the unknown and, I think, it's also that this is a complicated concept. And you know, we say again and again, there's governance, there's scalability, and there's interoperability. And governance, it's a big fight, and everybody's talking about it.

It can't even do a ballot vote without some drama. It is what it is. It's okay, it's a controversial thing, and CIP1694 is helping to push us in that direction. When you talk about scalability, we have input endorsers and that's great, but other people even have their own ideas on how to achieve scalability, and they are certainly very passionate about it. But interoperability? It really is a game of asking, "What are we being Interoperable about?"

...a transaction is submitted to the network; the network upgrades. That's how it is done with CIP1694. Any person in the entire Cardano network can submit a request to upgrade the system or make changes to the system. It was very important to me that this be included. We'll test the scalability of that, but I do believe it's in the CIP. Once they do that, there's a

"Technologically feasible, what's implementable, what's scalable, what's in the realm of possibility" - once these were written down, we then considered what we could deviate and modify, and what would cause a radical divergence from that governance system. Afterwards, it was opened up to the world, and dozens of workshops were held globally. A significant number of people came and participated in engaging discussions about these topics.

Uh, I love Scala and functional programming. Scala 3 is one of my favorite languages, man. I love it. I highly recommend it. Did you, or did you not, call XRP holders crazy when they mentioned EthGate? I just explained exactly what I said regarding the grand conspiracy. And then, when people linked them together and overreacted as you are doing literally right now, it proved my point. Uh.

And I explained what happened, and I made multiple videos. It escalated, escalated, escalated, and now we're back. We're literally back here; we're right here, again. You just proved every single thing I was just saying. You can't separate them; you just can't. I never once said your thoughts about Hinman or these other things, like Eth gate, are conspiracy. I said the notion that...

...you can go back to the record and look at Clojure. We can look at Scala. We can look at Cotlin. We can look at Python. We can look at Ruby. We can look at the development of D, which still doesn't have a canonical library, last time I checked. You can look at iterations of Java, and in every case, it takes about two to three years for the core language to stabilize enough.

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.

Ouroboros Leios, which is the input endorsers workstream, will allow mass parallelization and high-speed layer one. But we are also looking at rollups as an ecosystem, side chains as an ecosystem, and yes, evolutions of Hydra. I made a 45-minute scalability video about these things. But what people do is they take a single quote, a single paragraph, a single notion that was there to elucidate...

That transaction could be a lot of stuff. It could be like, hey, I want to move money, okay, so an asset. That could be something like using a smart contract. It could be something like I want to vote. It could be something like I want to make or register some certificate, okay, etc. There are many, many different use cases for Bob. So, when you talk about scalability, really what you're talking about is you're talking about a bunch of different properties.

so properties of scalability. So, you look at things like predictability. So, predictability means that when Bob wants to do these types of things, can he predict the cost, can he predict the latency, can he predict the reliability?

So, you have different metrics of predictability, cost, latency. Latency is how long does it take? Is that predictable, meaning that we say usually it settles within this range of time? Is that the case, or is it completely unpredictable where sometimes it settles in an hour, sometimes it settles in five seconds? Is cost predictable? This is the single biggest driver for enterprise. Okay, so then you have other properties of scalability such as resource growth. Under what circumstances do the resources of the system grow or contract?

Or is it the case that the more Bobs you get, the pie gets bigger, and you get a much larger resource pool for people? So truly scalable protocols, we generally think about resource growth that is proportional to the user growth. So, as you gain users, you gain resources in the system, and resources are the things that are, and it's an ambiguous term, so generally speaking, resources are consumed from these types of activities.

Okay, now there's a trade-off. Also, have a notion of security. So usually, almost all of the high scalability protocols that we see, your Byzantine resistance goes from a one-half dishonesty to about a third, and in some extreme cases, a fourth.

Over here, it's everybody and their uncle. Like you can leave your cell phone on and the charger, and it potentially could be doing something for the network. So when we talk about scalability, the Basho agenda was really started as a research project to better understand these types of things.

And so that's a fast and continuous notion of scalability. So it always improves the profile, and things just keep getting better. Now you'll notice something on Mithril. This is really the beginning of data availability and proof systems.

In other words, your trade-off profile, remember we always talk about trade-offs when we talk about scalability, looks more like this guy what you're used to and you signed up for but you get the advantage of a truly scalable system where you actually have an increase in resources.

Now you want to get to the system over here because ultimately what this does is it changes your trade-offs from the constraint of the consensus algorithm itself to whatever the network is able to process and whatever the data layer of your system is able to process. In other words, it creates a system that enables scalability for Cardano for the next decade or so.

You know, when you see arguments on the internet, they just get very brain dead, and I don't think people understand how these decisions are made. They have to really understand what are the properties of scalability. What do you want to be predictable? What resources are you talking about? What is your scalability model?

So, when you try to make these decisions about decentralization, about scalability, you have to say what is the easy stuff to do that everybody can participate in and what's the really hard stuff to do that does require a lot of foresight, understanding that you're changing something that is very valuable.

That is what you have now, and you have to make some decisions about where you want to take it, how quickly you want to move. My hope is that the wisdom of the crowds will take us to great places. So, thanks for listening and I hope this provided some clarity on the scalability side of the house.

It kind of talked a bit about some things we care about: scalability, science, interoperability, regulation, and all kinds of things. So that was the original. If there is a social contract, social contract of these types of things, but it was a lot bigger now and it's not just an idea, it's a launched network with millions of people. So, the question is, how do you get to a good Constitution for Cardano?

And there's a lot more to love there extended UTXO, Sigma Protocols, they have. A pretty cool proof of work system. And it’s all in Scala, one of my favourite programming language.

It's a lot of work and to bring all these different people and they have working groups for different concepts like the core node, scalability, things like smart contracts, identity etcetera, etcetera. Lot an enormous lift. So much work has to be done. But as it moves in that direction, you can see a single concise website. And you're moving from left to right. Right. And the community is deciding the cards just like with HYDRA that go in there and every day you come back and week by week, by week, things get better, faster, cheaper.

When will it come? It's your decision as a community. Why? Because after 1694 comes, you decide. Your dReps decide. There's a roadmap and you say you know; we could really aggressively push and escalate scalability like input endorsers.

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.

Validated by over 165 academic papers, think about that, 165 plus. It's an amazing amount of work, and there continues to be more work every single day and many more opportunities for us. It's an ecosystem to leapfrog the competition, and nothing is going to get settled for years to come. We're in the running on everything from identity to interoperability to scalability and other concers.

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

A group led by Bruno Paleo. Bruno has never missed a deadline. He's always delivered under budget and ahead of schedule. They actually have about a four to six-week release cycle, and they've been building an enterprise framework in Scala. So, the work they're doing there is just top-notch. We're almost in a position where we're just about ready to begin pilots in Ethiopia.

...to achieve cold staking, your spending key will never leave the hardware device or the paper wallet. However, there will be a management infrastructure within Daedalus that allows you to basically manage the staking rights and move them around. If you really want to escalate, you can import those private keys, if the device allows you to. Whether the keys can leave is dependent on the device.

...Wadler, Moe Gilardi, and Simon Thompson are figuring that out, and we're super excited about it. The other thing is multi-asset, you may have noticed that we have this design called Time Eric Ledgers. We've actually already implemented it in Scala. Furthermore, it's in our Enterprise framework, which we've been building and running pilots with. We are porting that design over to Cardano.

If Crypto Kitties was ported to Cardano; would it be sizably better? This is a really interesting question. So, we get a lot of questions about the scalability of the system and exactly how much TPS you need. This is very controversial, and it's often a misunderstood topic. So, my hope for where we can take Shelley is somewhere in the performance range between 50 to 250 TPS. So, when we worked with Integer 32 and

And you have to have an opinion and a philosophy of that and necessarily the idea of a trusted data fee because of external events have some implications on the system and also this idea of regulation as well as a corollary to this topic, there's the idea of escalation of privacy so ordinarily.

From our enterprise Ledger offering to ????? Involved Cardano and things on the Scala side, we also have several prototype implementations of Ouroboros Genesis. In fact, the Haskell implementation of Ouroboros is so elegant you can reparametrize the same code base to run a BFT mode Praos mode, Genesis mode and you can even put in different network stacks, so it's pretty cool.

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

It is still the only client that was built from the ground up specifically for Ethereum Classic, and it was built in Scala, and it was built with great engineering practices, and it was built by great engineers, and it was built in a very transparent way. If you go to our YouTube page, IOHK YouTube, you can see the weekly stand-up meetings that we did for Mantis, and I think there's damn near hundreds of them, and we didn't miss a single one every week we showed up and we, even if there was a little progress or a lot of progress, we showed it off and people could watch us go from an idea to a fully constructed client and they can see the commits in the repository...

And it and write something in C, C++, C# or Java or you can be a functional guy. And then within there you have flavours of it where you say I have functional, but I don't like committing so you can do Scala, F# or Closure or you can say I'm functional and I really want to commit. So, you can do a Camel or Haskell, or you know something like that. Or you can say I'm functional and I'm just batshit crazy, so I'm going to do Idris or COQ or something.

What do you do? Well, cryptocurrencies have money at stake. They have, and they're not big. If you actually look at these protocols like we wrote for Ethereum Classic and now it works with Ethereum, a client, a full node and it's only 15,000 lines of code in Scala. So, at the end of the day, these protocols that are in the cryptocurrency space, the infrastructure layers...

There's very strong argument to make that you could write these protocols in something like Scala.

We also have our own enterprise group that's led by Bruno Paleo and Bruno is working on a collection of proof of concepts in Scala.

So effectively what you've done is you've given out the value and you've done it in a near infinitely scalable way.

And the first great governance challenge I think is going to come is going to be about privacy. It's sure as hell not going to be about scalability because at the end of the day, you know, our research gives us good trade off profiles. So, we come in, we say, would you guys rather have X 1000 transactions per second or X dozens of transactions but you say more is better.

And so, it opens up a broader conversation about minimum viable escalation of privacy. There is no greater example of that in the financial world than KYC and AML. For example, right now we have a very bad situation If you're on a bank or an exchange, somebody comes to you and says Hi BitStamp, or Hi, Bittirx or Hi,shapeshift. I want to do business with you and they say great. Show me your passport or proof of funds or proof of residency.

Scalability, and then suddenly everybody gets 100,000 transactions per second or 500,000 transactions per second, or some outrage.

Number and they're infinitely scalable, as if they've just magically discovered something new, and it's the biggest innovation ever.

So anyway, my overall opinion is that where they're useful, they're useful, but they're not the solution to scalability.

Of a collection of potential solutions we're looking at about long term scalability.

Basically, when you do this you get kind of predictable performance. So even though you might be writing an F# or C# or Java or Scala, you don't really have a big performance built up between these things because there's all this stuff that's been figured out underneath it that's helping you do that, and that's where Rena is kind of about.

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.

What you do instead is you construct a process that is scalable, that is capable of welcoming new people in from different walks of life, different skill sets, different cultures, different languages that is capable of identifying the problems you need to solve to have a better system.

But because we're looking at pluggable consensus with an existing, very mature Scala based code base. This means that we probably can accelerate our test net plans for Goguen, our smart contract layer.

We've been hiring like crazy. We've onboarded 4 new Haskell developers just in the last three weeks alone. We intend on bringing onboard about 5 new Scala developers within the next six weeks. We hired another dev OPS person and we'll be hiring more dev OPS people and we are partnering with some new companies, and we'll be making those announcements at some point. Specifically to help us accelerate cardano's progress so that we can continue the momentum that we've already achieved.