Pretty much full.
Okay, welcome everyone.
Reality.
Reality of small-headed programming.
We've been organizing this death room seven times now.
Yeah?
Yeah.
So it's obviously getting popular.
We've always had a full house.
But what is a small-headed programming?
It's a language that fits the brain, right?
And I think most, you know, reality of programming today is that most language is not fit.
That's definition.
Python doesn't fit the brain.
I have to programming Python.
I'm keeping, I'm being forced to look things up all the time.
I don't know about you.
But maybe open AI will help.
Rust definitely doesn't fit my brain.
C++, I've written hundreds of thousands of lines of code in C++.
It still doesn't fit my brain.
So, in contrast, the list in general, I find pretty accessible.
See, it's also a pretty nice fit.
As they go, it's a pretty nice fit when it comes to that.
So what do you want to have a language, right?
I want to be fast, really.
And I don't mean runtime, but I mean compile time.
So, dropping a repo, debug, that kind of thing.
I also want my code to be reasonably readable after a few years.
There's always that question.
And I don't like compile time-tracking.
You know, not really.
The strict typing and a letter, it's not for me.
But I sometimes I need it, right?
If you want to refactor something, it can be quite useful.
And I want few dependencies.
Well, they've had a pretty good sketch of that.
Another thing is that, you know, today's world,
people think that garbage collectors are evil.
I think garbage collectors are a great invention.
The time before garbage collectors was much harder.
But they also have, you know, they have, they have a few problems.
Stop the world issues.
So, you know, real-time programming is a problem.
Or the challenge.
You know, and there can be other things.
I think a Google estimated that the Python spends about half its time
in the garbage collector.
And so there's a lot of, you know, it's called death by object creation.
And death by object destruction.
It's not trivial, as Andy can tell you.
And rest does not have a garbage collector.
So, everybody thinks, oh, great.
I have to write everything in rust.
Right?
It's beautiful language.
But it does mean that you have to always think
in terms of how we deal with the memory.
So, three years ago, I gave a talk here.
I'm Gael and Zik.
It was a matter in fused talk.
You know, and it was an exploration.
You can look it up if you want.
And Zik is a minimalistic new language.
It's focused on performance.
I said three years ago.
It's blazingly fast, which is really nice, as a compiler.
I think the last line is also kind of important.
You know, why say me columns?
You know, it's cancer of the same colon.
We have language today, and they offer them from same columns.
I don't know why.
But what really happened is, you know, I wrote a piece of code in Zik.
In a sort of general purpose piece of software that is used by a lot of people.
And, you know, once I've written a Sik, you think, okay, I can deploy it.
And people can use it.
But Debian didn't accept Zik into the distribution.
And it still hasn't happened.
Right?
And the problem is the bootstrap.
And so what happens is that people initially write a program language and see
or something or see++, which is fine.
You can compile it at any time.
But then they go to self hosting.
So it's a Zik compiler.
They wrote Zik.
Because Zik compiler in Zik.
Right?
And the same happened with the Julia.
They wrote the Julia compiler in Julia.
Or most of it.
And Zik and it's an incredible wisdom created the bootstrap in
Repassembly.
And so basically, they say, okay, you know, here, here's our
Repassembly blob.
This is your bootstrap.
And we don't really know what's in the blob.
Right?
So for Debian, that's not acceptable.
They want to be able to build that blob.
And Zik is a small language.
It's a small community.
So nobody paid attention to it.
And it never got into Debian.
But recently, Giggs managed to get the
You know, Giggs bootstrap.
So they basically built the web assembly blob from C.
And it's a path for Debian now too.
So it will come soon, I think.
Yeah?
But what really happened is when I started programming in Zik and
Rodi's general purpose tools, people said,
Why Zik?
You know, this is a new language.
It's not going to be supported.
It may die in a few years.
Right?
So, you know, all types of reasons for doubt.
And you know, and then it didn't get accepted in Debian.
And I had no story to tell.
So I complained a lot.
You know, it's on MasterDone.
You can track it.
And now we have it.
Okay? So we're good.
Yeah?
Ten minutes.
You mean ten minutes for the full talk?
No, for a quick question.
Okay.
But time moves on, you know.
And our target is actually a high performance computing.
And the same can be argued for low-end computing
for embedded systems.
Right?
These allow Zik at the moment target is the LVM.
And, you know, it's a, it's a large tool chain.
And you don't even get it on HPC.
Right? HPC tends to have all the distributions on there.
You know, like CentOS from four years ago.
And they cannot upgrade because then, you know,
the whole cluster will have to be upgraded.
And people get confused and all that.
So, and you cannot just install software on these HPC systems.
So, Zik is hard for that.
You know, this language is, and I started to move slow
towards thinking about transpiler.
So, if you have a C transpiler, you can always have a C compiler.
Yeah? On any system, practically, today.
So, let's look at those options.
And C, C, on transpiler,
that have, don't have garbage collectors.
For example, a Nim.
And we have a talk of that, of Nim later today.
Pre-skim and chicken lately.
Why don't we, you know, in this particular case,
once, why don't we avoid the garbage collector, right?
It's because mostly because we want to link against other languages.
And so, if you want to link against garlic,
if you have two systems with two different garbage collectors,
it can get quite upbeat.
The other things that nice output matters.
So, let's have a quick example.
This is pre-skim.
So, if you want to call a C function, right?
So, for example, to convert the flow to a string,
right? This is a typical C function.
Yeah, where the output buffer is as fast as a parameter.
And we write it in a pre-skim.
It looks like this.
And so, it's essentially a mapping.
And you can call that function, right?
It's a function that says, okay, transform this number.
Yeah.
And what it does, it translates to C.
And the C code is actually shorter than the list code, right?
And it's completely readable.
Yeah, so, that was a start.
And then I started looking at CnD,
because we want to have a vector type of optimization.
So, modern CPUs, they support AVX and
SSE in a lab.
This is a library here, which is essentially a whole bunch of
complex C macros.
Right?
And it also allows you to run AVX instructions on a non- AVX CPU.
Yeah, so, it's kind of interesting.
What does it look like?
Right? So, you have an instruction here.
So, you map to it.
So, it's the CnD instruction here, right?
And here, I make a vector, which is pre-allocated,
and I'm pushing the numbers in.
Of course, you can do it in a nicer way,
but this is just for the demonstration.
And then, I call actually the CnD functions, right?
In Lisp and pre-skim.
Yeah, so, it looks all very, very, very doable.
And this is the code, it generates, again,
it's shorter than the list code.
Yeah, so, these are macros.
So, pre-skim doesn't really care, you know,
whether you're calling a real C function or a macro.
Yeah, it will expand the C compiler, we'll do that for you.
Yeah, so, it writes beautiful C.
You can write, it has support for both scheme macros
and C macros.
And the strings and vectors, they actually use Malacone free, right?
So, let's look at another language that does this.
Name is a Python type language, at least the syntax is Python type.
And it also transpires to C, and, you know,
alternatively it can transpires to JavaScript, so people like that.
And this is what it looks in NIM, you know?
So, it's a closer, actually, to how you would do it in C.
But when you look at the transpile code, it's actually, you know,
there's a lot of, I mean, I'm just showing the best of, you know,
this is the central part, but it actually has a lot of additional.
Yeah, so, I would argue that the C that's written by NIM is actually
not for human consumption, though you could, you know?
And it's its competitors, you know, you can actually read it,
and you can grab through it and all that, so you can see what is happening.
But it's not really accessible.
It does the same thing with the C macros.
And unlike a priest scheme, which you have to use Malacone free,
it uses a form of reference counting, which is also five minutes for questions.
I'm almost done.
What an nasty thing about NIM is that it actually writes the C code
into a cache in home.
So, it doesn't, it's a pre scheme, it's sort of a direct mapping,
you have a list code, and it will generate the C code just as a file,
and then you can compile it.
With NIM, it's sort of hidden away from the user, though you can still find it.
Chicken came up, I mean, after NIM has funded the work
to modernized pre scheme, which is happening.
Chicken scheme, which is also a transpiler, to see,
also came up with a garbage collection, a version that's free of garbage collection.
I haven't looked at it yet, but I think it's very nice that people said
to think this way.
NIM and ZIG itself can also transpile to C apparently, it's very ugly,
but if you're still inclined, you can do that,
and you can compile it on your FPC.
So, the conclusion, for me, NIM is going through his exercises,
that the pre scheme is light, hackable, and generates light weight,
see output, and it's mapping to low level, it's really good.
NIM is cool, chicken is cool, so you can look at these things,
and I want to thank Andrew Watson, who is Australia-based,
to work on this, and the NIM for working on this project too,
so I have a funding it.
I can just show you quickly the actual code.
Let me see where I'm going.
So, if I take a full program, it does the float conversion,
and then it calls it Cindy stuff, right?
And then it creates a generous output for you, right?
It's a really neat little program.
And when you call this pre scheme compiler, it will generate this C code,
right?
So, it loops a little bit less accessible, but it's still digestible, right?
So, you can see this Cindy instruction in here.
You can see the printing of the string here.
And I'll show this works, but let's try.
So, I build the scheme to see translation,
and then I compile the C, and then I execute the code,
and these little scripts, right?
And this is what it does.
So, and we are going to push these into production types,
that's for sure.
Thank you.
Any questions?
No?
Yes?
Was that the question?
It's not a question.
Okay, it's awesome since Dave.
Thank you.
Yeah?
I think that regarding the end of the conference project.
So, in the past, it's probably some both code,
non-models, perhaps, so to which one are you referring to or which one.
I don't know.
Yeah, so the question is which, I mean,
name has different models for dealing with memory, right?
Yeah.
So, you can actually select whether you want to reference control or not.
So, I haven't tried it, but what you really doing,
when you're transpiring to see is that we'll use the reference control model.
Well, well, those are my other things.
They're separate from each other.
Like, the preference that memory model name uses is a separate decision.
So, you can choose, right?
Yeah.
It's not an answer, but yeah, you can choose.
Yeah.
The question is, when you say, when you transpile the C,
it is reference.
Yeah.
So, the original version of name was the garbage collected.
Yeah.
So, they transpile to C, and then it was garbage collected.
And then later they switched completely to a reference model, right?
So, that's what you get.
But you can select either.
Yes?
How do you get the program that you want to see?
How do you debug a program that what?
It's transpile to C.
You get C.
Yeah.
So, that's why it's important that you get, you know,
so this is one-to-one mapping from one language to the other.
Right?
So, you can easily, that.
I mean, if you know the C program is going to be hard,
but if you can do C, then you can debug.
Yeah.
For example, the output of Priske, it's a label,
and verbal text.
It's not so bad, if when you get into it.
It's mostly naming, right?
I mean, it's a...
Yeah.
So, I had a variable named B, right?
And it's as if for X, you know, to have the...
You know, it's...
Do you see not get confused, essentially?
Priske has a one-to-one mapping of the language.
Yeah.
Pretty much.
Yeah.
One more question.
There's one, what?
Yeah.
Okay, yeah.
This also, that's...
First question.
Is it just to acquire a scheme for you?
Yes, at this point it does.
Yeah.
So, the NLNet project is actually to transform a two-guile,
which is a more modern implementation of scheme.
Yeah.
Question?
What if your program in runtime wants to compile, say, a lambda?
So, lambda is actually supported in Priske.
Yeah.
So, I don't know how to do it, but...
Yeah.
So, have a look.
Well, yours.
Okay, here's one.
You have to repeat the questions.
Yeah.
I don't like this one.
Oh, you were next video.
Yes.
I'm next.
That's why I was...