All right, what comes now is the very first talk of a centuries-long upcoming new tradition,
and that is having August 68 presentations in this death room here and all over the world.
Well, it's not the first presentation all over the world, but at first, I may be the first presentation
ever about August 68 on first and ever, and it's not for say it's you, yeah.
Yeah, we're doing a funny thing here.
Originally, we meant to have introduction to August 68 before the actual use of August 68.
Now, we're doing it the other way around.
We first show a use and then, for say, afterwards, can go into some of the details of the language,
an implementation, of course.
Yeah, anyway, we have Mohammed Rizan Abibur coming up and educating us or showing an example of
use of the GCC August 68 implementation on a bare-map old target.
So, briefly, for this summer.
So, hi, let's get into it.
So, do not criticize my slides by the way, no, this is VIM, and this is fine.
So, this is a demo tank, okay, meaning that I'm not selling anything.
It's just random guy talking about August 68.
It's your decision to use August 68 or not.
People can make wrong decision, bad decisions, it's up to them.
Oh, no.
Okay, it's Ubuntu's bad decision, I hate it.
Okay, so, but that's how I'm just here, just talking about things.
It's a beautiful thing, so I just want to shape my experience with that.
It does it, okay, nothing more.
If you want more, like talk to Jose, okay, and okay, why I'll go 68?
Because it's a high-level power, God.
Because it's a high-level programming language, okay, we like high-level.
And I hope you use this old technology, it doesn't, okay.
So, if we classify, this is like just a random classification.
If we classify program languages, we can say, okay, there are two macro-assemblers,
and high-level programming languages.
For macro-assemblers, it's useful for systems programming,
because you have the control.
What's a macro-assembler?
You write some code, and you kind of know what kind of code it's built generated.
This is amazing when you need this control.
If you're developing systems software, you need this kind of control,
and my control is wrong.
Okay, yeah, write control.
So, as you can see, sometimes control goes wrong, and you know, oopsie doopsie.
But, and example of these macro-assemblers are C and BLEASE,
which is an interesting, like older-than-C language,
which has one more feature than C, which is, you can have,
what's the name?
You can have root core routines, and then you can say,
okay, jump to this with this stack.
So, you define, so, that's a very cool one, but it's typeless,
so, and also, we don't care about those things.
And we have like high-level program languages, which is like,
when you want to solve a problem, and the language doesn't want to,
you know, get into your way to solve in your problem.
You want to focus on your problem.
DSLs are just kind of things.
Algo 68, go sweep Python JavaScript.
These things are like, you want to solve a problem,
and you don't care about details.
You just want to something that doesn't allow you down your thinking.
So, these are useful for these kind of things.
And some of them are even, very useful to do production quality things,
and some are not, but still used in production.
Looking at JavaScript, but, so, so, so, okay,
well, about raw Stnc++, well, they're pretending to be high-level,
well, being a macro-assembly, and that's a disaster,
because, you know, the rule, like, one very bold feature of things,
is like, there are rules, but, but, but, but, but, like, okay,
okay, this is feature of the, because they are merging
melting to the two walls that are like, not very compatible.
Like, oh, if you do this, R and R, V, O, in St++,
we'll kick in, and you will not, you know, make a new copy,
if they do the copy-election, like, fuck you.
You know, it's, it's not simple, you know, it's not simple.
But, you know, you're a bit pretent to be,
think, so, I think this is duplication, okay, oopsie doopsy.
So, okay, example of differences, okay, for example,
in that class of learners, this is a difference, okay,
this is a difference, and in a macro-assembly optimization
is cherry on top of the cake.
You get what you want, but it's nice, you know, you get more out of that.
In high-level program languages, you have to do it right,
you know, all the pain goes to the compiler writer to get it right,
with, with, or if you say, like, it's not important,
but it's a big cherry, this we can agree on that top part.
So, for example, I was 68, it's so simple for the user,
the amount of constructs you have for the user is simple.
You have this very, very minimal thing, and everything works together,
as they call it, or for one-ality.
But the problem is, like, it's horrible for a compiler,
but we don't care, we are using a Jose's problem, okay,
he will figure it out.
And if it doesn't work as expected, we can use it, you know,
and only him.
And just, well, it's kind of fun, sorry Jose.
And then the other thing is like, in macro-assembly, as I said,
you know, you kind of know what kind of code you want to get there,
but for example, in the agostics, everything is value semantics.
So, it's the job of the compiler writer to
light the copies, which are not important.
So, it's very important to do this kind of thing.
But it's, look, algal 1968, that is semantics.
20, 20, far, c++ value semantics.
So, it's like, they, okay, then there's simplicity,
everything works which is each other.
You can, you can pass, there is no, if, but this kind of things,
you know, if you want to get this, if you do this, this is better.
There is no such thing, you write your program.
algal 1968. Okay, this part caught my eyes.
This identity declaration. Like, you know, you, you look at the thing,
you know, for a while looking, you don't figure it out.
And you know, oh, you see something, you know, there are
futures with that thing that you, you know, it starts, it's clicks.
So, now, there, that thing, for me, was, um, identity there.
I read like 80 page out of 230 pages of this informal
introduction. So, maybe there are more things after that,
maybe I love something, but till now, this is the best part.
This is the best thing. And, uh, hopefully, okay.
So, what's identity declaration?
Um, so this int i equal 1 real pi equal 3.
This is the clearing, um, so here is the identity.
So, I and one are the same thing.
They are not a variable or anything like that.
Okay. Um, uh, so everything is like, look familiar.
But they, they, they, they, they, they, they, we're part is here for for
see, don't do that. Uh, is this, you can not, uh, you can not do
this kind of things, you know, if you say i becomes too,
it's as, as, as meaningless as this thing, which is like,
nonsense, okay. So, this is, you're, you're, you're
declaring identities, like the same thing.
It's, it's like, these, i and one and three point these are like,
living in the, you know, mathematical real, not in the,
on the, on the machine to some, to some, uh, the, we still.
Oh, my, okay. So, what, if you do this, very, very similar,
you know, I don't, I remove the equal to something, you know,
this, in the sea, because the initialization, but this is not that.
So, here, this is a syntactic sugar for variable declaration.
This is a variable declaration. And then you can do this kind of things, you know,
i is one and the point is that thing.
And then later you can change something else, because it's a variable, you know,
you can change it. It's not the, uh, so, but, uh, so what actually happens here
is this int i is actually, uh, a syntactic sugar for this construct,
which means that which, which is that i is a reference to int,
and what's the content of their reference,
allocate something on the, uh, these are generators.
So, allocate this an int for me on this deck and put that, uh, you know, put that
address address in this for this reference. So, I didn't do anything, okay.
So, uh, that means that by the way, if you have a question, you can interrupt me.
I don't mind if you do that, and I don't, I hate the question at the
and definitely do not make two the question. I have a bunch of things.
So, uh, and here it's like very beautifully, uh, which, like, for, like, what is the type,
they call it mode? What's the mode of eye here? It's reference, not int, because it's in
name to something else, which leaves on the stack, and here is unreal. This is, like, awesome.
I mean, I don't, I appreciate they did this, but I always in my mind translate this to this,
and like, oh, man, this is beautiful. And, uh, you can also do this. Uh, uh, you can,
you can put this lock here. Meaning that, okay, put it, uh, as again, syntactic trigger to,
to make it clear that this is allocating on the stack, not, uh, somewhere else.
And, uh, and you also can have the heap. So, you can say, okay, put it on the heap.
heap is somber, which is, you give, somehow manage the memory, um, for example, garbage collection.
It's a one implementation, but it's just, the day the reap, okay, oh, I have the report by the way,
you know, it's like, important. This is Bible thing. I cannot read it yet fully, because it's complicated,
but I'm working on that, yeah. So, uh, so, uh, any question for the identity declaration that
and that's the most beautiful idea of, like, this, you, this, this, this, like,
please, you from this, see mindset of, like, int, exist, you. Is it actual? Yes, it is, it works.
I will show the actual code, and it will compile, hopefully. Uh, so, if you want, I tested before,
the time. Well, who knows? Uh, so, uh, if you want to build, uh, uh, for x86 is simple, you just say,
okay, I lose 68 and I want to put it there. Done. But this note is not about x86, who cares about x86.
Let's talk about arm, okay. Uh, so this is very metal arm. Uh, who's a headset, but I don't know.
It's the dominant thing. Uh, so, you have to apply a bunch of patches, which gives you this,
which I send it the initial draft to the mailing list, but it's still not in master,
because he asked for more test and stuff like that, like, man, come on. But, uh, with me,
I have to do that. So, uh, these are the most important. So, you, you, you, you, you, you, you, you,
you, you, you, you, you, you, you, you, you, you, you, you, you, you, you, you, you, you, uh,
prelude, because there is no live, see, like, or even there, don't do that to me.
And then there is this, uh, algal, and then, you know, target, and this, like, uh,
built for the, uh, the, the, our real time, and m is the, uh, microcontroller profile. So,
everything, it's, like, give you 10 or 20 different combinations of, uh,
lip GCC, and stuff like that, and you disable basically everything, because, you know, like,
it also, algal, 60 GCC, which is the boom GCC, which is, like, interesting kind of GCC.
Because I don't like it, just lags on me, like, okay, but this is, this is, this is,
I'm not a GCC developer, he is a GCC developer, so I like, I don't like, warning is there,
and, and so that, that's also for risk five, uh, you can do the same, and I, I will show you also,
example of this risk five thing. So basically, basically the same, this, this, this, but you
have to change this to this, and you don't have those madness of our improv, I think. So,
any questions so far? What? Somebody said, nobody, you should not use, so in, in the,
I don't even provide the malloc. And it is, this is a different mindset, you know, it's, in, in this,
what? No, yeah, because it's, okay, for microcontrollers, you want determinism at the maximum,
so if you, even want to do heat allocation, you have to do it like in the first part of your
initialization part of the thing, and then the main loop you never do any allocation, because
you want to be sure that your, your, everything is deterministic happening at the right thing. So
he is a bad thing, and the, the leader will yell at you a little bit, it's my mother, there is no
method to do it. Uh, then you have to change the construct, uh, for the, for the, for the,
it's a kind of pain, I will show you the pain part, but, you know, let's focus on the, you know,
quit part, and other questions so far? No question, I love no questions. So, um, the idea was, okay,
we have this hardware, which I have in my back, but I forgot the fucking cable to, to do the
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,
which we use to, to compile things. I can, even, so, um, I, I don't use Mx, but because, thanks to
Jose, there is syntax highlighting, I know everybody likes Hindu syntax highlighting, I don't
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,
even enabled this syntax highlighting for you. Uh, so here you can see that, there is,
don't do it. Is it like there's a line or something, is this line is important, I guess?
So, this, this, this M33 and M thumb are like this is the, the, the model for the things,
and I, I, I, I using this noses, so nose, nose, and I have also no built in, uh, uh, uh,
there is also here. There should be no lips. Ah, okay, here you can see that I commented the
lips is so, there is no lips. Um, but you have to link the GCC and, uh, uh, run time of the, uh,
uh, you know, I'll go. So, that's that thing. Uh, so the question is,
we start from C, okay, we have this, uh, C function. You have to first, uh, define, uh, you know,
here, this is the, I'll go 68, uh, uh, uh, function, you know, this is the thing you have to
control. So, this is the start of, this is before main. So, we have to call the main of the C program
or I'll go 68 program. That, we are there. That, it means like C runtime. Uh, so, uh, you need the,
from the linker's script, you need this, the, the, the, uh, the stack, uh, range, and then here is the,
uh, uh, ISR. So, you have to specify a bunch of based on the arm, uh, specification, you have to put
function pointers in the right place and also initial stack pointer. So, what happens is,
how this reset ISR is important. So, if you go down here, so this is like data, uh, initialization
BSS, you know, putting to zero, this kind of thing, they have to do it ourselves, uh, a bunch
of other things. And then, finally, because we initialize all the variables to zero or to
predefined value and then we call the angle, uh, 68 main which goes to this program dot things.
So, um, access board, board is a module in a sense of the angle 68. And, uh, so we have here,
uh, this is a, um, uh, uh, at the point. So, we are, uh, dealing with the C. Uh, so you see,
uh, you say this is my procedure, which gets bits, bit, bit to the translation to the, uh,
C-world is unsigned in it. They, because for them, bits are not integers, integers are always signed,
beautifully, and, uh, uh, uh, bits are a bunch of bits. If you go to languages, uh, from
Nicholas, we'll, for example, they also have this set concept in upper room in,
Pascal, I even think they have it. So, that's that mindset. So, this is bit, sorry,
area of points, which is in C, translated to unsigned bit. So, it's a procedure, which takes one bit
and returns bits, and this is a procedure, which gets two bits, and, uh, sends nothing. So,
read word, I want to read, I want to do the memory map, I owe. So, I say, okay, use this function
and declare it as this, uh, I will succeed a procedure, and this, uh, so, where those things are
defined, namely, oh, let's see, here. So, uh, that's it. So, I need, uh, I don't know how to
yeah, this is. So, MMIO, uh, you see, I'm using unsigned int unsigned int address, and I'm
using this cast, I want to read, like, I want to deal with the memory map, I owe to, okay, uh, to
read the stuff, read the stuff, read the stuff like that, and, or I want to write something there.
So, this is the address, and I want to, uh, do, do the writing. Any questions so far, Arson?
Okay? I don't care about this, you know, seriously. We are not see for this class, okay?
Uh, okay, you can, one, insurance, I think it might not be a problem.
Of course, you should not, but maybe you'll see how the different opinion, but, yeah, so,
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
because alcohol, there is no address, like volatile stuff, or writing, writing, this kind of thing.
You, you, you, it's not a macroson, exactly. You're not listening, shall I? What the fuck?
I'm not a salesperson.
Somebody add something? Yeah, I mean, you have to use a macroson there to do your macro system to stuff,
but this is a shame later, and that's all the C code you have, based besides the runtime,
and everything else is a fuck. This thing, so we have this, we get this over thing, and then now
we have a procedure, for example, uh, this, this fund, so I'm just going through this, I have only five minutes
that's very sad, but this is the, uh, denotation for the bits, so it's, you can not have it, like,
bits equal to one, so it's a different thing, so you have to use the base to be support,
or algo 60 support, 2, 4, 8, and 16, as basis, there is no base 10 because that's not 10, you know,
but it's not, I mean, it's not an inch, uh, so or, uh, you, so this is a operator, like, bitwise
operator, so this is a comment, so this is also using a modern, uh, algo-strupping, which I
also will talk about, and then, uh, you're, uh, you know, and apps is going from the bits
real to inch real, so the value, because I wanted to plus it with this integer, which is this int,
and it's like this, and then, uh, then I'm writing to the word, I have to turn it back to bin,
as to get bits, and then this is the shift left, so it does the, uh, one, I like base 16,
so I use 16, you can use whatever, base 2, for example, but one, not 16, and then bit shift that,
so, uh, here, uh, this is a color-colour-colour-colour, it's this syntax, not standard, 16,
far zero, close that, he wrote it, I don't know, I don't know, I don't use syntax, I like it,
yeah, that is, that values, uses a different color, and the other layer, the photo, so this is,
this is the, this is the, this is the speaker, fix it, and you know, people are not happy,
so, so here, this is a helper function for, you know, we get a bunch of addresses, I'm using it,
in summer, and I'm just like, okay, this is also a beautiful thing, okay, I think I'm so close to be,
okay, so here I'm calling this function addresses, and I'm giving an index to that, it gives
me the address of that thing that I asked for, which, for example, don't, I have an example,
so here, you see this parenthesis, this is a close-clouse, or, uh, so you all close, I guess,
okay, no, so close-clouse, which is like, okay, this is a declaration, and then this is,
this is, if the short form of, if, so if address is not zero, uh, read that, otherwise,
return zero, this is like this, it else is always, there is this thing, a skip, like in,
you know, it uses the default value, you want to have an antibody for a function, put a
skip there, you want to, int, you don't want to value, put a skip there, you want anything,
you put a skip there, and I hear, put a skip there implicitly, so it's like a third,
way of saying this, this thing, uh, here busy-vades, because of course, you know, and, you know,
you want to, you know, wait your time there, so I'm, I'm accessing this memory from C,
and just writing to this memory, because it's across the boundary, the compiler can not optimize it,
also, it feels just for some time, give me a simulation of bait, uh, and then this is, uh,
this is, uh, I don't need to go there, I have a cursor, so, uh, here, uh, we can,
define a variable sleep, which you can then assign the procedure, which is a value to this thing,
and, uh, uh, I wanted to have two different things, you know, but then like, okay, it's not that
much time off, exactly. And then just, just let me blink the LEDs, and then everything is fine. So,
here, here we have the, for, um, here we have some registers, you sleep, you write the, um,
to this GPIO, that okay, the value, like, put a bit on the GPIO that you want to blink,
explore, you know, just, uh, switch between them, and the blue, so, if I was a little bit
wise to have some video or something, I'm not wise, I don't have anything, just trust me, bro,
this means, so, and then there is nothing for a wrist fight, but wrist fight was a very nice project,
which is, like, sad. Because I was lazy. Yes. Oh, this, this is also awesome. This is the,
the foreloom, let me do this also. So, this is the foreloom, okay, do odd. This is a forever foreloom,
okay, and then you want to have, um, you want to have a duck, don't do it. While, um, something,
is not equal to something, don't, don't, don't, don't, don't. Okay, while this is happening, it can do
that, you can also, you know, it's the same construct, it have optional parts. You can also add
four, um, we can do 200, to, until 100 times, like, until 100 times, um, do this, um,
while this is true, do this kind of things. You can say, from 10 to, and then you can have also four,
I, as a variable of type in, so, okay, this is my eye, I want to be explicit. So, this is so beautiful,
you know, everything is one single thing, and then you add the stuff to the end of my talk. Thank you,
everybody, thank you.