 Hello, everyone. My name is Will DeChill. Some of you may know me by my legal name, Will Braswell. I am here as one of the co-founders of the Pearl 11 philosophy and movement and was invited to speak about the reunification of Pearl 5 and Pearl 6 and the many different projects and people involved in that. This will not be a very deep dive, technically, into source code, because we don't have enough time to do that. I would love to show everyone demos of everything you see here, but we probably won't have time to do it live unless I speed through everything way faster than I predict. But we'll try and leave a few minutes for questions at the end. And if I have extra time, I'll try and run some demos. But if not, then just find me afterwards, and we'll do some person-to-person demos at that time. So we'll just start right out immediately what in the world are we even talking about when we say Pearl 11? Is it a version number? Is it this or that? What is it? Well, that's a very good and somewhat confusing question because Pearl 11 is many things. Pearl 11 is philosophy. So there's three main parts to the philosophy. We want to have a plugability of pearl. And pearl itself is that word, very charged. But it means a family of languages. So plugability of those family of languages, we want to be able to take apart the main implementations of those languages and replace parts or make new parts that may be better or different somehow. So think plugins or reusability or object oriented type programming. Right now, that's not exactly possible with all of the different Pearl projects. So that's a major goal to work towards. The second goal of this new philosophy is, of course, the reunification of Pearl 5 and 6. And we'll see in a minute that these are two different languages, and we're calling them siblings. So they're not the same language, and they're not just a new version of the same language. So that's often confusing, and rightly so, because you would think from going from 5 to 6 it's just the next version of the language, but it's not. It's a different language. So we will actually have to recombine those languages. Again, reunify those languages in some way in the future, and it's taken us a long time to get here. And a lot of people have worked very hard on both Pearl 5 and Pearl 6, both of them very useful and advanced languages in their own rights. And some of those people are, in fact, here in this room. So it's going to take many more years for us to recombine everything again. And then, of course, my personal favorite is the runtime performance of C or faster. So this may seem crazy or difficult or impossible, but that's my personal passion is to have my code run faster than anybody else's in the whole world. Pearl 11 is also, in addition to being a philosophy, it is a development collective by which we mean there are many developers, software programmers around the world in many different projects working under this Pearl 11 banner or umbrella, if you will. And as I had mentioned before, Pearl 11 is not yet a version number. We're not saying that we have released Pearl version 11. This is not the case, so don't jump ahead just yet. That will be quite some time before that's going to happen. But we're working towards it, and we're working towards this idea of the Pearl 5 plus Pearl 6 equals Pearl 11. And this was where our original pun or idea for the name Pearl 11 came from, the reunification of the two. So now I'm going to switch to another graphic that I have here, and we're going to have to, let me see, how can I even do this? We're going to have to switch back and forth here to a few different things, because I have all these multiple desktops. So prepare yourself, because you're about to be exposed to a somewhat complex flowchart. And I know that we all hate flowcharts, but I had to create one because it's never been created before. And it was very important for us all to understand this particular flowchart. It's not even a joke. It's a real flowchart. So I have created, and we're all about to see, all in one chunk, I'm not going to try and step through it piece by piece, the Pearl family tree. So where did Pearl come from, and what is Pearl, and where is Pearl going to, as if Pearl was a family of living things, which I guess you kind of can say that it is because we are a community, and we are living humans that comprise all this. So let's see how well I can make this work. Here we go. So this is the Pearl family tree. It all started in the beginning. There was Unix and C. And then all these other tools came, and this man here, St. Larry Walt. Wait a minute. Sorry, that's the wrong picture. We just have to kind of swap him out there. This man, St. Larry Walt, took a lot of things into his brain. He's got a tremendous brain, which all of us in the Pearl community really admire him for his genius. He's led us all to where we're at now, and he still is leading us in that regard. Thank goodness. So St. Larry took Unix and C. Oh, we swapped back again. And whew, it wants to switch itself for some reason. I don't know why. It's the ghost of St. Larry. OK, see, now this, that is totally unscripted, ladies and gentlemen. Let me see if I can swap it out for good here, because while it is funny, I don't want to be too disrespectful. Let's see if that stays. So St. Larry took all these ideas from other tools and combined them in his brain and figured out what it did not have, and used that to create everything on the right side, my right side, your left side, which you can see with the blue arrows. And this was really Pearl 1 through 5, but we just call it Pearl 5 because it was the same code base. And this is written in C. And it's actually mostly, or I would say largely at least, mostly written in C, preprocessor directives, C macros, and the like. So that's very tricky to upgrade that in the long term and to maintain it. But it also runs on every architecture and wrist watch in the world. So if you can figure out the make file. But essentially, we had this camel and pumpkin side here where this was what we think of when we just say Pearl. So if you say, I'm doing Pearl, I'm programming Pearl, you're probably talking about the left side of the family tree. And we're going to go through that. It's quite complex. On the right side, you've got the new sister language of Pearl 6 that now has a new name also called Raku, Japanese for easy or something along those lines. And it has several implementations in children as well. And then you can see we're all kind of leading somewhere at the end. But I'm going to try and give you a 30 second sound bite about each one of these things. Because we have a few minutes and it is worth giving lip service to every single project that's up here. So bear with me because the Pearl family tree is not exactly straightforward. I'm not going to say too much about the stuff at the very top because you all should know what most of those. I'm sure everyone in here who's at least a developer has probably touched one of those things at some point. But I will talk about everything below. So basically, Pearl 5, aka Pearl, is a specification. So the camel is a spec. And the camellia butterfly is a spec. These are not implementations. The pumpkin is an implementation. That's the one written in C macros. And that's the one we call it pumpkin pearl because of a tradition in the pearl community where whoever is in charge of that software of Pearl, Pearl 5, of that implementation of Pearl 5, for this release cycle or cycles, we call that person the pump king, which is a pun on the pumpkin king or a combination of those terms. And that person actually is in possession of a physical item, which is called the patch pumpkin, which itself is a pun, I guess, on pumpkin patch. And it's a plush jack-o-lantern pumpkin doll from who knows, back in the 90s at some point. Somebody got this and then has passed it along. And you can see it every few years at the Pearl conference whenever it changes to the next person who's going to be the pumpkin, the Pearl 5 pumpkin. So that's Sawyer X now, if I'm not mistaken. And I was there when they had Ricardo through the patch pumpkin, and he caught it and he became the pumpkin. So that's just one of the traditions we have. That's where we get this pumpkin idea from. Well, pumpkin pearl spawned several forks and children. So everything that has the dark blue arrows is actually a port or fork of the pumpkin pearl. So we did actually end up with vanilla pearl, briefly, which was for Microsoft platforms, which then spawned strawberry pearl, which still exists as the primary open source pearl for Windows platforms. And there was, yes, there was, planned to be a chocolate pearl at some point. Just never got released. It was supposed to have more gooey or something for Windows people. So if anybody here is a Windows person who wants to implement chocolate pearl, it still needs to be done. You also have Active Pearl, which is a commercial version of pearl that has this corporate support with Active State the company. And that still is around for most of the big companies that want to have the same release of pearl compiled for all of their different operating systems with corporate tech support and compliance and all of that sort of thing. So Active Pearl does have a place in the ecosystem. And there were a few other forks of pumpkin pearl. I'll mention one right now, which is called Sea Pearl. This is quite recent. And this is also depicted as a pumpkin because it is really a fork of pumpkin pearl with a whole bunch of extra patches added on. So it's kind of a bigger, taller, stacked up pumpkin, patched up pumpkin. But it is actually a direct fork of pumpkin pearl. So that's a direct fork, thus the pumpkin imagery here. Now let's step back up for just a moment to the camel again. Remind yourselves, the camel is a spec, a specification, not an implementation. And so from that spec came several other projects that were not that sea macro code, that were not forks of pumpkin pearl. And so the most important of those, one was called pony. This stands for pearl on new internal engine. And this was Arthur Bergman and one or two others. Worked for a few years on this, and this was actually an attempt to recreate the pearl five execution mechanisms using a virtual machine called Parrot, which you can see over here on the right side of the screen. And both of those, pony has since been put out to Patern, the Parrot is once again dead. Yes, this is based on Parrot's sketch of Monte Python, and it's deep humor all the way through the pearl community. I'm under the impression that the Python language also came from that, and the P from that came from the pearl lineage. So I'm sure the Python people will dispute that, but that's what some of us believe ourselves to be somehow superior or more mature or an older community at the very least, which I think at least that last part is technically true. So pony never got a release, never got finished really, but did lay the groundwork for Parrot, which lasted quite a bit longer, and in theory could be revived as the dead Parrot is trying to be sold in the comedy sketch. But the thing that came after pony, most closely related to pony, is right there, R-Purl. I created R-Purl. This is a pearl compiler. And it is similar in many ways to the idea of pony. So it's kind of a pony reducer. It doesn't use any of the code or really the requirement for high-magic pearl that was assumed for pony, but R-Purl is a pearl on new internal engine. So it does actually fit the name pony, that acronym, the actual technical meaning for that name. And that new internal engine is essentially compiled to C++ engine that I can talk about a bit more in a moment. We have more things that still came off of that spec, which I'll mention in a minute. I'll get to that group in the middle here in a minute. So now I'm going to jump over to the right side of the screen. I'm sure glad I didn't try and step through this thing because it's so much jumping around I would have gotten myself lost. So again, the camel implementation or spec? Spec. Butterfly implementation or spec? Spec. OK. So everything coming off of the butterfly is an implementation of that spec. And there have been several. So Parrot was one of, or perhaps the earliest attempt to create this virtual machine that was originally actually part of the Pearl 6 official development initiative. It was then split off to become its own virtual machine. Then pony said, hey, let's try and make Pearl 5 run on the same virtual machine as Pearl 6. And then Parrot stopped trying to support Pearl 6. And then Parrot stopped trying to support pony because pony died. So then Parrot was left alone for a long, long time and other languages decided to use Parrot. So there are like half a dozen languages that target the Parrot virtual machine, neither of which right now is actively Pearl 5 or Pearl 6. Kind of hilarious just the way things happened. After Parrot, we had Pugs. This is written in Haskell by Audrey Tang. And this actually did run quite a bit of Pearl 6, if I understand correctly, although Pearl 6 was different at the time because this was quite some time ago. And the stable production release of Pearl 6 is only just a few years old now, which is kind of the part over on the right we'll get to in a moment. So Pugs went away as well. Pugs went up to Puppy Dog Heaven. All dogs go to Heaven, I guess. But that was not too long ago. So I guess, in theory, if there's some Haskell hacker out there who loves Pearl 6, you might could revive Pugs. It's open source. There was another one. Niexa, not even sure if I'm pronouncing that correctly, but this is essentially an implementation of Pearl 6 that's targeted towards the .NET common language runtime, one of the virtual machines that Microsoft has created. And I don't believe that is really considered production ready. In fact, it's pretty much still marked as experimental at this point. But I guess if you're really into .NET or you need some Pearl 6 code to run in .NET, you could probably hack something together with Niexa. So then all the way over here to the right, we're kind of getting towards the more modern and official parts of Pearl 6. There's a thing called VIV, which is connected to a different thing called standard. And VIVs is Roman numerals for VI, which is 6, and V, which is 5. So it's this translator from a part or subset of Pearl 6 into Pearl 5. It's a backwards translator, if you consider going from Pearl 6 to Pearl 5 backwards. Although as we show them here, they're actually on the same level because we're calling them siblings. One is an older sibling, one is a younger sibling, but they're still siblings. So anyway, to translate from sibling to sibling, VIV was a tool to do that. And there are other tools now, but that was an early tool that was important because it was and is actually still part of the official Pearl 6 repo and code base. And VIV was used to help kind of bootstrap Pearl 6 so that it could run part of itself in Pearl 5. And it had this other thing connected to it called standard. And it's called standard because it means St. Larry's standard grammar. And there was a standard for Pearl 6, and there was a standard for Pearl 5. And there still are there in the code base. The issue is that neither VIV nor standard is still being actively developed as part of Pearl 6. So there's a lot of moving parts of Pearl 6 that are complicated, but these two were important for several years because they were used as part of the official spec and official experimental, I guess, implementation of Pearl 6. And so those, the standard.pm6 and standard5.pm6, if I'm remembering the exact file names correctly, these are both PM6 files, which means a Pearl 6 module. And those Pearl 6 modules were run through VIV to spit out Pearl 5 code that would run in pumpkin Pearl and thus give, again, this sort of bootstrapping of Pearl 6 running in Pearl 5. And why would you need a bootstrap? Because Parrot never worked fully as a VM, so we didn't really have that to target to run things on. Pugs eventually went away. And Nyexa is experimental and for .NET only. So there had to be some way to have this sort of cross platform, which pumpkin Pearl is, runtime that they very, very high level, high magic parts of Pearl 6 could run on top of. And so using VIV and standard allowed us to have Pearl 6 stuff running on Pearl 5 for several years. And that is no longer necessary because now there is a real true self-contained, self-sufficient, self-supporting implementation of Pearl 6, which is called Rakudo. And this is kind of part of where the name Raku comes from, and it's this sort of Japanese idea. Rakudado, if I remember my Japanese correctly, is Way of the Camel. So it's a reference back to the Pearl 5 spec. And essentially is a stack of several different components. There's one called NQP, which stands for Not Quite Pearl. It's a subset of Pearl 6 that is easier to bootstrap and can then be used to implement the other more complicated parts of Pearl 6. And Liz, if I'm wrong about any of this, I'm sure you're going to have an ugly look on your face. I'm not a Pearl 6 developer. We have one in the room who knows much more better about this than I do. I'm a Pearl 5 developer. So then there's another part of the stack called More VM. And this is a low-level virtual machine that was implemented from scratch in order to run just Pearl 6. So it matches the Pearl 6 semantics very closely because it was designed for that, and thus is now properly running Pearl 6. And we don't have to try and run Pearl 6 on top of Pearl 5 or on top of the CLR or on top of Haskell or on top of the dead parrot because it has its own More VM now. So that kind of stack of Rockado, NQP, and More VM is the modern, I guess you could say, official Pearl 6 implementation. Although there's also this avoidance of calling things too official because you have the spec you can implement your own if you really are that insane. But you probably don't want to do that because it's taken all the smartest people working in the Pearl 6 development team for 2,000 until now to get there through all these iterations. It's re-implementing Pearl 5 or Pearl 6 is not for the faint of heart. It takes many, many years. I'm on my sixth year of my implementation of Pearl 5, and I only have a small part implemented so far. It's quite complicated. So that's kind of the Pearl 6 side. Now let's jump back to the middle because, as you can see, there are parts that are actually inheriting from both sides. And this is where it gets interesting. So you've got, first up, Pearlito. This was created by Flavio Glock and is essentially a implementation of Pearl 5 and Pearl 6 that can compile into JavaScript or Java. And as we know, not the same thing. And also can translate between 5 and 6 to a certain degree as well directly between Pearl 5 and Pearl 6. So that's pretty neat. That's been around for a while. And Flavio was actually there remotely when we came up with Pearl 11 originally. So Pearlito is one of the original Pearl 11 projects. P2, not as far along as Pearl 11 or most of the other projects on here, but still worth mentioning, this is Rainy Urban, one of the co-founders of Pearl 11 with myself and Ingy.net. And this is based off of a small VM called Potion by Why the Lucky Stiff and Why Has Disappeared, but his VM is still around. And so Rainy has started coming up with his plans and ideas for a total from scratch implementation of 5 and 6 on a single small, fast VM. It's all based on jitting, and Potion is pretty cool from what I understand. I'm not a Potion expert, but that's a pretty interesting project. So if we've got any hackers that might be into that, that's a real fertile soil to work on right there for reunification. And we've got a new one called Web Pearl. And this is Haoka, my apologies if I'm mispronouncing. But this is actually, you can see Web Pearl is inheriting all the way from pumpkin. It's kind of convoluted, but it's there. Pearlito and P2 are re-implementations of Pearl 5 from the spec. Web Pearl is actually a port of pumpkin pearl to Web Assembly via clang. Also, again, Pearlito and P2 are re-implementations of Pearl 6 from the spec. But Web Pearl's not. Web Pearl is actually, again, a port of the Rockado stack, again, to Web Assembly via clang. That's pretty cool stuff. And a lot of make-file magic from what I understand. But it works. And that's pretty much a brand new. It just came out a few months ago. So those guys in the middle are the furthest along on the reunification pathway. But we're certainly not there yet. You can see I've kind of pointed us all in some future direction here. Pearl 11 is this, again, philosophy and development collective that we came up with in 2012. Engi.net and Rainy Urban and myself met. I brought them to Austin, Texas, where I am from. And we had Flavio of Pearlito on the video chat with us and a few others. And we came up with the idea of Pearl 11. And we came up with the philosophy, the three points. And since 2012, we've been trying, like, her own like, herding cats is nowhere near the right analogy because everybody is pretty much completely independent. So we're not even herding anything. We're just trying to coordinate efforts to bring them all into the pearl11.org umbrella and to at least have technical discussions. We've got our on IRC channel and all of this sort of thing so that those of us that are working on our own pearl implementations, such as myself on our pearl and so forth, we can discuss technical details that pertain to the greater picture, the bigger picture of Pearl 11 and how we're going to somehow reunify at some point. So all of these sort of active or important and significant Pearl 5 and Pearl 6 projects will, if they survive, because we see some of them don't, but the ones that do survive will somehow eventually move in that direction of Pearl 11. And I don't pretend to know exactly how that will happen. But I can tell you that I'm working on our pearl. Right now, this is an implementation of Pearl 5. I'll be adding Pearl 6 support any minute now. I'll be adding Pearl 6 support. As soon as I'm done here, I'll start on it, maybe. But we will have Pearl 6 support in our pearl as soon as I'm far enough along with Pearl 5 that I feel like it's time to switch gears. And so eventually, we'll have an arrow from Camelia, the colorful butterfly, over to our pearl. And so our pearl is at least one pathway, like these other guys in the middle. Our pearl is at least one pathway to implement, eventually, all of Pearl 5 and all of Pearl 6 in one common code base that runs together, somehow seamlessly. And even the exact mechanisms of how they will run together is still being worked out. There's like a use v5 and a use v6 sort of tag that can tell the compiler which version to use and that sort of thing. So that was a whole lot on one gigantic, annoying, lee-complicated slide. But we had to know where we came from, where we're at, and where we're going in order to understand, even just in general, what Pearl 11 is trying to encompass. So I will switch off of this terribly colorful and amazingly awesome graphic for the time being and see if I can switch back to my presentation. Is that it? Yes. Moving on. This was just, again, an overview of the four most important Pearl 11 implementations right now. And I can't have every single thing that was on that gigantic thing to have its own single slide. But I gave a few of them. Pearlito I mentioned is Flavio. This, again, is Pearl 5 and 6 to Java and JavaScript. He's been working on it longer than I have been working on our Pearl by several years. He's out of Amsterdam. Why did he create it? And why would you want to use Pearlito? First of all, it's running inside your browser of virtual machines. So if you have a JavaScript virtual machine or a Java virtual machine inside your browser, then you can just run stuff in your browser. You don't have to download and install extra stuff. That's pretty cool. This is actually written in Pearl itself. So if you're a Pearl hacker, you can go and read the code and understand probably somewhat how it works. And it is a transpiler. So again, it has this sort of Pearl 5 to Pearl 6 ability as well. So if you are a futuristic Pearl hacker and you want to see how your code runs in one versus the other, then that's another feature of Pearlito. Why would you not be able to use Pearlito for some specific projects? Well, first of all, a lot of Pearl code relies on C. Pearl itself is written in C, but what you would think of is Pearl modules or libraries or even Pearl applications. A lot of that has C code embedded or hidden in it with this thing called XS. And XS is this extension system that is essentially a type of C, a way to connect C code into your Pearl code. And that is not easy to convert to JavaScript or Java. In fact, it's probably intractably impossible. I would not try and do it without some other much more complicated automated mechanism. So you're not going to be able to use a lot of your Pearl modules off of C pan, which means most normal Pearl apps would not work in that case. If you're writing what we call pure Pearl, where you know that it's not loading up some other module that has C code hidden in it, then you can almost certainly get it to run in Pearlito. But if you're doing something like loading a module off of C pan, even if you think that module is safe, it's probably safe to assume that it has some subdependency somewhere that does have XS, and you're not going to be able to make it work right. So that's a limitation. And Pearlito is a subset of Pearl 5 and 6. So there would be some super special parts of those languages that are not yet supported directly. It's really, as I mentioned, Flavio manually implemented 5 and 6 both. Good for him. It's very difficult. And I would not want to have to do it again. So there's his website if you want to get more info about that. Our Pearl, this is me. It's an optimizing compiler for Pearl 5 right now. Like I said, I'll be adding Pearl 6 at some point. It's all about performance. That's the only thing that matters. Our Pearl is faster than anybody else's code in here or it fosters them. And I will challenge anyone that wants to implement their algorithm. I'll write the same thing in our Pearl, and I'll beat you. Because I'm compiling directly to C++ with special optimizations that I'm making along the way. And I've got automatic parallelization. So I really don't think you can beat me. I invite anyone ever for all of eternity to try, but I'm putting the smack down and saying, our Pearl is the fastest in the world. Come at me, bro. Why would you not want to use our Pearl? Because again, like for Lito, it's a subset of Pearl 5. There's going to be a lot of these special high magic features of Pearl 5 that are not yet implemented. We're working on it. I could use the help if anybody wants, sure, join up its open source. The other thing I'll actually mention real quick is if you have some Pearl code that you need to protect the intellectual property, which I know is somewhat flying in the face of the whole open source thing. And yes, our Pearl is completely open source. But by sheer nature of the fact that our Pearl is translating your Pearl 5 code into C++ and then compiling that with like GCC or whatever C++ compiler you want, you're protecting your IP with strong protection, as strong as C or C++ because it is actually calling GCC. So that is strong IP protection. It's the strongest you can get for Pearl. And that's just a side effect. So go to our Pearl.org if you want to see about that, our Pearl.org. So C++, this is Rainy Urban, OK? This is an actual fork of pumpkin pearl. Only Rainy would be crazy enough not to port, but to fork. And only Rainy would be smart enough to do that. And only Rainy would be loved and reviled enough by the Pearl community to actually, perhaps, succeed. But that remains to be seen. He's written several hundred patches himself which have been rejected by the Pearl 5 development community based on disagreements they have. Who knows who's right? In the technical world, I think Rainy is mostly right. In the interpersonal world, I think the other people are probably right. But now we have a fork. And Rainy has applied 200 through 100 patches, whatever he's written, to save a bunch of memory, to make it run faster. And you do have high magic. So C++ Pearl is pretty much production ready. There are some things that it may have glitches or bugs on that, I think, are mostly known issues at this point. But if you have production pearl, even in a big company, and you need to save some memory or get some performance benefits without really changing much, or perhaps even anything, then you could consider C++ Pearl. It could save you some memory. It could save you some dollars. It could get you a promotion. I think the debugger might not work right. So if you need the pearl debugger, you might be out of luck with that one. WebPurl, this is Halca. I don't know his last name. A lot of us have some anonymity in the pearl community. I don't know where he's at. He's on IRC. He talks to me on there. But ooh, it's not supposed to say foo. That's what we write in pearl when we forgot to finish the slide. OK, WebPurl is a pearl 5 and pearl 6 runtime environment in your browser. That's what that's supposed to say. Why would you want to use it? Well, it's in the same vein as pearlito. If you don't want to download and install pearl, you can do this, because it's just running in your browser. Unlike pearlito, the XS and C code is supported, because it's actually compiling C through Clang to generate WebAssembly. And interestingly, WebPurl also does actually have some API for interfacing with JavaScript. So you're not compiling your pearl code into JavaScript, like with pearlito, but you can call between your pearl code and JavaScript. And so you can even use jQuery or your other JavaScript frameworks or tools, widgets and all that, and call it from pearl. So you can actually use pearl as a web scripting language. And I think actually the idea there is to replace JavaScript, because Halka didn't want to have to write everything in JavaScript he wanted to use pearl instead. So that's pretty sweet. You can check out his website there. And WebAssembly is pretty neat. And then I'll mention one more. I have created a free cloud platform called Cloud for Free. And this is essentially pearl 5 and R pearl loaded up on some cloud servers I've got in Dallas. And it's got a web front end. It's not running in the browser VMs. So this is not the same thing as either pearlito or web pearl. This is running server side, because I'm compiling the R pearl on the server and running that C code super fast on a fast server that's probably faster than your laptop and probably has access to more cores, et cetera, because it's a cloud platform, not your laptop. So it's different. If you want to run your code in your browser, using your laptop's processor, then use pearlito or web pearl. If you want to run it on the cloud, using someone else's processors, Cloud for Free. And Cloud for Free is compiling using R pearl, so it's way, way, way, way, way super duper, duper faster. And we're talking about hundreds of times faster. R pearl is like up to 400, 500x, which is like 40,000 percent faster. It's not like 3 or 4x or something like that. It's not comparable to normal pearl speed. So in conclusion, I just thought I'd show you Rody the Roadrunner, because I love our pearl mascot. But pearl11 is many things. There's many projects here. Pearl5 plus pearl6 is pearl11. This is our initial pun and numeric pun, I guess. And pearl11 will be a version, number, someday. I don't know when that will be. It's taken us 31 years-ish to get where we're at now, 32 years. So it's going to take another 30-ish years to undo the mess that we're in. We're unscrambling two different types of eggs, recombining their genetics and creating a new type of bird that can lay that special crazy new magic egg. So it will take many, many years to achieve that. But when we do get there, it will be amazing. And it will be the most advanced language in the world, because at that point, not only do you have all the power of pearl5 and pearl6, but the sort of crazy magical thing about pearl6, which those of you who may have seen the other pearl talk yesterday would know about, is pearl6 is especially designed to implement other languages. And so at some point, and all the Python and Ruby and Java people are going to super hate this part, we're going to absorb all of you, like the Borg assimilating species after species. And we will reimplement your grammars and semantics in pearl6, and we'll have it compiled using our pearl, running jitted on Potion or Rockado or something faster than your own native implementations, at which point your user base will switch to pearl. And at that point, pearl11 will be the ultimate final language of all time. So thank you. That was pearl11. We will have a pearl dinner tonight. Please join us if you want to see demos or talk to us in person, and I'm Will the Chill. Thank you, pearl11. I think we have two minutes for questions, if there are any. I've already started disconnecting here. Are there any questions? Right here? I guess I'll try and leave this back up here. I don't know if it's going to go back on. I'm listening. Go ahead. So on my Linux desktop, all the pearl scripts, what are they running at the moment? Say that one more time. My regular Linux desktop, laptop server, whatever, the pearl scripts, what are they running? You mean which implementation? It's pumpkin pearl, pumpkin pearl. So when you say I'm running pearl, you are running pumpkin pearl 5. Very good question. Thank you. Hey, I think there's another pearl I've heard of, stable pearl. One more time. I think there's another pearl called stable pearl. Stable pearl, there are other forks of pumpkin pearl. There have been probably half a dozen of them over the years, and I simply did not have enough room to put them all on here. But yes, there are a few other ports or implementations of pumpkin pearl, of which I believe stable pearl is one of them, relatively similar to C pearl with some additional patches that may be fixing bugs that haven't been fixed in the main pearl yet. One more question, and then I think we're out of time way up there. If you can get up there fast enough, because we've got just a moment for our last and final question. Can you give some examples of the restrictions of our pearl? What is not possible to do in our pearl? Examples of restrictions of our pearl. So using magic variable names, using secret operators, using runtime evaluation where the behavior cannot be determined at compile time, those are things that static compilation usually can't do anyway. All right, so again, will the chill our pearl? I'll be at the pearl booth right up behind there. Thank you.