 I'm going to talk about Raku, previously known as Per 6, until October last year. Long story short, it's a different language. So, I mean, you think about something that has a 6 in its name, and then you say, OK, so it's like 5 already, you know, bigger or better or whatever. But it's not, it's totally different. Still, there is more than one way to do it. So, Larry Wall, which right away his nickname is Tim Toady, that is more than one way to do it. So, basically about Raku is that there is more than one way to do it. But before, let me tell you about Raku. Before that, what are the kind of things that many cool emerging languages do nowadays? What kind of things are you going to find in new languages and also all languages which are getting new features? One of them is Unicode, because Unicode is important. It's very extremely important. I mean, it's the basis of every single language. It's the basis of every single text computing nowadays. Let's check out, for instance, JavaScript. JavaScript has very good support of Unicode. You can see that. Okay, load it up for you. Still, you see that there are many ways of supporting Unicode in JavaScript. For instance, you can write the name of identifiers, you can write them in Unicode, but also you can use them inside regular expressions. So, you can check if something is actually Greek or not. And you can then call this function with this thing, and then it will actually output just because it's... But still, you see something here which is this thing, right? This is you. So, you are telling explicitly JavaScript that it's Unicode. It's a Unicode regular expression. It's like it happened for instance in Python 2. In Python 2, if you wanted a Unicode string, you have to put a new in front. I mean, it's supported. And you will see this in many languages. It will have different kind of support. But there are some other things. For instance, lambdas. Lambdas are so important that even C++ has lambdas now, which is totally amazing. Also, immutability. The two things are kind of related because they're related to functional programming. Lambdas are functions that you can use as data and they are first class citizens. And immutability is something that you are going to use because you're going to get some kind of variables that are not changed and you are going to do some kind of things with them. Like for instance, this. Can you see that? Yeah, right. This is Clojure. It's not a very modern language, but it's very similar to many other Lisp-like languages like, for instance, Guile or some other like that. The first thing is we define a lambdas here. This is a lambdas because we are saying, we are defining some general kind of data, which is ellipses, and then we are saying, okay, so this is going to be an fn, a lambdas, and then it's going to take this as an argument and it's going to do this, right? And then this function is a recursive function which is using that lambdas right here, right? So I'm using both things here at the same time. The good thing about immutability is that you can be pretty sure that some particular data structure is not going to change, that allows for lots of optimizations. Also, needs you changing a little bit the way you think about the algorithms and everything, and it allows you to forget about loops so that loops can be eventually deprecated. There are also some other kind of things like post-modern assignment. Basically what you do is you destructure arguments. So instead of taking one data structure here and then you do some kind of exploration of that data structure and you put several data structures on the other side on the left-hand side, you can do that in one single way. And also gradual typing. Gradual typing is a very cool thing that many, many model languages have and it allows you to use type if you want, not use it if you don't want, right? You can have some data structure, whatever, they can change, they can have different types along its lifetime, but then some other languages say, no, no, I want this data structure to be like that. I'm putting these two things together in Kotlin with Derrida, who is the father of post-modernism and then he was all the time talking about the structuring and okay, that's it. This is several things here. First one is a lambda. The lambda is right here. Landas are all over the place. There is almost no single language that doesn't have lambda. I'm pretty sure that Fortran in the next iteration will have lambda. Anyway, just like here, right? And then Kotlin is very nice because it allows the structure in a pretty simple way. You just create a data structure in any way, like a struct or whatever, and you can assign it to something else. You don't even need to specify what you are going to assign to the first thing, what you are going to assign to the second thing. You see that in this case I return a result, which is a data structure that is defined right here, and then result says 42 and true. In this case says something else and false. So it's a data structure, this data structure right here with two things. Here I'm assigning the result of that, which is a data structure to do two different variables. I'm destructuring that data structure directly, which is easy, which is nice. I don't have to create an intermediate data structure. I don't have to deal with issues of memory allocation and things like that. Pretty fast, pretty straightforward, type safe, everything very nice, right? Then you have things like pattern matching for complex decision making. So the kind of thing it avoids is if cascades. So you don't have like if this happens, then do that. If this other thing happens, then another thing, then another if, then another else, you know, if cascades. By the way, this is a very nice cascade in Iceland. All the pictures are mine. And they are all creative commons, so you can download them, you can do whatever you want. It's a creative commons CC by SA. Anyway, so we are going to try them in Scala. Scala is, I'm not going to say a pretty nice language, I'm going to say it's an academic language. It means that it does some things very well, some of the things are not so well. That also means that as any other academic language it was in obscurity for a long time. And then all of a sudden, that the same has happened. Everybody said, oh, data science, we are going to learn Scala. Anyway, it's a language that you can do very nice things with Spark and everything. But it's also object oriented, it's functional, and it's got very nice features. Anyway, I was looking at this pattern matching which we use this thing called match. It's a keyword in Scala, which is match, and then you check card and you can check it against Ace, three, JQ, you can do more complicated things here. Like you can put some regular expression, you can compare it with a type, you can do some other complicated things. And you also have a default type, a default case, which is this one, which you are going to use. In this case, it's like a cascade of thief, only it's nicer because you see very clearly the intent of the code that you are seeing there. Eventually you use it, you call it in points and it goes to here and it prints whatever. Multiple dispatch. The great thing about multiple dispatch is that depending on the signature of a method or function, you are going to call different code. So, again, you avoid ifs. Again, you state very clearly what's the intent of your code, and then your GIT compiler or anything that's a lower level can see very clearly what's going on and then it can kind of optimize what's going to happen. Of course, if it's functional, it's going to be even better because you can cache, you can do memoize, any kind of thing. We're going to do it with Julia. Julia is also a language that was created for science, which means that it doesn't have things like, you know, web or database, things like that. It's science, you know. Of course, there is something like that because it's a general purpose language. It was very recently turned into version 1.0 which broke everything, of course. But anyway, it's a language, it's got very extensive support of macros and it's, I mean, there are many cool things about Julia. But in this case, we are using this multiple dispatch with these two different functions. We are going to use the Spanish way of expressing cards like bastos, espadas. Anyone knows this? It's actually not Spanish. It's from Naples, but anyway. So we use two different enums. This ampersand over here is a macro, so the way Julia defines macros is by using an ampersand and the way Julia defines an enum is by using a macro, which is kind of nice. Anyway, it's kind of a type, so if I am calling two strings with something that is a symbol of the American or French kind of card deck, it's going to call the first one and then it's going to call the other one. This is also a lambda. So we are defined two strings as a lambda because we are not putting, you know, the key or whatever way of saying, no, no, this thing is going to be equal to that. And also we are using Unicode. We can use enum, we can use directly Unicode symbols here as Unicode. That's good, right? Slots will inherit the earth. Actually, I'm too lazy so I was looking up for a picture of a slot. I didn't find it. I found this picture of penguins and penguins are cool. So anyway, lazy evaluation is very powerful. It allows you to define to work with infinite data structure. You can have anything in it. Only when you're actually needing something, when you're actually printing something, it comes to life. But working with lazy is such a functional because you can work with mathematical data structure, infinite sequences, infinite maps, whatever. And also there's this thing called cascading. Cascading is something that allows you to kind of put the result into a computation into another computation and then into another computation without the need to use intermediate variable or anything. You just say, okay, I want the result of this to be processed by this. The result of this is going to be processed by this other thing and so on and so forth. Let's look at it in F-sharp. F-sharp was a language that was created by Microsoft, which is why nobody paid attention to it for a long time. But then it's a good language. It's a purely functional language. It's a language that's working on the .NET virtual machine. Yes, please? Do you see it? Five minutes. Okay, yeah, almost done. Thank you very much. We are going to compute something which is called the Horadam sequence. Horadam sequence is kind of a generalized Fibonacci sequence. Everyone is using Fibonacci sequence, but you see what we are doing is this is the first element of the sequence, so this is the first thing that's going to go into the pipeline. Then we pipe it into this thing. So what we are telling it is you are going to pick this up and you are going to create an infinite sequence out of that. And then eventually what you are going to do is you are going to open it to the first two elements. I am going to put that in the beginning. And then this is totally lazy. So I am telling it I want this infinite sequence and I am going to have a lazy there structure that's going to hold that. And then I am going to compute it and I am also going to use this pipe to just take the first 15. So eventually when I compute the first 15 they come to life. That's cool and that's actually very fast. I got all of them in my computer actually. Finally, inheriting is much better than composing. I can't reduce it anymore. So you can use traits, mixing and rows. The 90s were a little bit all about object-oriented programming but then something more complicated came. People were talking about meta-object protocols so that you can create all kinds of things. Anyway, my point is that you can create new kinds of objects or classes by composing other objects. Like for instance using it in Rust. Rust is a very nice language. People were tired of using it and getting shot in the feet and so they say we are going to do something totally different and then they talk about Rust. Rust has a very interesting concept of data property so that only some things can work with some other things but here what you define is a struct which is a structure and then you define a trait and then here what you say so what I am going to do is for this trait, for this there is a structure so you kind of bind it together and that is using trait in Rust. What is the point with Raku? I didn't talk about Raku so far, it was just a little bit. The point with Raku is that it's got everything and the kitchen sink. This is actually my kitchen sink at home right? It's a little bit dirty there is some chopstick here and the rest of the... anyway it took me a while in most cases I hadn't seen those languages ever I had never written a line of code in Rust or of course in F-sharp or you have a script a little bit Python also took me a while but not too much the most difficult part was actually Kotlin because syntax is tricky because you have to know how to do some specific things like concatenating to strings or getting an element of an array and that's a new righty max mode for everyone so it took a while to look up the righty max mode but I understood the concepts the concepts were there because I called in Raku so every one of those things is in Raku and many more this is me, I'm part of the core of Raku development I work more or less with documentation and that's my github and this is this is going to suck anyway so I'm not going to even try it's on the web, you can check it out but this is a Raku program which has around 20 lines of code which implements every single concept I have talked about here every single one of them plus one that is incredibly cool I will see if I can show it here you see it here? you know what's that? Raku is able to do arithmetic with Arab literals as far as I know there is no language that is able to do that this is actually arranged so it's arranged from one to one thousand right? and it's also written in the right direction because unicode is important so if you are written in Arab you have to do it in the right direction you type it in the right direction but it shows up in that direction it's incredible this is not part of the highlight I'm using this slanted eye which is a unicode thing anyway it's there, you can check it out so learn Raku to learn every single language at least the cool ones that's it, thank you very much I don't know if I can repeat the question I mean it's no big deal I repeat the question he's asking Raku is able to maintain a team where people type in different ways is that correct? that's a good thing you use cmax ctrl x8 tab and then you get all the unicode things and then you save on this one that's it or you look it up in the web and then copy and paste okay thank you yes please that's correct yeah the thing is that Raku has got something which is called native code so native code basically it allows you to embed things which are written in any other language using shared libraries so I want this function which is taken from that particular shared library and you can do that with Python you can embed the interpreter of Python there is something called inline Python there is also inline pair and you can basically do anything many libraries are just basically I want this C library or anything that can be compiled from Go or Rust or whatever to a shared library I want this inside Raku so I load it and then what I do is I want this function in C to be called that other way and this data structure which is in the original language to be called in this other way it's amazing, works pretty well thank you very much