WEBVTT

00:00.000 --> 00:17.880
All right, what comes now is the very first talk of a centuries-long upcoming new tradition,

00:17.880 --> 00:24.440
and that is having August 68 presentations in this death room here and all over the world.

00:25.160 --> 00:31.000
Well, it's not the first presentation all over the world, but at first, I may be the first presentation

00:31.000 --> 00:37.640
ever about August 68 on first and ever, and it's not for say it's you, yeah.

00:39.960 --> 00:41.640
Yeah, we're doing a funny thing here.

00:41.640 --> 00:46.920
Originally, we meant to have introduction to August 68 before the actual use of August 68.

00:46.920 --> 00:48.280
Now, we're doing it the other way around.

00:48.280 --> 00:54.360
We first show a use and then, for say, afterwards, can go into some of the details of the language,

00:54.440 --> 00:55.960
an implementation, of course.

00:55.960 --> 01:02.360
Yeah, anyway, we have Mohammed Rizan Abibur coming up and educating us or showing an example of

01:02.360 --> 01:07.480
use of the GCC August 68 implementation on a bare-map old target.

01:13.480 --> 01:15.080
So, briefly, for this summer.

01:16.760 --> 01:19.560
So, hi, let's get into it.

01:19.560 --> 01:25.880
So, do not criticize my slides by the way, no, this is VIM, and this is fine.

01:26.600 --> 01:32.120
So, this is a demo tank, okay, meaning that I'm not selling anything.

01:32.120 --> 01:35.000
It's just random guy talking about August 68.

01:35.000 --> 01:37.480
It's your decision to use August 68 or not.

01:38.440 --> 01:42.120
People can make wrong decision, bad decisions, it's up to them.

01:43.000 --> 01:43.560
Oh, no.

01:44.200 --> 01:47.160
Okay, it's Ubuntu's bad decision, I hate it.

01:47.160 --> 01:51.800
Okay, so, but that's how I'm just here, just talking about things.

01:51.800 --> 01:54.600
It's a beautiful thing, so I just want to shape my experience with that.

01:54.600 --> 01:56.440
It does it, okay, nothing more.

01:56.440 --> 02:04.120
If you want more, like talk to Jose, okay, and okay, why I'll go 68?

02:04.120 --> 02:06.120
Because it's a high-level power, God.

02:07.560 --> 02:11.640
Because it's a high-level programming language, okay, we like high-level.

02:12.200 --> 02:15.320
And I hope you use this old technology, it doesn't, okay.

02:15.320 --> 02:19.080
So, if we classify, this is like just a random classification.

02:19.080 --> 02:24.280
If we classify program languages, we can say, okay, there are two macro-assemblers,

02:24.280 --> 02:25.800
and high-level programming languages.

02:30.120 --> 02:32.520
For macro-assemblers, it's useful for systems programming,

02:32.520 --> 02:33.880
because you have the control.

02:33.880 --> 02:35.560
What's a macro-assembler?

02:35.560 --> 02:39.720
You write some code, and you kind of know what kind of code it's built generated.

02:41.000 --> 02:43.560
This is amazing when you need this control.

02:43.640 --> 02:47.560
If you're developing systems software, you need this kind of control,

02:47.560 --> 02:49.720
and my control is wrong.

02:51.400 --> 02:54.120
Okay, yeah, write control.

02:54.120 --> 02:58.440
So, as you can see, sometimes control goes wrong, and you know, oopsie doopsie.

02:58.440 --> 03:02.840
But, and example of these macro-assemblers are C and BLEASE,

03:02.840 --> 03:06.840
which is an interesting, like older-than-C language,

03:06.840 --> 03:11.000
which has one more feature than C, which is, you can have,

03:11.960 --> 03:13.960
what's the name?

03:13.960 --> 03:17.000
You can have root core routines, and then you can say,

03:17.000 --> 03:18.840
okay, jump to this with this stack.

03:18.840 --> 03:21.560
So, you define, so, that's a very cool one, but it's typeless,

03:21.560 --> 03:23.400
so, and also, we don't care about those things.

03:24.200 --> 03:26.840
And we have like high-level program languages, which is like,

03:26.840 --> 03:30.200
when you want to solve a problem, and the language doesn't want to,

03:30.200 --> 03:32.040
you know, get into your way to solve in your problem.

03:32.040 --> 03:33.400
You want to focus on your problem.

03:33.400 --> 03:34.600
DSLs are just kind of things.

03:35.560 --> 03:39.800
Algo 68, go sweep Python JavaScript.

03:39.800 --> 03:41.960
These things are like, you want to solve a problem,

03:41.960 --> 03:43.240
and you don't care about details.

03:43.240 --> 03:46.520
You just want to something that doesn't allow you down your thinking.

03:46.520 --> 03:48.280
So, these are useful for these kind of things.

03:48.280 --> 03:53.080
And some of them are even, very useful to do production quality things,

03:53.080 --> 03:57.080
and some are not, but still used in production.

03:57.080 --> 04:03.880
Looking at JavaScript, but, so, so, so, okay,

04:04.040 --> 04:08.440
well, about raw Stnc++, well, they're pretending to be high-level,

04:08.440 --> 04:10.760
well, being a macro-assembly, and that's a disaster,

04:10.760 --> 04:14.600
because, you know, the rule, like, one very bold feature of things,

04:14.600 --> 04:19.480
is like, there are rules, but, but, but, but, but, like, okay,

04:19.480 --> 04:22.600
okay, this is feature of the, because they are merging

04:22.600 --> 04:25.960
melting to the two walls that are like, not very compatible.

04:25.960 --> 04:30.040
Like, oh, if you do this, R and R, V, O, in St++,

04:30.040 --> 04:33.160
we'll kick in, and you will not, you know, make a new copy,

04:33.240 --> 04:35.320
if they do the copy-election, like, fuck you.

04:35.320 --> 04:37.800
You know, it's, it's not simple, you know, it's not simple.

04:40.440 --> 04:42.040
But, you know, you're a bit pretent to be,

04:42.040 --> 04:45.960
think, so, I think this is duplication, okay, oopsie doopsy.

04:47.320 --> 04:50.840
So, okay, example of differences, okay, for example,

04:50.840 --> 04:53.320
in that class of learners, this is a difference, okay,

04:53.320 --> 04:55.960
this is a difference, and in a macro-assembly optimization

04:55.960 --> 04:57.320
is cherry on top of the cake.

04:57.320 --> 05:01.240
You get what you want, but it's nice, you know, you get more out of that.

05:01.320 --> 05:04.280
In high-level program languages, you have to do it right,

05:04.280 --> 05:08.360
you know, all the pain goes to the compiler writer to get it right,

05:08.360 --> 05:11.160
with, with, or if you say, like, it's not important,

05:11.160 --> 05:15.000
but it's a big cherry, this we can agree on that top part.

05:15.000 --> 05:19.800
So, for example, I was 68, it's so simple for the user,

05:19.800 --> 05:22.200
the amount of constructs you have for the user is simple.

05:22.200 --> 05:24.920
You have this very, very minimal thing, and everything works together,

05:24.920 --> 05:26.680
as they call it, or for one-ality.

05:26.680 --> 05:29.000
But the problem is, like, it's horrible for a compiler,

05:29.000 --> 05:31.480
but we don't care, we are using a Jose's problem, okay,

05:31.480 --> 05:33.480
he will figure it out.

05:33.480 --> 05:36.680
And if it doesn't work as expected, we can use it, you know,

05:36.680 --> 05:37.480
and only him.

05:37.480 --> 05:41.400
And just, well, it's kind of fun, sorry Jose.

05:42.600 --> 05:46.200
And then the other thing is like, in macro-assembly, as I said,

05:46.200 --> 05:49.320
you know, you kind of know what kind of code you want to get there,

05:49.320 --> 05:53.400
but for example, in the agostics, everything is value semantics.

05:53.400 --> 05:55.960
So, it's the job of the compiler writer to

05:56.040 --> 05:57.800
light the copies, which are not important.

05:57.800 --> 06:00.040
So, it's very important to do this kind of thing.

06:00.040 --> 06:05.960
But it's, look, algal 1968, that is semantics.

06:05.960 --> 06:10.040
20, 20, far, c++ value semantics.

06:10.040 --> 06:15.560
So, it's like, they, okay, then there's simplicity,

06:15.560 --> 06:16.760
everything works which is each other.

06:16.760 --> 06:20.280
You can, you can pass, there is no, if, but this kind of things,

06:20.280 --> 06:22.680
you know, if you want to get this, if you do this, this is better.

06:22.680 --> 06:25.640
There is no such thing, you write your program.

06:26.440 --> 06:31.240
algal 1968. Okay, this part caught my eyes.

06:31.240 --> 06:34.840
This identity declaration. Like, you know, you, you look at the thing,

06:34.840 --> 06:37.240
you know, for a while looking, you don't figure it out.

06:37.240 --> 06:39.880
And you know, oh, you see something, you know, there are

06:39.880 --> 06:43.240
futures with that thing that you, you know, it starts, it's clicks.

06:43.240 --> 06:47.400
So, now, there, that thing, for me, was, um, identity there.

06:47.400 --> 06:52.680
I read like 80 page out of 230 pages of this informal

06:52.680 --> 06:55.560
introduction. So, maybe there are more things after that,

06:55.560 --> 06:58.440
maybe I love something, but till now, this is the best part.

06:58.440 --> 07:02.440
This is the best thing. And, uh, hopefully, okay.

07:02.440 --> 07:04.040
So, what's identity declaration?

07:04.040 --> 07:09.000
Um, so this int i equal 1 real pi equal 3.

07:09.000 --> 07:13.400
This is the clearing, um, so here is the identity.

07:13.400 --> 07:15.720
So, I and one are the same thing.

07:15.720 --> 07:18.040
They are not a variable or anything like that.

07:18.040 --> 07:22.120
Okay. Um, uh, so everything is like, look familiar.

07:22.200 --> 07:25.800
But they, they, they, they, they, they, they, we're part is here for for

07:25.800 --> 07:33.160
see, don't do that. Uh, is this, you can not, uh, you can not do

07:33.160 --> 07:38.120
this kind of things, you know, if you say i becomes too,

07:38.120 --> 07:41.800
it's as, as, as meaningless as this thing, which is like,

07:41.800 --> 07:43.800
nonsense, okay. So, this is, you're, you're, you're

07:43.800 --> 07:46.520
declaring identities, like the same thing.

07:46.520 --> 07:50.600
It's, it's like, these, i and one and three point these are like,

07:50.600 --> 07:54.520
living in the, you know, mathematical real, not in the,

07:54.520 --> 07:59.560
on the, on the machine to some, to some, uh, the, we still.

07:59.560 --> 08:06.120
Oh, my, okay. So, what, if you do this, very, very similar,

08:06.120 --> 08:08.680
you know, I don't, I remove the equal to something, you know,

08:08.680 --> 08:11.960
this, in the sea, because the initialization, but this is not that.

08:11.960 --> 08:17.160
So, here, this is a syntactic sugar for variable declaration.

08:17.160 --> 08:20.520
This is a variable declaration. And then you can do this kind of things, you know,

08:20.520 --> 08:24.520
i is one and the point is that thing.

08:24.520 --> 08:27.960
And then later you can change something else, because it's a variable, you know,

08:27.960 --> 08:33.480
you can change it. It's not the, uh, so, but, uh, so what actually happens here

08:33.480 --> 08:38.360
is this int i is actually, uh, a syntactic sugar for this construct,

08:38.360 --> 08:43.960
which means that which, which is that i is a reference to int,

08:43.960 --> 08:46.360
and what's the content of their reference,

08:46.440 --> 08:50.600
allocate something on the, uh, these are generators.

08:50.600 --> 08:57.400
So, allocate this an int for me on this deck and put that, uh, you know, put that

08:57.400 --> 09:04.760
address address in this for this reference. So, I didn't do anything, okay.

09:04.760 --> 09:08.760
So, uh, that means that by the way, if you have a question, you can interrupt me.

09:08.760 --> 09:12.040
I don't mind if you do that, and I don't, I hate the question at the

09:12.040 --> 09:15.320
and definitely do not make two the question. I have a bunch of things.

09:15.320 --> 09:21.000
So, uh, and here it's like very beautifully, uh, which, like, for, like, what is the type,

09:21.000 --> 09:26.440
they call it mode? What's the mode of eye here? It's reference, not int, because it's in

09:26.440 --> 09:32.840
name to something else, which leaves on the stack, and here is unreal. This is, like, awesome.

09:32.840 --> 09:37.080
I mean, I don't, I appreciate they did this, but I always in my mind translate this to this,

09:37.080 --> 09:44.520
and like, oh, man, this is beautiful. And, uh, you can also do this. Uh, uh, you can,

09:44.520 --> 09:49.160
you can put this lock here. Meaning that, okay, put it, uh, as again, syntactic trigger to,

09:49.160 --> 09:53.560
to make it clear that this is allocating on the stack, not, uh, somewhere else.

09:54.760 --> 10:00.920
And, uh, and you also can have the heap. So, you can say, okay, put it on the heap.

10:01.000 --> 10:08.520
heap is somber, which is, you give, somehow manage the memory, um, for example, garbage collection.

10:09.800 --> 10:15.960
It's a one implementation, but it's just, the day the reap, okay, oh, I have the report by the way,

10:15.960 --> 10:21.320
you know, it's like, important. This is Bible thing. I cannot read it yet fully, because it's complicated,

10:21.320 --> 10:29.320
but I'm working on that, yeah. So, uh, so, uh, any question for the identity declaration that

10:29.400 --> 10:34.760
and that's the most beautiful idea of, like, this, you, this, this, this, like,

10:34.760 --> 10:40.680
please, you from this, see mindset of, like, int, exist, you. Is it actual? Yes, it is, it works.

10:40.680 --> 10:46.920
I will show the actual code, and it will compile, hopefully. Uh, so, if you want, I tested before,

10:46.920 --> 10:56.520
the time. Well, who knows? Uh, so, uh, if you want to build, uh, uh, for x86 is simple, you just say,

10:56.600 --> 11:03.800
okay, I lose 68 and I want to put it there. Done. But this note is not about x86, who cares about x86.

11:03.800 --> 11:10.760
Let's talk about arm, okay. Uh, so this is very metal arm. Uh, who's a headset, but I don't know.

11:10.760 --> 11:17.240
It's the dominant thing. Uh, so, you have to apply a bunch of patches, which gives you this,

11:17.240 --> 11:21.560
which I send it the initial draft to the mailing list, but it's still not in master,

11:21.560 --> 11:26.840
because he asked for more test and stuff like that, like, man, come on. But, uh, with me,

11:26.840 --> 11:30.600
I have to do that. So, uh, these are the most important. So, you, you, you, you, you, you, you, you,

11:30.600 --> 11:32.440
you, you, you, you, you, you, you, you, you, you, you, you, you, you, you, you, you, you, uh,

11:32.440 --> 11:36.440
prelude, because there is no live, see, like, or even there, don't do that to me.

11:38.440 --> 11:42.760
And then there is this, uh, algal, and then, you know, target, and this, like, uh,

11:42.760 --> 11:48.120
built for the, uh, the, the, our real time, and m is the, uh, microcontroller profile. So,

11:48.200 --> 11:52.360
everything, it's, like, give you 10 or 20 different combinations of, uh,

11:52.360 --> 11:56.920
lip GCC, and stuff like that, and you disable basically everything, because, you know, like,

11:56.920 --> 12:03.240
it also, algal, 60 GCC, which is the boom GCC, which is, like, interesting kind of GCC.

12:08.600 --> 12:14.920
Because I don't like it, just lags on me, like, okay, but this is, this is, this is,

12:15.000 --> 12:20.840
I'm not a GCC developer, he is a GCC developer, so I like, I don't like, warning is there,

12:22.440 --> 12:28.440
and, and so that, that's also for risk five, uh, you can do the same, and I, I will show you also,

12:28.440 --> 12:33.320
example of this risk five thing. So basically, basically the same, this, this, this, but you

12:33.320 --> 12:38.360
have to change this to this, and you don't have those madness of our improv, I think. So,

12:39.000 --> 12:54.360
any questions so far? What? Somebody said, nobody, you should not use, so in, in the,

12:54.360 --> 13:00.200
I don't even provide the malloc. And it is, this is a different mindset, you know, it's, in, in this,

13:01.240 --> 13:08.120
what? No, yeah, because it's, okay, for microcontrollers, you want determinism at the maximum,

13:08.440 --> 13:12.760
so if you, even want to do heat allocation, you have to do it like in the first part of your

13:12.760 --> 13:16.440
initialization part of the thing, and then the main loop you never do any allocation, because

13:16.440 --> 13:21.080
you want to be sure that your, your, everything is deterministic happening at the right thing. So

13:21.080 --> 13:25.800
he is a bad thing, and the, the leader will yell at you a little bit, it's my mother, there is no

13:25.800 --> 13:30.600
method to do it. Uh, then you have to change the construct, uh, for the, for the, for the,

13:30.600 --> 13:36.840
it's a kind of pain, I will show you the pain part, but, you know, let's focus on the, you know,

13:36.840 --> 13:44.360
quit part, and other questions so far? No question, I love no questions. So, um, the idea was, okay,

13:44.360 --> 13:50.200
we have this hardware, which I have in my back, but I forgot the fucking cable to, to do the

13:50.200 --> 13:57.240
life, but it's a different story, it doesn't matter. It's a, it's a arm board, it's a Cortex M33 board,

13:58.360 --> 14:04.760
which we use to, to compile things. I can, even, so, um, I, I don't use Mx, but because, thanks to

14:04.840 --> 14:08.760
Jose, there is syntax highlighting, I know everybody likes Hindu syntax highlighting, I don't

14:08.760 --> 14:15.960
use it, I don't see how I'm, I'm using this thing. Okay, so, I love you, I, you can see, I, you know,

14:15.960 --> 14:20.760
even enabled this syntax highlighting for you. Uh, so here you can see that, there is,

14:20.760 --> 14:26.760
don't do it. Is it like there's a line or something, is this line is important, I guess?

14:27.240 --> 14:34.520
So, this, this, this M33 and M thumb are like this is the, the, the model for the things,

14:34.520 --> 14:42.040
and I, I, I, I using this noses, so nose, nose, and I have also no built in, uh, uh, uh,

14:43.160 --> 14:49.240
there is also here. There should be no lips. Ah, okay, here you can see that I commented the

14:49.240 --> 14:56.600
lips is so, there is no lips. Um, but you have to link the GCC and, uh, uh, run time of the, uh,

14:56.600 --> 15:00.600
uh, you know, I'll go. So, that's that thing. Uh, so the question is,

15:02.440 --> 15:09.720
we start from C, okay, we have this, uh, C function. You have to first, uh, define, uh, you know,

15:10.520 --> 15:16.840
here, this is the, I'll go 68, uh, uh, uh, function, you know, this is the thing you have to

15:16.920 --> 15:22.040
control. So, this is the start of, this is before main. So, we have to call the main of the C program

15:22.040 --> 15:28.200
or I'll go 68 program. That, we are there. That, it means like C runtime. Uh, so, uh, you need the,

15:28.200 --> 15:35.400
from the linker's script, you need this, the, the, the, uh, the stack, uh, range, and then here is the,

15:35.400 --> 15:42.280
uh, uh, ISR. So, you have to specify a bunch of based on the arm, uh, specification, you have to put

15:42.440 --> 15:47.160
function pointers in the right place and also initial stack pointer. So, what happens is,

15:47.160 --> 15:54.200
how this reset ISR is important. So, if you go down here, so this is like data, uh, initialization

15:54.200 --> 15:58.840
BSS, you know, putting to zero, this kind of thing, they have to do it ourselves, uh, a bunch

15:58.840 --> 16:05.160
of other things. And then, finally, because we initialize all the variables to zero or to

16:05.240 --> 16:11.320
predefined value and then we call the angle, uh, 68 main which goes to this program dot things.

16:11.320 --> 16:18.920
So, um, access board, board is a module in a sense of the angle 68. And, uh, so we have here,

16:19.640 --> 16:26.280
uh, this is a, um, uh, uh, at the point. So, we are, uh, dealing with the C. Uh, so you see,

16:26.280 --> 16:32.920
uh, you say this is my procedure, which gets bits, bit, bit to the translation to the, uh,

16:32.920 --> 16:39.960
C-world is unsigned in it. They, because for them, bits are not integers, integers are always signed,

16:39.960 --> 16:47.080
beautifully, and, uh, uh, uh, bits are a bunch of bits. If you go to languages, uh, from

16:47.080 --> 16:50.600
Nicholas, we'll, for example, they also have this set concept in upper room in,

16:50.600 --> 16:55.000
Pascal, I even think they have it. So, that's that mindset. So, this is bit, sorry,

16:55.000 --> 16:59.960
area of points, which is in C, translated to unsigned bit. So, it's a procedure, which takes one bit

16:59.960 --> 17:07.080
and returns bits, and this is a procedure, which gets two bits, and, uh, sends nothing. So,

17:07.080 --> 17:13.560
read word, I want to read, I want to do the memory map, I owe. So, I say, okay, use this function

17:13.560 --> 17:20.360
and declare it as this, uh, I will succeed a procedure, and this, uh, so, where those things are

17:20.360 --> 17:29.800
defined, namely, oh, let's see, here. So, uh, that's it. So, I need, uh, I don't know how to

17:30.040 --> 17:36.120
yeah, this is. So, MMIO, uh, you see, I'm using unsigned int unsigned int address, and I'm

17:36.120 --> 17:41.800
using this cast, I want to read, like, I want to deal with the memory map, I owe to, okay, uh, to

17:41.800 --> 17:45.800
read the stuff, read the stuff, read the stuff like that, and, or I want to write something there.

17:45.800 --> 17:51.320
So, this is the address, and I want to, uh, do, do the writing. Any questions so far, Arson?

17:51.320 --> 18:04.840
Okay? I don't care about this, you know, seriously. We are not see for this class, okay?

18:04.840 --> 18:09.640
Uh, okay, you can, one, insurance, I think it might not be a problem.

18:09.640 --> 18:14.920
Of course, you should not, but maybe you'll see how the different opinion, but, yeah, so,

18:14.920 --> 18:19.880
well, why do you need an FFRC in the part to do this kind of reason, right? So, memory, why can't you do it with

18:20.200 --> 18:24.520
because alcohol, there is no address, like volatile stuff, or writing, writing, this kind of thing.

18:25.720 --> 18:29.000
You, you, you, it's not a macroson, exactly. You're not listening, shall I? What the fuck?

18:31.800 --> 18:33.240
I'm not a salesperson.

18:37.160 --> 18:45.000
Somebody add something? Yeah, I mean, you have to use a macroson there to do your macro system to stuff,

18:45.400 --> 18:50.040
but this is a shame later, and that's all the C code you have, based besides the runtime,

18:50.040 --> 18:57.720
and everything else is a fuck. This thing, so we have this, we get this over thing, and then now

18:57.720 --> 19:03.160
we have a procedure, for example, uh, this, this fund, so I'm just going through this, I have only five minutes

19:03.160 --> 19:10.040
that's very sad, but this is the, uh, denotation for the bits, so it's, you can not have it, like,

19:10.040 --> 19:14.040
bits equal to one, so it's a different thing, so you have to use the base to be support,

19:14.120 --> 19:21.240
or algo 60 support, 2, 4, 8, and 16, as basis, there is no base 10 because that's not 10, you know,

19:22.840 --> 19:30.680
but it's not, I mean, it's not an inch, uh, so or, uh, you, so this is a operator, like, bitwise

19:30.680 --> 19:35.560
operator, so this is a comment, so this is also using a modern, uh, algo-strupping, which I

19:35.720 --> 19:41.880
also will talk about, and then, uh, you're, uh, you know, and apps is going from the bits

19:41.880 --> 19:48.600
real to inch real, so the value, because I wanted to plus it with this integer, which is this int,

19:49.240 --> 19:56.120
and it's like this, and then, uh, then I'm writing to the word, I have to turn it back to bin,

19:56.120 --> 20:04.440
as to get bits, and then this is the shift left, so it does the, uh, one, I like base 16,

20:04.520 --> 20:09.400
so I use 16, you can use whatever, base 2, for example, but one, not 16, and then bit shift that,

20:10.520 --> 20:19.320
so, uh, here, uh, this is a color-colour-colour-colour, it's this syntax, not standard, 16,

20:19.320 --> 20:24.840
far zero, close that, he wrote it, I don't know, I don't know, I don't use syntax, I like it,

20:25.800 --> 20:33.480
yeah, that is, that values, uses a different color, and the other layer, the photo, so this is,

20:33.480 --> 20:41.800
this is the, this is the, this is the speaker, fix it, and you know, people are not happy,

20:44.840 --> 20:50.520
so, so here, this is a helper function for, you know, we get a bunch of addresses, I'm using it,

20:50.600 --> 20:57.720
in summer, and I'm just like, okay, this is also a beautiful thing, okay, I think I'm so close to be,

20:57.720 --> 21:02.280
okay, so here I'm calling this function addresses, and I'm giving an index to that, it gives

21:02.280 --> 21:08.840
me the address of that thing that I asked for, which, for example, don't, I have an example,

21:08.840 --> 21:17.000
so here, you see this parenthesis, this is a close-clouse, or, uh, so you all close, I guess,

21:17.000 --> 21:22.280
okay, no, so close-clouse, which is like, okay, this is a declaration, and then this is,

21:24.520 --> 21:31.560
this is, if the short form of, if, so if address is not zero, uh, read that, otherwise,

21:32.360 --> 21:38.440
return zero, this is like this, it else is always, there is this thing, a skip, like in,

21:38.440 --> 21:44.040
you know, it uses the default value, you want to have an antibody for a function, put a

21:44.040 --> 21:48.280
skip there, you want to, int, you don't want to value, put a skip there, you want anything,

21:48.280 --> 21:52.680
you put a skip there, and I hear, put a skip there implicitly, so it's like a third,

21:52.680 --> 22:01.400
way of saying this, this thing, uh, here busy-vades, because of course, you know, and, you know,

22:01.400 --> 22:06.200
you want to, you know, wait your time there, so I'm, I'm accessing this memory from C,

22:06.760 --> 22:11.960
and just writing to this memory, because it's across the boundary, the compiler can not optimize it,

22:11.960 --> 22:20.280
also, it feels just for some time, give me a simulation of bait, uh, and then this is, uh,

22:20.280 --> 22:26.680
this is, uh, I don't need to go there, I have a cursor, so, uh, here, uh, we can,

22:26.680 --> 22:31.240
define a variable sleep, which you can then assign the procedure, which is a value to this thing,

22:32.360 --> 22:37.320
and, uh, uh, I wanted to have two different things, you know, but then like, okay, it's not that

22:37.960 --> 22:43.000
much time off, exactly. And then just, just let me blink the LEDs, and then everything is fine. So,

22:43.000 --> 22:49.960
here, here we have the, for, um, here we have some registers, you sleep, you write the, um,

22:49.960 --> 22:56.120
to this GPIO, that okay, the value, like, put a bit on the GPIO that you want to blink,

22:56.120 --> 23:01.320
explore, you know, just, uh, switch between them, and the blue, so, if I was a little bit

23:01.320 --> 23:05.160
wise to have some video or something, I'm not wise, I don't have anything, just trust me, bro,

23:06.120 --> 23:11.240
this means, so, and then there is nothing for a wrist fight, but wrist fight was a very nice project,

23:11.240 --> 23:20.440
which is, like, sad. Because I was lazy. Yes. Oh, this, this is also awesome. This is the,

23:20.440 --> 23:27.640
the foreloom, let me do this also. So, this is the foreloom, okay, do odd. This is a forever foreloom,

23:27.640 --> 23:37.160
okay, and then you want to have, um, you want to have a duck, don't do it. While, um, something,

23:38.040 --> 23:45.720
is not equal to something, don't, don't, don't, don't, don't. Okay, while this is happening, it can do

23:45.720 --> 23:51.960
that, you can also, you know, it's the same construct, it have optional parts. You can also add

23:52.040 --> 24:02.520
four, um, we can do 200, to, until 100 times, like, until 100 times, um, do this, um,

24:02.520 --> 24:11.960
while this is true, do this kind of things. You can say, from 10 to, and then you can have also four,

24:11.960 --> 24:17.240
I, as a variable of type in, so, okay, this is my eye, I want to be explicit. So, this is so beautiful,

24:17.240 --> 24:21.240
you know, everything is one single thing, and then you add the stuff to the end of my talk. Thank you,

24:21.240 --> 24:33.240
everybody, thank you.

