 Okay, let's start with this. How the camel is deep cocooning. Actually, the inspiration for all of this came from this little piece of cardboard. It's an original of the Larry Wall. And for a long time I was wondering, what the hell was he doing there? I mean, what is that? And what it says at the top is part of the cocoon. Well, apart from the misspelling. Yeah, you could argue that Rule 5 has been cocooning for a long time. So let's recap a little bit of the past. If you look at Rule 5 between 2000 and 2010, we have 5.6 in 2005 and 8 in 2002. 5.10 came in 2005, that's 5 years later. 2010, so 5.12 is 3 years later. But since then, we have a yearly release of Rule 5. So you could argue that the lead years of Rule 5 have passed. If you look at Rule 6, we've had the original camel herds meeting in 2000. We had the whole request for coverage process. We had the eucalyptus, the exotesis, and the synopsis. Did that say that right? Okay. We had Parrot as a virtual machine for everybody. We had Pucks, which was Rule 6 on household. We escaped from Rule 6 test suite, very important. And we now have, again, well, 2010, we had Raccoon, Parrot, and Getscher on Mono.net. And you could very arguably say that nothing there is production ready. So you could argue that the zeros were the cocooning years for Pro. Pro was very visible in itself. It was redefining itself. It was reinventing itself. So what is Pro, actually? And I would argue now that these years have passed. So coming back to this, it will not be your normal deeper cocooning. Because in a normal deeper cocoon, you have an empty shell and something new comes out. This cocoon is different as in Rule 5 and Rule 6. I think it will continue to coexist for a long time to come. So what does Pro 5 look like in the 10s? Is that what you'd say that? It's 10s. We have a new release every year. We have many of the presentations in Pro 5, and a lot of internal protein, which has been very important. We have a lot of Pro 6-like features, which I'll get into later. And we have a lot of Pro 6-like modules, which I guess will be one of the most important ones. But also method secretaries and processes. And we have a monthly development release in Pro 5. So how does it look for Pro 6 in the 10s? Well, Niencia came up very quickly and very fast. It was more feature-complete initially, but it's falling behind now. We have Not-Quite-Pro developed. And the nice thing about Not-Quite-Pro is that it's actually soft hosting. We have 6-model actually implemented on AKB with multiple backgrounds. We have Moren, a virtual machine with Pro 6. Everything that Rakudo originally was planned to be is now more. I could argue. So now, Rakudo runs on Parrot, JVM, and more VM. And we also have a monthly development release. Will these continue to coexist? Yes, they will. But I think that Pro 6 will become much more important and more feature-proof. And therefore, we call it large. So, what are the Pro 6 features in Pro 5? Well, I said earlier that, say, yada, yada, state variables, defined or electrical subs. So between signatures, a lot of these things for Pro 6 work in Pro 5. And as long as they don't involve types, they generally work in Pro 5. So, in these examples that I'm going to give you now, I made a little alias for Pro 5, capital E and Pro 6, small e. It makes it smaller and it makes a lot more less typing. So, if we look at this in Pro 5, we have a print, and we have to say it, otherwise it puts a new line for you after it. And how does that look in Pro 6? Exactly the same. So, winning, I guess. What do we have here? In Pro 5, we even do the yada, yada, yada here, and we run the subroutine and it stops with saying it's unimplemented. If you put something like this into, try to do it in a variable, it's actually syntax error. So, the yada, yada, yada is not complete like the yada, yada of Pro 5. The Pro 6, yeah. In Pro 6, if you do it like that, it's subcode executed. It's not unimplemented, it's subcode executed, but it works the same way. However, if you try to put this into a variable, it actually works. It's actually valid code. And what we put into the variable is that's the way of actually asking for what something is in the variable, what method, actually macro method, something, thingy. It's failure. If you put a failure in a variable, does that mean anything? Well, the moment that you actually look at the value of the variable, like you're going to say, it will actually find out, oh, hang on, this is wrong. Something happened here. So, you can delay failures in Pro 6. And that's a very useful feature, especially if you run a asynchronous. The failure state variable is Pro 5. Well, that's very nice. There was a sub here, and we started at 10, and we say from 0 to 9. Let me get it up to 30. Very nice, very easy. It's a statement for Pro 6. The way you specify ranges is a little bit different. You can say 0 to correct 10. This basically means Pro 10, but don't take the last one. So, which is 9. This is the defined order. So, we've got two variables. One is a defined, one has a value. The defined order will give you the second one, and the first one is a defined. And the normal order will give you, if the first one is false. So, in this case, we're going to put 0 in here. The defined order will give you 0. And the second order will give you 0. Very useful to have that. And I know people that actually backported it to earlier versions of Pro 5, just because they wanted to have it there. And Pro 6 is not different. So, that's one nice backport of a Pro 6 feature to Pro 5. Lexical subroutines. You'll let everybody know what a Lexical subroutine is. Yay. In Pro 5, you can now say my sub, which basically means that you only have a sub that exists inside this code. So, you can run it here, which makes it full. If you run outside of the scope, it doesn't know about it. It's going to be very handy to make sure that the things are only visible in the area that you actually need them. So, this is about the same as just saying this. And so, it's definitely, it finds out at runtime that you actually couldn't call this. Now, if you compare this with Pro 6, all Lexicals are, all subs are Lexical. So, I don't have to do anything special here. I have a sub A here, I can call the A here, and call the A outside of this scope. But, this will never run. So, Pro 6 already, a compile time figures out that this subroutine call will never work, because it doesn't exist there. So, a never run will take a compile time, which is a huge win, if you're actually misspelling names, and you find out like five minutes into the run of your program that you misspelled something. Good that you know what it means. These are the new features of Pro 520, and Pro 5, they're called signatures. You can actually specify, in the area where you normally do a prototype, you can now specify a signature. So, the first parameter, the additional parameter that you pass to the subroutine will become part, will be stored in a variable for Pro 5, and all of the rest of the name parameters will be put into a hash. So, if I call this subroutine with bar and basically a hash, I get these two things. Now, in Pro 5, you will still also have an underscore. Even if you say, if the signature and underscore will still exist. So, the whole signature thing is just syntactic sugar for you. It doesn't really do anything apart from that, it just makes sure that it does all sorts of things for you. So, the huge overhead that you have for actually creating an underscore and a subroutine called signatures. So, there's no runtime effect of using signatures, it's just for your convenience. Those are lexicals inside the subroutine, yeah. Automatically, you don't have to specify them with minor, automatically, it's just inside the subroutine. In Pro 6, you can do the same like we did here. You have to call this a slurry hash and see star in front of it. You can do the same thing. However, if you specify an underscore here, it will actually at compile time say, uh-uh, you can't do that. In Pro 6, an underscore is only created if you actually use it inside the subroutine and then it automatically creates a signature for you. Since I've already specified a signature here, you actually cannot have that in there. And that's a good thing, because you probably don't want to use an underscore in a year anymore if you actually take the trouble of using signatures. So what are the problematic Pro 6 features in Pro 5? Well, the standard async thing needs that we have in Pro 6, Pro 5 are based on hybrids. We have promises, but they're based on an event loop that you need to actually have in your program. The smart match doesn't work because we have type problems in Pro 5. We don't know what something is, so we don't know what the smart match is supposed to do. So it's going to be dedicated, and superteens signatures are limited and they are only synthetic sugar. So that only goes to show that if you bolt on stuff on a laser where you didn't actually take it to account from the start, it's always hard. So standard async, we have hybrids. It's sort of flawed implementation. If you really want to know what's wrong with pro hybrids, copy me after the talk. But there's no real alternative for it. It's basically using the fork emulation that was intended to work on windows. Yeah, it's another way to do the threads, but it started as a job and I think still is in the end. But you should really realize that if you want to program threads, you're actually doing something that is sort of superhuman. And I think in that respect, it's very important to remember our old friend, Kurtigan, by Kurtigan, who's stated in his program C-book, if I remember correctly. Debugging is twice as hard as buying a code in the first place. Therefore, if you write a code as cleverly as possible, you are, by definition, not smart enough to debug. And this is very true with your programming threads. You're always working on yourselves if you're programming threads. So you should be programming threads yourself. Code 5 also has a promise module. It's a synchronicity for non-superiors. It's available as a secret module, but it beats an event loop. And you can usually only have one event loop in your program. And if you have one set of modules that use one event loop and you want another event loop, then you have a problem. And trouble. And probably the promises are not really asynchronous to begin with. It just gives you the impression of being asynchronous. So even though you have eight cores, you're still just using one core. It's just not what you want. In Code 5's smart match, well, you need typing really to make smart match work. Code 5 most likely will never have typing. Remind me a little bit. It depends. It depends how much one leak is available. Yeah, exactly. So it's been of limited use for those that have been with a source of confusion in Code 5. And therefore it's going to be deprecated. So this is one of the failed experiments on porting back from six features to Code 5. And it's hurting. So two signatures. Well, they're not here yet. It will be in May. It's a type of sugar. In Bill 6, signatures are part of something called multi-banded dispatch. I'll give you a little about a month later. But it's very nice to have none less. I mean, one of the things that made Code 5 look like in all languages because you actually had to always do something like why this and that is at other's work. And you don't have to do that anymore. So in that sense it's very good to have that. So give an example of signatures in Bill 6. This is a way of specifying the name parameter and the default for the name parameter. So if I just call it without name parameter it says hey you. Never follow what you've got to say. Hey you've got it. And that's what is the fact is this. You might ask. Well, this is what you know. I guess Bill 5 is called a fat comma and in Bill 6 we call this pair. And if you look at the rule code for that it's actually using the fat comma notation for you. This is just the same way of saying this here using the angle bracket here which basically means quote this and that's a what. It's a pair and the rule is the same thing. So these are just a quicker way of saying this is less typing and it's more consistent. You can use this everywhere where you use name parameters or pairs or whatever. And this is an example of multi method, multi sub-dispression in this case. A short way of saying that we have multiple units multiple subs of the same name. We say multi A, multi A, and we give it a different signature. So this one accepts numbers, this one accepts strings. In this case I just say number that number and use that string that string. And I'll call this same super treatment 42 over the string. I get number 42 and string 2. So that makes it very easy for you to actually handle different parameters and it just makes different subs for them. You don't actually have to think about it yourself anymore. This is a very powerful thing. So, and why is that a powerful thing? In those states you can just say my dollar A equals 4 and you can say that it works. You can say this is a number and I put 4 into it and you say it. It says type shape. Type shape change in assignment. If I get a number, I got a string. No go. It doesn't know. A string is not a number. But if you say a string here, it just works. So this is the thing called gradual typing. If you put in the type that you want and it will check for you, will it actually make things slower when you do this? No. Because if you don't specify anything here it actually says my any dollar A. And no is any and string is any. So it works. So you don't get any penalty for adding types. In fact, you're helping any optimizer code to actually optimize your stuff in such a way that it actually goes fast. So if you can use type, you should use type and you probably should have used it. And if you put something wrong in there and it will bomb on you, it is very useful. Is this still something important at all? In the sense that, for instance, number 6 is an impression for a string. Yes. There is a spec that will allow you to specify that if something comes in from that and you want to actually automatically chorus it, you can do that but it's not implemented. Okay. And there has been some discussion whether or not that should be implemented. 6-1. There are constraints or non-conversions. Like basic constraints. So what are the full 5 features in full 6? We have the full 5 intro object, the project we have used in full 5. But of course it always stays hard to integrate something or mimic something that actually does not have a description. The only description of full 5 that exists is full 5 running full 5. And finding out what something does, there is no official description for it. This full 5 intro object, the idea of that is that you can actually run a full 5 interpreter inside the code or more here. So you actually get access to all full 5 out there, including the N-models with XS and you would be able to call full 5 code from full 6 to full 5 for itself. There is only one problem. This project has been since it has told and there is no ETA. Even though this nice ground waiting for it is not doing it anymore and we don't know exactly why. We have used V5, which is the other thing. It's basically original by Larry Wall himself and it's done by Tobias Leig, IK Frogs. And it's basically like full 6 is implemented using NQP and Grammars and full 6. And it's really committing full 5 in the same way. So create a grammar for full 5 that creates ASDs and just basically uses the same runtime as full 6. That's gone quite a long way. But it will never allow access. At least not as we know it. It will allow full 5, full 6 because it internally uses the same code. So there's no difference anymore. And it now has about 10% of the full 5 test suite. Now the biggest problem there of course is that there's so much code in the core of Google that is XS code and that will never run. So there's a huge part of the test suite that will actually just never pass. So 10% doesn't look like a lot but it's actually quite a lot. If you think about it. So if you look at it for what we need for full 6 adoption in the future I think we need a good introduction ebook. We need full modules to CPAN support. Actually at the moment you can already upload full 6 distributions to CPAN. You can't download or install them yet but it's very important that the whole architecture that we have for CPAN, for testing, for grading, for dependencies and everything is not being not known to say destroyed but being inconvenienced by full 6 modules that do not compile in full 5 and stuff like that. So we're now going to upload full 6 distributions to CPAN and there will be ignored which is a good thing but they already disappeared and we need better performance Now a good introduction ebook. I was I said that a certain someone is working on that a certain someone who wrote a chemical book a long time ago but this is a rumor. So if you feel like writing your full 6 book or blog about it please do let us know that you did put a link into the whole Planet 6 feed of logs and you will get destroyed. We're going to make more modules and CPAN support Installing from CPAN should be pretty soon I guess around the post-progress shop in a few weeks we're going to put the dots on the high there and there's going to be a network probably in September where we really start supporting CPAN modules to full 6 and of course this is not going to stop anybody from starting to do that right now. The better performance part Orbea is now completely standalone the performance of Orbea is creeping towards 205 I would say the start of 205 plus moves is now I would say on Orbea and we actually now can officially say that we have a Google server code project to develop a kit for Orbea and what that means is that it all goes well Orbea will be so smart that when it can it will actually compile out the machine code Am I saying that correctly? And it And I guess when that happens we're going to see how long do some nice benchmark tests with Orbea? Is there an update with Flavio? Is there an update with Flavio? Is there an update with Flavio? Is there an update with Flavio with Mr. Tolito which was a compiler that goes to ;) As far as I know Flavio is still working on Tolito I saw recently a number of commits pass by again but it is not on the Pro 6 channel it seems to be working completely on its own on this I don't know if there is a channel for Tolito I'm not pretty sure but I'm staying at Tolito see that as a thick tank type project rather than anything. Are some set of the core applied at the last vector bit? You see, you basically take the same approach that the D5, usually D5 does by using a grammar to interpret for fight code. So in that sense, it's the same, but it's not NQP-based at all. And so it doesn't have the benefit of if you have NQP running on a virtual machine, you basically almost have Pro 6 running on it as well. So you don't have to need to port whole languages, where in his case, more or less is. And he's now, you know. The nice thing being that D5 is built on top of it, meaning that D5 can work on the JVM. Yeah, exactly. The nice idea that he has, and that's to an extent I didn't mention it here, but there has been a project that actually targeted JavaScript as a back-end for NQP. And that's one of the back-ends that he has. So you can actually run Pro 5 or Pro 6 in your browser. And that would be very nice. There is a project still sort of going. It's sort of sweet going at the moment. Who knows what happens? Close has the degrees. OK, so I'm basically the guy doing this. First has to get this degree, and then he can actually work on this again. Yeah, well, that's life for you. So why would you use Pro 6 in production? I think, most importantly, it is a saner, explicit, multi-core programming concept with channels and promises and supplies. The supplies part you saw this morning in terms of NQP with that. It will have no worshipping issues with modules. This is very important for production. If one module is using another module of a particular version, it will never interfere with a third module using the same module with another version. Because everything you do with modules is only visible inside the scope that you use in module. This is very, very important. This is a very big difference between Pro 6 and Pro 5. In Pro 5, if you load a module, it is global for everything in your process. In Pro 6, it is only visible inside the scope that you actually use it. Outside there, it's not visible. I'll give you the time. So all these cool features, I think, will make happier programmers. That's important for management, I think. So to give an example of implicit asynchrony, which, by the way, is actually not yet implemented in Pro 6 at this point, but we now have all the primitives to be able to do that. This is what is this? Well, it's one or two or three. And in Pro 6, you say it like that. It's any of these. It's basically part of superposition of the thing in our way, but it's integrated into the language. So if you say it's one, two, or three, is this true? Well, you get this. Is any of these true or false? Well, that's true, of course. So if you want to boolean out of that, it's true. Now let's say that I want to have an relative of between 0 and 999, 999 inclusive. This is short for that. We just leave off the 0 dot dot, and you say that. Give me a random number, like 718. So if I have my dollar 8, it's any from 0 to 999. And I say, is this 718, sorry, is this any from 999, is that any of them have a random number? It will actually have to go out, of course, each one of them. And normally, in a program, you would do this sequentially, because it's going to be true. Is it not? Now if this is 1,000, the random number, there's only a chance of 1 in 10, and it's true. So it actually has to go out and try all of them. And that still works, but it could also be false. And this is a case where we actually, in the future, impulse 6 will actually automatically, for you, thread out and make it just do it parallel. And the first one that gives you a true result will be one that, in this case, it gives you the result. And it will give you that narrative. Maybe use more CPU. We have plenty of that, because we have plenty of force. So this is another example of this. Suppose we have a little piece of work, 10 of them. And in this case, I'm just saying this is a random sleep, and I just print the number that I get here. So if I run this, it will just print those numbers. And in real time, it will take about five seconds. And it will use so much CPU. Now if you want to do this impulse 6, but in parallel, you make this into a promise. This is the start function. It makes this a promise, and it just goes off somewhere and does it for you. And you want to wait until all of these promises are finished. So the result of the for loop, we get it to the await. The result is a list of promises, and the await takes all the promises, and waits for all of them to actually have finished. So the order in which these things are done is not the same anymore. But if that's not important for you, this might be important, because now it only takes 1.2 seconds instead of 5.4. And it only takes much, only more CPU. So if you have plenty of CPUs, and you don't have a lot of time, this is the way to do it. And this works. It is as easy as it gets for you impulse 6. Now in regards to modules, and so there is a test module in impulse 6. It's just called useTest, and it will give you an OK sub, and you can actually put the value in there, and it will give this comment. So if you do this, you get this. Very simple. Now if you go to the useTest here inside its own scope, the OK is only known inside the scope here. There's no OK outside of it. So you get an error, and then only will you get an error at runtime. You get an error for file time, because it already runs at the file time, but you don't have OK there. This is where it gets very important. Whenever you use a module, it only is seen inside the scope that you actually use it. So if somebody would write another test module, I could use that in the same script, as long as they use them in different scopes. This is very important for production. Yes? Just a question. I thought you would specifically allow this kind of syntax, that you have to say which test I'm using, or there's no good use. I think you'll switch that if you can't. Oh, yeah, but I don't want to go into that right now. The scopeing is the most important thing here. The fact that you can have different tests by authority or version is not an issue, but you can specify it in the use statement to say, I want to have useTest version 1 here, and in the notebook, I want to have useTest version 2. But that was going for the visibility aspect here. OK, so how can you try those things right now? Well, it's very easy. You go into MC, you make a directory, you do a git clone, you do a CD into the directory, you do this, get more, it goes click, click, click, click, click, click. You say make install, it goes click, click, click, click, click, and you have both six in your installment directory. That's all you need to do, get more six. You want to get support? We have a very good channel on ioc3.org, a six channel, very friendly folks there. There's a lot of examples in the Rosetta Code protect for PhilSix. It's just a place where there's all the blogs. There is an article if you're going from PhilFive. On PhilGit.tv, some other nice articles there as well, by the way. And if you want to get into the nitty-gritty, there's all these synopsis, which basically is the specification of PhilSix that you can find there. So this is, I think, how the cable is decopuding in the coming years, and right now, actually. Do you have any questions? I guess in Python 3.3 or 3.4, it's strongly typed by Stena and Leithite. And I was going to be talking about your signatures. In Silkeban, Python 3.4 was in your naming of parameters. You can make a suggestion like, I'm kind of expecting this kind of type, but they're just suggestions. And then when the function runs, it's kind of an optimization. OK, because you said that I'm expecting a number for this parameter and I'm expecting a string to this other one, is that something that could be added to the profile to make that a little more useful than just a sugar curve? You wouldn't know. I'm not actually typing, but like suggestions. There have been very large discussions about this on CIP. And the thing is, well, I'm only actually following. My impression was that it couldn't reach an agreement on what it should do and what effect it would have on backwards compatibility and performance. Well, the back of compatibility, I don't think we should review the whole discussion. It's been a huge discussion. And the thing that everybody agreed on, we need at least to have a syntactic sugar right now. So that's what's going to happen in 5.20. We know it's going to happen in 5.22, but that's the situation here. Now, from 6.20 on the HGVM, we talk about the modules that you can specify. Does it mean that memory-wise, for the merci, you know the Java? Well, that's a thing. If you load two different modules, they will take up memory. Yes. It's a list in that case, so. Yeah, but in general, I would say towards the future, I don't think memory is the problem. It's the problem that CPUs are not getting faster. It's just getting more of them. You can't have to take any of them. Maybe you can. More questions? It's just a convenient way. It's syntactic sugar. It will basically just internally map at underscore 2, my, dollar, whatever. We'll do that for you. That's about it. But if you don't pass in the parameters in arguments, so you take two parameters and pass them along here? But those two are the same, right? Still. Yeah. Yeah, and write it, right? Yeah, for every one that we have done so far, it will be used. No, it will be like. Yeah, well, I would have to do that. So, well, I guess I should take it down. So thank you very much. And I would say thank you for the white panel.