WEBVTT

00:00.000 --> 00:13.800
So, we will start another talk about how to improve Python, how to use another language to improve

00:13.800 --> 00:14.800
Python.

00:14.800 --> 00:20.800
For example, we have C, C++, or REST, and here, that will be the case with NIM, another

00:20.800 --> 00:23.800
language, trying to help Python.

00:23.800 --> 00:24.800
Let's go.

00:24.800 --> 00:25.800
Thank you.

00:25.800 --> 00:35.800
I can speak loud, what?

00:35.800 --> 00:42.640
What are you going to speak loud, what are you going to speak loud, what are you going to speak

00:42.640 --> 00:52.640
loud?

00:52.640 --> 00:53.640
This one?

00:53.640 --> 00:54.640
Okay.

00:54.640 --> 00:55.640
Wow.

00:55.640 --> 00:56.640
I'm loud now.

00:56.640 --> 00:59.640
So, thank you for being here.

00:59.640 --> 01:00.640
Very happy to be here.

01:00.640 --> 01:08.560
So, this will be talk about the fact that, let's say seven or more years ago, I was a

01:08.560 --> 01:09.560
Python consumer.

01:09.560 --> 01:17.240
I consumed a part of the ecosystem, and something pushed me to get out there and do stuff

01:17.240 --> 01:25.680
and motivate and be part of the community and even try to contribute to the wider ecosystem.

01:25.680 --> 01:34.760
So, it's actually talk about becoming a better Python instance, and the takeaway for me is

01:34.760 --> 01:37.120
if you get inspired by doing something like that.

01:37.120 --> 01:45.560
For me, that thing has been NIM, but pick your one and do things.

01:45.560 --> 01:48.640
Code for the slides is on GitHub.

01:48.640 --> 01:55.240
So, what is NIM is a programming language, and it's a systems programming language, which

01:55.240 --> 02:00.560
working in the definition is a programming language, which you can write an operating system

02:00.560 --> 02:01.560
for example.

02:01.640 --> 02:08.560
And it's weird one at that, because it doesn't use braces for indentation, and it uses

02:08.560 --> 02:16.480
white space for indentation, which makes it a kind of, not unique, but there are a few

02:16.480 --> 02:19.080
of those.

02:19.080 --> 02:21.840
It's also statically typed and compiled.

02:21.840 --> 02:29.560
So, in these are two ways in which is really different from Python, but it's also good for

02:29.560 --> 02:30.560
everything.

02:30.560 --> 02:40.560
Not have a specific use case, some languages are born with something in mind, NIM a bit

02:40.560 --> 02:46.160
like Python is something that you can use pretty much for any use case.

02:46.160 --> 02:54.360
So, a little bit about me before starting, I met at a scientist, I will use maybe this

02:54.360 --> 02:58.800
is an excuse if you ask me hard, the computer science question.

02:58.800 --> 03:05.800
I work at agile lab, which is a consultant in data engineering, one interesting thing is

03:05.800 --> 03:13.040
that we have a self-management system called holakrasi, that I think is something that

03:13.040 --> 03:17.640
ties well with open source, and I'm also organizer of Python Milano and Python Milano,

03:17.640 --> 03:23.080
if you want to be pass from there, you want to give a talk, we have to, we try to organize

03:23.080 --> 03:29.120
two meetups every month, and I ran into 2018 on Hacker News on this blog post, that

03:29.120 --> 03:35.320
didn't have even the name MIM on the title, and I find it interesting, you know, the romantic

03:35.320 --> 03:43.600
of being an underdog, it was a very nice blog post, and that's how it started.

03:43.600 --> 03:47.200
Good part of the work that I'm presenting here was Donna Drikersenter, which I retreat

03:47.200 --> 03:50.280
for curious and kind of programmers, very nice place.

03:50.280 --> 03:56.040
I did this at Python Italy, and again, please come to Python Italy at the end of May,

03:56.040 --> 03:57.440
we'll be there.

03:57.440 --> 04:05.400
So I will first tell you what is been in a little bit more detail, and then I will try to

04:05.400 --> 04:12.360
explain you why it made me a better Pythonista, and we have blocked the ups for you.

04:13.360 --> 04:16.360
Good.

04:16.360 --> 04:18.360
Thank you.

04:18.360 --> 04:20.360
Thank you.

04:20.360 --> 04:23.360
Really, thank you.

04:23.360 --> 04:25.360
I don't know.

04:25.360 --> 04:27.360
What do I do now?

04:27.360 --> 04:33.360
Okay, yeah, it was just the top.

04:33.360 --> 04:39.360
And then I'll tell you how also you're in the way that I relate to the open source, and it

04:39.360 --> 04:44.360
may be created project and start interacting with the community.

04:44.360 --> 04:52.520
So, MIM, as a first approximation, is an easy to learn and fast complement to Python,

04:52.520 --> 04:59.520
as presented originality, it has very nice interoperability, and the killer feature I would

04:59.520 --> 05:05.720
say is Metaprogramming, and it has another bunch of features.

05:05.720 --> 05:12.200
So the main selling point, at least the beginning, is the fact that it's performance,

05:12.200 --> 05:19.200
so it compiles two native code, and it doesn't add overhead on a runtime or something like

05:19.200 --> 05:20.200
that.

05:20.200 --> 05:26.960
For me, the liberating factor is that you can write nested for loops.

05:26.960 --> 05:31.600
You can write multiplication of metrics with three for loops, and it doesn't give you

05:31.600 --> 05:32.920
a hit in performance.

05:32.920 --> 05:39.920
And you don't need always to reach the reliability to do something performant, and that's

05:39.920 --> 05:40.920
very nice.

05:40.920 --> 05:47.240
And we actually had a debroom when Fosim was online, and there is a talk about this use case,

05:47.240 --> 05:51.280
but we'll not talk a lot about the performant part, because one of the things that I like

05:51.280 --> 05:57.080
a lot is the syntax, so which is also one of the things I like about Python, the readability

05:57.080 --> 06:00.560
part, the fact that you want to show code.

06:00.640 --> 06:06.240
I will start with one thing, which is sometimes a bit of a look, and it's also a bit weird,

06:06.240 --> 06:10.920
not many languages have it, and it's one of the advantages of being statically typed.

06:10.920 --> 06:18.680
So if you have types and a compiler knows about type, you can do something like this, in

06:18.680 --> 06:25.200
which you can define an ink procedure of function, it's equivalent of best.

06:25.200 --> 06:30.680
And when you declare it, to see the compiler knows that something called counter is of type

06:30.680 --> 06:35.600
counter, you can call it in three different ways, the common system, syntax, the function

06:35.600 --> 06:39.200
syntax, and the method syntax.

06:39.200 --> 06:40.800
And it will rearrange it.

06:40.800 --> 06:47.160
And I think this along the fact that you have procedural loading, so you don't have to

06:47.160 --> 06:51.640
come up with a different name for a function that does something when you change the arguments,

06:51.680 --> 06:56.600
which is also something that I appreciate a lot because I have a hard time naming that.

06:56.600 --> 07:02.200
So these things and the procedure of er loading gives you a lot of the advantages of object

07:02.200 --> 07:08.200
or the anti-programming without all the difficult part, the hand in terms of everything.

07:08.200 --> 07:11.120
All the parts that are related, especially to syntax.

07:11.120 --> 07:16.680
And you can always add a function to an object coming from a library and it will look like

07:16.680 --> 07:17.680
a method.

07:17.760 --> 07:23.480
And you don't have print parenthesis, print without parenthesis, Python 2, Python 3,

07:23.480 --> 07:24.680
conversion or anything.

07:27.680 --> 07:30.320
Once you have a compiler, you can ask it to do other things.

07:30.320 --> 07:34.000
So the compiler is something that can reason about your code and give you other stuff.

07:34.000 --> 07:39.480
So in the Python, we are used to have other tools, leaders and checkers and stuff

07:39.480 --> 07:40.000
you like that.

07:40.000 --> 07:45.200
But with a compiler, you can, for example, track side effects.

07:45.240 --> 07:51.600
And the compiler is able to check if something that you now call a funk and not anymore

07:51.600 --> 07:56.040
a proc is something that is without side effects.

07:56.040 --> 08:02.800
So it's a language in this way, which you can get closer to some kind of functional languages.

08:02.800 --> 08:07.680
You can exercise yourself in the style of functional languages,

08:07.680 --> 08:10.640
which is also something that I find very interesting.

08:11.640 --> 08:16.080
And then, as I mentioned, the killer feature is metaprogramming and, for me,

08:16.080 --> 08:21.240
is the equivalent of the magic, of Python, of the important gravity.

08:21.240 --> 08:27.840
And one of the first things I remember is the XKCD comic about that.

08:27.840 --> 08:32.040
And you have this power that you can just import something or something that you look

08:32.040 --> 08:34.240
and you have access to extreme power.

08:34.240 --> 08:36.840
And it's in a sense, this works like that.

08:37.040 --> 08:44.840
So to explain it, the definition is code that generates other code.

08:44.840 --> 08:49.840
Let's start with something we have somehow familiar, which are F string,

08:49.840 --> 08:51.840
which is a great feature.

08:51.840 --> 08:55.840
I guess the feature that made push the move to Python 3.

08:55.840 --> 09:01.840
And an image we look like this, not F, not F, not FnT.

09:01.840 --> 09:06.640
And how this is implemented, it's not actually language feature.

09:06.640 --> 09:10.640
It's something that you implement with metaprogramming,

09:10.640 --> 09:16.640
because in the language you can have that piece of code that is translated to another piece

09:16.640 --> 09:17.640
of code.

09:17.640 --> 09:20.640
Metaprogramming has different sources, but basically you can give

09:20.640 --> 09:26.640
something, static strings, other code, and you can manipulate the ST,

09:26.640 --> 09:30.640
produce something else.

09:30.640 --> 09:34.640
Metaprogramming gives other kind of magic.

09:34.640 --> 09:39.640
And one of this type of magic is interoperability with Python.

09:39.640 --> 09:44.640
And here we are seeing two kinds of magic, one from Niem and one from Python.

09:44.640 --> 09:49.640
On the top, you will see in a light gray, not very visible, something which is called

09:49.640 --> 09:51.640
the pragma, which has this expert pie.

09:51.640 --> 09:55.640
The rest is standard name code, but you import this name pie library.

09:55.640 --> 10:01.640
You annotate the function that you want to use in Python with expert pie.

10:01.640 --> 10:06.640
You put in the same folder a Python file.

10:06.640 --> 10:11.640
And you install the Niemporter library, a Python library.

10:11.640 --> 10:15.640
So you just have these six lines of code, these two files in the library,

10:15.640 --> 10:17.640
and everything is stored, of course.

10:17.640 --> 10:21.640
And if you run Python code, is able to code an Niemcode.

10:21.640 --> 10:27.640
Without anything, in the part of the Python magic is because Niemporter is

10:27.640 --> 10:34.640
hooking the import hook, and it recognizes, and it finds, thank you,

10:34.640 --> 10:41.640
recognizes this and is able to compile and bind anything.

10:41.640 --> 10:46.640
Another thing that I really love about Niemn is the fact that you can do interactivity.

10:46.640 --> 10:49.640
And this is another example of Metaprogramming.

10:49.640 --> 10:56.640
So that kind of BSL is in HTML like the SL used by a library called

10:56.640 --> 11:04.640
Carax, which is sort of a react for Python, that allows you to do interactivity in the front.

11:04.640 --> 11:11.640
And how do you do interactivity in the front and with this language that compiles to native?

11:11.640 --> 11:15.640
Because it does not only compile to see, but as much as boiler in the beginning,

11:15.640 --> 11:17.640
it also compiles to JavaScript.

11:17.640 --> 11:19.640
And I also in the description.

11:19.640 --> 11:22.640
And you have a very easy way to wrap stuff.

11:22.640 --> 11:27.640
So this is how my mind went when I saw this.

11:27.640 --> 11:33.640
Because in a way, as a data scientist, one of the things that I find very important is the user interface,

11:33.640 --> 11:38.640
the way that you interact with this complex algorithm that you look at.

11:38.640 --> 11:41.640
And so I always suffered about not being able to do that in JavaScript,

11:41.640 --> 11:44.640
and maybe not wanting to do that in JavaScript, though.

11:44.640 --> 11:49.640
This is also a result of a rapid, a JavaScript library.

11:50.640 --> 11:58.640
So that was what is named and why it made me into a better Python-ista.

11:58.640 --> 12:04.640
So one very easy way in which you can become in general a better programmer once you

12:04.640 --> 12:08.640
study your first programming language is to study a second programming language.

12:08.640 --> 12:10.640
And do something in other programming language.

12:10.640 --> 12:13.640
Even if you don't plan to use it in production.

12:13.640 --> 12:18.640
This helps you broaden your horizon understanding things.

12:18.640 --> 12:21.640
Maybe do something in another domain.

12:21.640 --> 12:24.640
And so it helped me understand what the type system is.

12:24.640 --> 12:26.640
There are different type systems.

12:26.640 --> 12:29.640
How to go into functional programming.

12:29.640 --> 12:31.640
Reason more about mutability.

12:31.640 --> 12:33.640
Which is also big thing.

12:33.640 --> 12:36.640
And this is one way to change me.

12:36.640 --> 12:41.640
Then one thing I want to tell you is why I was affected by this kind of language.

12:41.640 --> 12:45.640
And there are three things that I think that they share.

12:45.640 --> 12:48.640
One is very accessible.

12:48.640 --> 12:52.640
And this is a really powerful thing with Python.

12:52.640 --> 12:59.640
Because being accessible means being not purely to a really wide audience.

12:59.640 --> 13:03.640
And part of the success of Python, I think, is due to this.

13:03.640 --> 13:05.640
I also find it very playful.

13:05.640 --> 13:11.640
And playfulness is important for creativity, for innovation, for discovering things.

13:11.640 --> 13:16.640
That's why maybe Python has a important role in data science.

13:16.640 --> 13:20.640
And I also like the fact that you can use it because you must try everything.

13:20.640 --> 13:24.640
And once you learn one, you have something accessible and playful.

13:24.640 --> 13:30.640
And you can combine things from embedded to computing whatever.

13:30.640 --> 13:34.640
Three things instead, which are different.

13:34.640 --> 13:40.640
And in front, struggling to read Python are the fact that you have everything happening around time.

13:40.640 --> 13:43.640
So you get errors later.

13:43.640 --> 13:47.640
And the compiler helps you get the errors before.

13:47.640 --> 13:51.640
Then if you want, sometimes you create something with Python,

13:51.640 --> 13:53.640
and you want to give it to your friend.

13:53.640 --> 13:55.640
And it's not that easy.

13:55.640 --> 13:59.640
If you combine alternative code, you have an executable to give.

13:59.640 --> 14:03.640
And the other thing, probably the main thing is that when you work with Python,

14:03.640 --> 14:10.640
you usually work with a high ecosystem, or also reasoning about Python code.

14:10.640 --> 14:13.640
The Python object model is not something too easy to reason about.

14:13.640 --> 14:19.640
And the system's programming language allows you to get to the bottom of the layer of computing.

14:19.640 --> 14:26.640
So you have to cut through the abstraction.

14:26.640 --> 14:32.640
Another very nice thing, very interesting for me, is the fact that the name is a small programming language.

14:32.640 --> 14:34.640
We have a very nice community.

14:34.640 --> 14:45.640
And this I think is something that is a great opportunity to motivate you to contribute to something.

14:45.640 --> 14:50.640
So one other motivation, you can contribute with other bigger project.

14:50.640 --> 14:55.640
But if you find your own niche community of maybe name,

14:55.640 --> 15:01.640
maybe the other programming languages, it's a really a great place to motivate you.

15:01.640 --> 15:03.640
Because it gives you ownership.

15:03.640 --> 15:08.640
Just to give you an example, something that I participated while interacting with the community,

15:08.640 --> 15:14.640
was about picking the color of the language on GitHub.

15:14.640 --> 15:21.640
If you know, but there is a repository which records all the hex codes of the color of the language.

15:21.640 --> 15:27.640
And the name had at some point a different color that did not tie to match the brand.

15:27.640 --> 15:38.640
And in that repository in GitHub, there was a particular algorithm that checked that you didn't pick a color to close for other albums.

15:38.640 --> 15:47.640
So in doing that, we implemented a very specific color distance, so you can read more about the forum.

15:47.640 --> 15:55.640
And so implemented a color distance, and we were able to pick one of the colors that was in here.

15:55.640 --> 16:00.640
That was close to this.

16:00.640 --> 16:08.640
Then the third way, so I mentioned the fact that I improved technically.

16:08.640 --> 16:10.640
I improved in terms of motivation.

16:10.640 --> 16:16.640
And the third way is that also, when you go into another community with all its differences,

16:16.640 --> 16:23.640
with all its issues also, you come back with a different perspective on the Python community,

16:23.640 --> 16:31.640
which I think is a great place, and it gives you a lot of motivation to participate,

16:31.640 --> 16:36.640
and to put in work to keep this community great.

16:36.640 --> 16:41.640
And at some point, I stumbled upon a Kings Day speech of Gators,

16:41.640 --> 16:47.640
which one of the first link on his website, and it's a great blog post,

16:47.640 --> 16:52.640
if you want to get inspired again by a Venetian Python.

16:52.640 --> 16:59.640
So, we open source part, how did it help me to get into open source?

16:59.640 --> 17:05.640
And this, I think, it applies to any other kind of thing,

17:05.640 --> 17:08.640
that any other language that has a niche community.

17:08.640 --> 17:17.640
So, in a niche community, in a way it's easier to do the kind of open source that, as a naive person,

17:17.640 --> 17:22.640
I was many, many years ago, you tend to associate with open source,

17:22.640 --> 17:25.640
to create your own library, to do something,

17:25.640 --> 17:31.640
while then later I realized that many, many ways to contribute to open source.

17:31.640 --> 17:34.640
But let's say you want to contribute your library,

17:34.640 --> 17:37.640
and you have to come up with an idea,

17:37.640 --> 17:40.640
but for example, in a niche language with a small ecosystem,

17:40.640 --> 17:44.640
there are a lot of anti-pidia, and you can start something very easy,

17:44.640 --> 17:47.640
porting something that is another language to that language.

17:47.640 --> 17:52.640
It is useful or fun, another language to that language.

17:52.640 --> 17:57.640
Since I kind of liked the emoji, one of the first things that I did five years ago,

17:57.640 --> 18:03.640
if a library that created was a library to parse, string,

18:03.640 --> 18:08.640
and turn emoji codes into emoji.

18:08.640 --> 18:16.640
And another way, so, a niche community helps with coming up with ideas that you want to do,

18:16.640 --> 18:20.640
because in Python, every idea you say, okay, there's something else that is lying in.

18:20.640 --> 18:23.640
I can contribute to that, but it's not the same thing.

18:23.640 --> 18:25.640
So the other thing you need to code it,

18:25.640 --> 18:29.640
and you just initialize with the package manager,

18:29.640 --> 18:35.640
you code something, and then one of the other things that I like a lot about name,

18:35.640 --> 18:37.640
that the published command is something very, very easy.

18:37.640 --> 18:42.640
You type a command, and it opens a pull request on GitHub repo,

18:42.640 --> 18:46.640
that just adds few lines to a package is done JSON.

18:46.640 --> 18:49.640
Somebody manages that, and it's done.

18:49.640 --> 18:53.640
Compared to how, instead, a little bit more involved,

18:53.640 --> 18:58.640
is publishing a package with Python, I think it's a good bonus.

18:58.640 --> 19:04.640
I haven't yet made the trick to publish a Python package, hopefully soon.

19:05.640 --> 19:07.640
This kind still, kind of scary.

19:07.640 --> 19:12.640
So the bigger project that that was, that,

19:12.640 --> 19:19.640
an emoji thing, by the way, is something that I created that in one day on a Saturday,

19:19.640 --> 19:23.640
and a few days later, the guy who wrote the initial blog post,

19:23.640 --> 19:27.640
that I write on after news, put me star, and that film you with the video,

19:27.640 --> 19:29.640
although that star, that particular important,

19:29.640 --> 19:33.640
but that particular star was very, very important for me.

19:34.640 --> 19:37.640
Another project, instead, that I've worked through other years,

19:37.640 --> 19:40.640
also with friends in this project called Nimi Blunder,

19:40.640 --> 19:42.640
and the first thing is I show you.

19:42.640 --> 19:45.640
I tell you that I like interactivity.

19:45.640 --> 19:52.640
So this is a copy of something that I saw on socials,

19:52.640 --> 19:57.640
of a curve that looks like a firm, that you can change the parameters.

19:57.640 --> 20:03.640
This actually HTML page is something that is done with this Nimi library,

20:03.640 --> 20:07.640
and the source code for this is this many lines.

20:07.640 --> 20:10.640
You put this many lines of code into the library,

20:10.640 --> 20:15.640
and you create an HTML page.

20:15.640 --> 20:19.640
So it's actually, when you look back,

20:19.640 --> 20:22.640
something which is called literate programming.

20:22.640 --> 20:28.640
So interweaving, having code and text code and explanation of the code,

20:28.640 --> 20:36.640
and also output of the code, that are a tool that helps you put the two together

20:36.640 --> 20:37.640
or separate the two.

20:37.640 --> 20:39.640
It started with Donald North.

20:39.640 --> 20:44.640
And Nimi takes advantage of how Nimi syntax is very flexible,

20:44.640 --> 20:48.640
and takes a different approach from the standard literate programming of North,

20:48.640 --> 20:53.640
or even the more modern, interactive programming,

20:53.640 --> 20:58.640
like Jupyter Notebook, which was part of the inspiration of this.

20:58.640 --> 21:01.640
So it is a library that you import,

21:01.640 --> 21:05.640
and you produce an HTML like that.

21:05.640 --> 21:11.640
And you can do slides, then, because then you can add the different template,

21:11.640 --> 21:16.640
and this is also thank you for who the commentator of this library,

21:16.640 --> 21:18.640
and all this project.

21:19.640 --> 21:24.640
And at some point I realized, maybe I can, it also makes sense with Python.

21:24.640 --> 21:28.640
And so I have this project, which I've started working on,

21:28.640 --> 21:34.640
and it's not yet published, but it tries to do the same thing as a Python library.

21:34.640 --> 21:38.640
And it makes much less sense than with Nimi,

21:38.640 --> 21:41.640
but it still makes sense, so it's something that I plan to publish.

21:41.640 --> 21:46.640
And this is something that there is a repo,

21:46.640 --> 21:49.640
and it works like that. It does exactly the same thing.

21:49.640 --> 21:53.640
You have a code, a text cell, and a code block,

21:53.640 --> 21:59.640
and it creates the code block and it captures the output.

21:59.640 --> 22:06.640
And something else I've started experimenting is to integrate it with Python,

22:06.640 --> 22:10.640
because which is also a project I like a lot,

22:10.640 --> 22:15.640
and we will have a talk later this afternoon about that.

22:15.640 --> 22:17.640
And there is a way to interact.

22:17.640 --> 22:22.640
But this is something that APIs not there, there are a lot of problems.

22:22.640 --> 22:28.640
So, I think that sums it up.

22:28.640 --> 22:32.640
I'm very happy to have done this here in this place.

22:32.640 --> 22:37.640
It's my second time at Fossdom, and thank you for your attention.

22:37.640 --> 22:39.640
And she has questions.

22:39.640 --> 22:41.640
Happy to answer here.

22:46.640 --> 22:50.640
Thank you, Pieto, for your demonstration.

22:50.640 --> 22:52.640
Do you have any questions?

22:52.640 --> 22:54.640
Yes.

22:56.640 --> 22:58.640
Thank you.

22:58.640 --> 23:01.640
So, my question is, how good is the support with bindings?

23:01.640 --> 23:04.640
For example, I have a C++ library or a C library,

23:04.640 --> 23:07.640
and I want to be able to interface it with NIMM.

23:07.640 --> 23:09.640
To use it with NIMM.

23:09.640 --> 23:13.640
So, that part is really, really good, the FFI.

23:13.640 --> 23:19.640
So, because it's very, very easy to use a library.

23:19.640 --> 23:22.640
So, I show you the interoperability with Python.

23:22.640 --> 23:27.640
But, basically, for example, you have a C++ library.

23:27.640 --> 23:31.640
You annotate it with something that would be import CPP.

23:31.640 --> 23:34.640
And you can use it basically right away.

23:34.640 --> 23:37.640
Then there are also projects that automate the wrapping,

23:37.640 --> 23:41.640
especially with C++ and has been a lot of work.

23:41.640 --> 23:44.640
One of the most notable projects is,

23:44.640 --> 23:50.640
Juan Gomez was working on a wrapper of the Unreal Engine,

23:50.640 --> 23:56.640
and has really also smoothed out a lot of the experience

23:56.640 --> 24:00.640
of accessing to all kinds of C++ library.

24:00.640 --> 24:03.640
Unreal Engine is a game-changing,

24:03.640 --> 24:06.640
very big C++ project.

24:06.640 --> 24:10.640
And so, lots of projects there to do that.

24:10.640 --> 24:13.640
Performance wise, how does it compare, for example,

24:13.640 --> 24:16.640
GoLank, which assumes it is the same class?

24:16.640 --> 24:18.640
No, LIMM.

24:18.640 --> 24:22.640
Well, it depends about NIMM tends to be in the same class

24:22.640 --> 24:24.640
as last and ZIG.

24:24.640 --> 24:26.640
So, you don't have it, you don't have a floor.

24:26.640 --> 24:28.640
It's starting with the GC.

24:28.640 --> 24:33.640
Now, it has a red counting, so the memory management is something

24:33.640 --> 24:37.640
which injects initializer in the structure.

24:37.640 --> 24:43.640
You can also use it without nothing happening at runtime,

24:43.640 --> 24:51.640
and you'll have to manage pointers for references with the cyclic stuff.

24:51.640 --> 24:56.640
But there is no bottom at the type of performance that you can reach.

24:56.640 --> 24:59.640
And the expressivity makes it so that sometimes you can reach

24:59.640 --> 25:03.640
in an easier way faster speeds.

25:03.640 --> 25:10.640
So, there are projects that Mami Ratsimba has project for tensor libraries

25:10.640 --> 25:13.640
that have the most incredible steep speed,

25:13.640 --> 25:20.640
or crypto libraries that are used in Ethereum space.

25:22.640 --> 25:25.640
And if it fails, we'll get a stack trace or just segmentation fault.

25:25.640 --> 25:26.640
Sorry?

25:26.640 --> 25:30.640
If it fails, do I get a stack trace or segmentation fault?

25:31.640 --> 25:35.640
You should get a stack trace otherwise it's a compiler back.

25:37.640 --> 25:39.640
Another question?

25:42.640 --> 25:45.640
You mentioned portability as an issue with Python,

25:45.640 --> 25:49.640
but if NIMM is compiled, how good is your portability

25:49.640 --> 25:51.640
to different operating systems,

25:51.640 --> 25:55.640
or if you have libraries, are they statically linked in a sense

25:55.640 --> 25:58.640
that you can ship one executable without dependencies?

25:58.640 --> 26:04.640
So, the portability in the sense that you can create an executable.

26:04.640 --> 26:08.640
Yes, you will usually have the choice to statically compile the libraries

26:08.640 --> 26:11.640
or to use dynamic libraries.

26:11.640 --> 26:15.640
So, in that sense, it's portable.

26:15.640 --> 26:18.640
You can compile an executable and you pick whatever you want

26:18.640 --> 26:21.640
in terms of linking with the library.

26:21.640 --> 26:23.640
And in terms of different operating systems,

26:23.640 --> 26:25.640
it's supported all the main ones from scratch.

26:25.640 --> 26:28.640
And since it compiles to, and it's important,

26:28.640 --> 26:33.640
also other back-end targets of different kinds.

26:33.640 --> 26:36.640
But this is probably where I call in the fact that I'm data scientist,

26:36.640 --> 26:38.640
so I'm not supposed to know this kind of stuff.

26:40.640 --> 26:42.640
Okay, thank you. Thank you.

26:42.640 --> 26:43.640
Thank you.

26:43.640 --> 26:44.640
That's me in the theatre.

26:44.640 --> 26:46.640
Hello.