Compete with the Haskell client, you probably want to keep your layer one concise and simple, if you can. In each generation, simplify it where you can so you can have multiple implementations of it. Don't lose the ocean; you could always chase the ocean. It's just that ??? never caught up, and we bet big. We bet big in a lot of different directions and there is a lot of amazing computation.

...testing is done on the use of Haskell as a base language, and all the things that had to be done to make that protocol great. It's not perfect. There are certainly major improvements that need to be made with interfaces, a better data availability story. We have to get the side chain story out. Oh, finality, sure. We already have plans to know how to turn that from 12 hours to 10 minutes -- on, uh, on...

One of the things that we're batting around right now, we're going to talk to partners like Emurgo or the foundation as well as the members of Intersect, is an idea of four courses that once you complete them, you get certificates that are posted on the Cardano blockchain. Something to cover Haskell, something to cover AGDA, something to cover open-source best practices, and a mastering Cardano course.

When you have alternative clients you call that polyglot, basically means many languages. So, we want to have lots of alternative clients, but we want those clients to conform to standards and quality so that regardless of the client that you choose, you have reasonably the same level of quality assurance that you have from the canonical Haskell client that we're currently using.

So, when people, the government of Cardano, says upgrade, it actually happens as opposed to a developer over here on Rust or TypeScript or the Haskell side holding the network hostage and not adhering to the will of the Cardano government.

Now this process can grow and evolve over time because we only have one client, you know the Haskell and AGDA, but you know if there's a Rust client then you can add a Rust course. If you take that then you get access to the Rust repos assuming you know how to read the specs and the best practices and understand Cardano.

So Haskell is an example, but you could have dozens of these types of things. And those proofs are completely open. Now here's the really cool thing. This actually doesn't require real-life human identity.

And have a dependently typed language to write a spec location and that permits full code extraction to Haskell along with constraint satisfaction testing. So that's a huge leap forward for quality assurance for debugging and testing, and hopefully that can through intersect the MBL work its way to all of the other eras of Cardano and have one unified set of blueprints that are implementation agnostic. What that will permit is the ability to certify third party clients Rust, TypeScript and other things to compete with and augment the Haskell client

And you get the adept. Super Haskell. You have formal specifications that are on par with what NASA does with building rockets, for medical software that goes into pacemakers for things that if it fails, it kills a lot of people like code for regulating nuclear reactors. These types of things. Code that peoples with PHD's in computer science spend 10 years post PhD learning how to write well.

For example, with the Conway era, will be the very first era of Cardano to move to a full true formal specification with code extraction. So we actually have an active specification of the Voltaire Ledger logic, and we can extract from that Haskell code and compare it to the production system.

What that functionally means is for the first time ever, we'd have an end-to-end specification which is implementation independent that can be used for third parties to build competing clients for Cardano, which is a major milestone forward, but do so in a way where those clients can enjoy similar quality to what people have enjoyed with Cardano itself. In the Haskell sense, so I would love to see a Rust in a TypeScript client, for example.

The single most important thread amongst all of this is realizing that we all have to upgrade the EQ, not just the IQ. Cardano has the highest IQ, 180 papers and moon math, and all kinds of magic. And it's not easy to write active specifications. It's not easy to write Haskell code people absolutely understand the rigor, discipline, and sheer brilliance of the research side.

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.

And I, I guess, uh... you know, tried to extend into his portfolio but he did invest in Book IO. We love the people from Book IO. Oh yeah, we have a great relationship with them. They love innovating; they're Haskell fans. They've been in the Cardano ecosystem for some time and wherever we can help out, we try to. It's been nothing but a joy working with them.

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

The fact that Ethereum is struggling to pave its way to non-custodial, liquid staking, when we have natively bet on that now, is noteworthy. There were some additional comments on Haskell, and at the time we chose to use it as a language, it was a bit too rough around the edges to be a commercial language. We, as an ecosystem, had to work really hard to vastly improve the quality of Haskell to get it...

We actually have two independent implementations of those protocols: one is on the Rust side, the other on the Haskell side. However, there's a bit of a drift between those two, so a reconciliation will have to be done. This reconciliation is set to occur in the ensuing weeks. Our goal is to have all...

...an economic and community preference, so you establish that economic and community preference through the test net phase. Our Haskell team is working really hard to get to a test net, and our Rust team is also working really hard to get your test net ready. The Rust team has a true hacker mentality. A few weeks ago, they asked me if I could fly every single one...

Then, hopefully, we could have a very short time period to move over into Shelley. On the Haskell side, things are still moving in a pretty good direction. We have a lot of very refined and elegant ideas that the Haskell team have been working on. What we're trying to do is figure out...

David, Jeremy, and I have been given a huge amount of information about Cardano, so he's going to be very worried about essentially getting the rest test to where it needs to go. He'll work with Bruno to get the Haskell team into a ship-ready delivery culture but must preserve the rigor. He must also preserve the really cool ideas they have and ensure that we conduct proper reconciliation. This frees...

Time, so that's where we're at. Shelley is staking. Staking is coming soon. Either it's going to be on the Rust side of the Haskell client side, more likely not the first test that will be rust will hit right now. We're priming a large group of people to participate. Anyone can, but we'd like to at least have some fairly good participants. The specs are entering the candidate phase, there are some...

...cases will have multiple specifications. Like, on the network stack, we're probably going to have three candidate specifications. One from the Rust, one that's being built on the enterprise side, which could potentially be reused in Cardano's, and then what the network team has been doing on the Haskell side. That's about fifty or sixty percent done, give or take, maybe a little bit more, but they're converging to a funnel design, which has some really cool features about it.

To get all of these things, Rina was one of those high-risk high-return mega projects that we basically said, "Let's go shoot for it. Let's go try it and see how far we can get." So the Haskell team has a spiritual successor, like a micro version of Rina, that has a lot of the concepts and principles of Rina embedded within it, and they're working their way towards it.

As well, she's great. They go there and say, "We're going to teach these people Haskell or something." That's a great way of filtering the class. Should they pass it, we know they are rigorous and they are good candidates, and we hire them. If they can pass, we hire them. So, at the moment, we have 23 people, all women, in Ethiopia: 19 from Ethiopia, 4 from Uganda. The class is...

We realized that Haskell may be too slow to get a production product into the market in the time frame you guys want. We launched Cardano on Rust and built it up, and it is already starting to dramatically improve things and speed things up. But it's also making the Haskell team faster. We make key personnel changes all the time, and we've done all of this in about a year since launch.

We're checking models and property testing, writing formal specifications and LaTeX, and writing software in Haskell. Yet we intend to make that a consumer product that will eventually work on a cell phone. They'll say, "Ah, but we have no pathway to BLEB assembly or JavaScript." Fine, we'll build the tools for it. You know, no one does that. Even multinational big companies don't get that crazy, but we're.

...to the new Haskell code that we've been writing, so throughout the next few weeks to months, we're going to be connecting the Rust code and connecting the new Haskell code to that wallet back-end. Whichever one is done first will end up becoming the first release of Shelley. It looks like the Rust code is a little ahead of the Haskell code in terms of our ability to run a test net, so that's...

For anything, either on the Haskell side or the Rust side, we can just simply wire the code together, flip a switch, and suddenly, Shelley's turned on. Yeah, to mention the rollout, what's going to happen is that OBFT will run for all slots in the first epoch. Then in the next epoch, some percentage of slots will be turned over to the state pool. So this is if they make all their slots or if they...

Gradual decentralization that will occur in the system, so the purpose there, again, is the OBFT update and the cobbling. Then, whatever code base is ready in the Rust base or the Haskell base, we will wire them. We decided to have two new independent teams following different processes because I really wanted to de-risk delivery in the event that one is just delayed for some bizarre reason.

And challenge every design assumption. The workshop basically gave us the opportunity to do that. People from IOHK Science were there. Peter Gazi was representing him, and then we also had engineers from the Haskell team and engineers from the Rust team, as well as engineers from Emurgo. In particular, Sebastian and Nico were there because they're actively maintaining your Yoroi and...

...and that's the specification to a point where we now actually know all the nuances of it, to a point where we can build it. Okay, now the advantage of this specification process is that the spec, written and math, is very close to canonical representation in Haskell. This means that we can go very easily from math to a somewhat lightweight reference version of the software, and we've...

We can connect it to Jormungandr, which is the rust client. That's the code name for the rust client. We haven't got a product name for it yet but it's the rust Cardano. We can also connect it to the new Haskell code. So, version 1.6 will be about getting us Icarus-style addresses and getting us the decoupled wallet. Now, the next update will be about taking the rust client...

...that we've constructed, and taking the Haskell client with the new code, if you look at our repos, Cardano Chain and Cardano Network, they will replace the deprecated Byron-based Cardano SL and throw away the SL, inserting Cardano Chain and Cardano Network into that wallet backend. Now, what this essentially means is that once that's done, 100% of the legacy code will have been basically replaced...

...and the Haskell back-end is working correctly, and then we're putting in the final delegation features for both Daedalus and Cardano itself. At that point, it'll be pretty straightforward to delegate. GUI scamps of the delegation center. We reviewed them at the summit as well as at the workshop. Darko or Nicola or someone on that side will write a blog post and show off some...

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.

And then there's infrastructure that Haskell code needs to run on. We've been scaling up resources on both Web Assembly and JavaScript for gjs, to be able to take Haskell code and convert it into JavaScript, take Haskell code, and convert it into Web Assembly. This means that you'll be able to actually run the client side of your smart contracts in a containerized environment, whether that...

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

...Cardano means that you can have much more sophisticated queries while interfacing with those wallet backends. We're also going to be moving to GraphQL for all of the IOHK product lines. So, we're moving Mantis in that direction. Eventually, we'll move the Rust client in that direction, and we'll do that with a Haskell client as well. GraphQL is really powerful; it can do a lot. It's very...

...resilient, robust system that Facebook designed is open source. The only downside is, because it has much more power and complexity, you have to be a little bit careful about how you integrate it. In particular, in Haskell, there's going to be some friction in getting that in, so one part of the team will be involved in that. In a parallel effort, another part will be sticking with Rust...

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

...JavaScript, then there'll be a way to go from that Haskell into JS, or into WebAssembly. Then, you can package it all together into a Node package or something like that, and then bundle this as a single logical unit. That unit, along with an application manifest and all that metadata, can be hashed and signed by your key. Then, there'll be a registration process to take that unit...

Functional programming and they're going to go all the way through everything in Haskell, including monads, and how to do networks. They're implementing their own peer-to-peer network and they're going to implement a version of Bitcoin, among other super cool things. However, it's our first class for teaching where we're actually going to have a flutist component to the class. So, after

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 in particular, in the next few quarters, you're going to see Cardano wallet, the reference wallet of the system transforms quite a bit. First, we'd like to have two implementations of Cardano wallets backend. Right now, we have Haskell implementation but we're also going to be rolling out a Rust implementation, and then the user can choose which code base that they want to use for the backend.

Another thing is that our wallet backend is getting decoupled, so we've actually built It, so that it's going to be in its own repo. And it's going to be a standalone product. And that conceivably means that you can take that Haskell wallet backend and and connect it to a different core.

Our first experiment with that is going to be with the Rust Cardano client, so we'll take the new wallet layer we'll connect it to The Rust client, and it should be able to connect to the Haskell client, the Rust client, but ultimately, other people can take that backend and they can use it for other products.

We're also going to start putting a lot of resources into improving Haskell's portability. Right now, Haskell works great for certain infrastructure.

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.

We can either go down the web assembly road and get a Haskell to web assembly compiler ready to go, and make that a good experience, similar to how we can do that with rust. Or we can put more money and get GHCJS to reach equivalency with things like reason ML or other platforms that do that.

We're going to conduct a series of experiments, one of our partners tweak ?????, already has been doing pretty heavy lifting with web assembly and we think within four to six months, if it's given some tender love and care, you can reach parity with what it needs to be able to compile our Haskell code to run in the browser.

Now what does this mean for smart contracts and what does this mean for Cardano? It needs all the Haskell code that we've written could conceivably be ported into a browser application similar to what we've done with Icarus, with Rust and JavaScript.

So multiple backends, Rust backend and Haskell backend, terminals coming multsig is coming.

Will staking be possible on a mobile version of Yoroi from the Cardano effect? I have talked to Sebastian Pabon and Nico about this so we're having a summit about delegation and basically what the delegation spec is and that's summit invitation only for Cardano developers. So, we've invited Yoroi developers. IOHK coming as well. So, is the Rust team and the Haskell team and we'll see if we get the vacuumlabs guys there...

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.

You can take that Haskell and use GHCJS to convert it to JavaScript and then it becomes a node package. And electron the platform we built this on allows you to have node packages and Chrome applications running and also includes web assembly.

The difference between your average JavaScript developer and your Haskell developer is no one ever started with Haskell as their first language, unless they were so privileged to go to Edinburgh or Glasgow or a very small group of computer science institutions.

Most Haskell developers are a little older, little greyer in the beard and have decades of experience and are experts, not only in development engineering but also computer science, Duncan Coutts is a great example of that.

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.

One in Athens and one of Barbados. It started during January 8th in Ethiopia with an all women's class. We have a Haskell course we created.

And then we have a migration path from BFT to Genesis. So BFT, the legacy team's been working on that and it's the last piece of code we're going to be committing to the legacy repo. The implementation of BFT is done and we've begun broad scale testing of it and we're going to actually test it both on the Rust side as well as the Haskell side. We're going to run Rust clients against the Haskell clients...

So basically, it's a small script you can write like a shell script, or you know it's like a Python script, something that you can write that automates the wallet process. Now you can do that with the Rust client. You can't currently do that with the Haskell client. A big priority in Q1 2019 for the Daedalus team will be putting a terminal into Daedalus itself and then...

Especially for us on the engineer side 2019 will be much more manageable and easier for us. Furthermore, we've begun a systematic decoupling of things in our in our stack, starting with the wallet backend, the very next version of it will actually be completely decoupled and we'll be able to connect the formally verified while the backend from just the Haskell client to also connect it to our Rust client as well, so that decoupling should be finished sometime January and actually as a result of that, we're going to have a very fast development time for wallet backend feature.

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.

We actually have a Rust team and a Haskell team, and both of them are building independent full clients for Shelley, and they're in a sudden death of whichever 1 finishes first. Our hope is that one of them can get to a testnet quickly so that we can start building up the stake pool population.

On our end, we're rewriting the wallet backend for Cardano so that it's modular and it can be pulled out and it can connect to our Rust code and also can connect to our Haskell code.

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.

Was Haskell a good choice? Yeah, that's a great question. I ask myself that every day, you know, so a programming language is just a tool and it's a tool to solve whatever problems ????? Ya. Selecting a good programming language is a surprisingly difficult thing, because it turns out that there's a lot of these tools. There's thousands and thousands and thousands of them.

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.

We chose Cardano's to have Haskell because we wanted to bring together some of the brightest people in the world to do original research and to think about the problems of the cryptocurrency space. So it wasn't just about what is the ideal language and is this the fastest language to develop in or is this the best cost benefit, or are we going to have the easiest time with tooling.

It was more about saying - if I wanted to make this interesting to Duncan Coutts or to Philip Wadler or to Michael Payton Jones, or to John Hughes. What could I do to make it interesting to them? What could I do to come to them and say there are 10 years' worth of problems we've put up in a pile and we'd like for you guys to come and solve those particular problems in a way that they've never been solved before or in the most optimal way that we can prove and Haskell gave us that path.

So, in a sense, Haskell's been very painful, but I think it was a necessary pain, and it's one that I would do over again. I would do a few things differently here and there. We would have retained different types of people in the beginning and of course, we have a huge amount of hindsight that we've gained, but I don't regret the overall choice anyway.

Have 5 implementation efforts, some on the scholar side, some on the prototyping side, some on the Haskell side that are all independently looking at this.

The advantage of that is we could take the Haskell wallet backend that's built on verified formal code. Really, really good Haskell code and connect it to the rest client and then the rest client could have API compatibility or you could actually take that with some modification and potentially connect it to a Bitcoin wallet or you know, a Monero wallet or whatever that has UTXO accounting system, that's parametrizable and also it means that the lower back end can then have an independent release cycle to everything else.

When mobile wallet? Actually, that's a great question too. So, you know we chose Haskell and Haskell has just been a mixed bag. It's been great and it's been a nightmare at the same time and at some point I threw in the towel, I said OK, let's diversify development a little bit. So, we created a rust project called Prometheus and. And we ended up creating the Cardano Rust wallet, and the code is up on GitHub and the first product of that was Icarus, which gave us a Chrome extension, and now that's being built up by a Emurgo for Yoroi.

So, in short order, next three to six months, we should see mobile experiences, hardware experiences coming out of the Rust Cardano effort, now Haskell still our core. And we're still doing a lot of work there. And we've learned a lot as a company for it, but sure is difficult ecosystem to write code and especially when you talk about interoperability, you know rust is just so damn portable.

It works on everything and it's really easy to get it to work with web assembly or on mobile devices and Haskell it's just like that screaming kid. You know in the store that throws a temper tantrum and you have to drag them out by their foot to get somewhere.

So the Haskell code that we have isn't so good at the moment for mobile devices or Ledger devices or ATMs or Intel SGX or these types of things.

You know, we have a great relationship with the Haskell community.

We've implemented Haskell.

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.

Concerns about Cardano, you know that I do have concerns every day, you know, I wake up and ask myself, was Haskell the right choice?

How many languages will Cardano support and smart contracts and dapps be written in? And let's get some other questions. OK, so there's some good questions here. All right, so Cardano has been misrepresented a lot and it's amazing. You know, I guess I'm failing at comps and marketing, but I I hear things from, we are ERC20 token to the only way to write smart contracts is in Haskell at the moment. There is no way to write Haskell smart contracts with Cardano, so I don't know where that came from, but OK, the goal of Cardano is to be both principled and pragmatic.

So that's the smart contract story. In short, yes, you'll be able to write smart contracts in more than just Haskell. I would really love to be able to write a JavaScript smart contract at some point. I really would love to be able to write a Java smart contract in C++ smart contract.

So in Ethiopia, basically, we agreed to host a class like we did in Barbados and Athens and have that class basically invite recent graduates from Ethiopian universities to sit down for two months and to learn lots about how to hope, write code in Haskell. And then if they're really good, we'll offer them a job at IOHK, and then we'll put them onto a blockchain projects either permissioned or permissionless. The ministry was very progressive, they said not only did they want to do this class, they wanted it to actually be all women.

I suspect what they're going to do is run the Rust code on their on their module, not the Haskell code, so we'll find out more about that as time permits, but we'll we'll keep you update.

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.