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.

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.