WEBVTT

00:00.000 --> 00:02.000
You

00:30.000 --> 00:32.000
You

01:00.000 --> 01:02.000
You

01:10.000 --> 01:12.000
Why is that pink?

01:12.000 --> 01:14.000
Because you made it pink.

01:14.000 --> 01:16.000
Let me see.

01:16.000 --> 01:18.000
Stop how my aesthetic choice is.

01:18.000 --> 01:20.000
I think the rectangle is the hollow.

01:20.000 --> 01:21.000
Yeah, right.

01:21.000 --> 01:22.000
It's first color.

01:22.000 --> 01:23.000
Quite right.

01:23.000 --> 01:24.000
Yeah.

01:24.000 --> 01:25.000
Yeah.

01:25.000 --> 01:26.000
Okay.

01:26.000 --> 01:27.000
Yeah.

01:27.000 --> 01:28.000
So.

01:28.000 --> 01:29.000
Interesting.

01:29.000 --> 01:32.000
Interesting decision in life.

01:32.000 --> 01:35.000
Or several, I guess.

01:35.000 --> 01:38.000
This is a major one.

01:38.000 --> 01:41.000
That cheesy needs an algal 68 front.

01:41.000 --> 01:45.000
And then this language needs to have a vibrant community.

01:45.000 --> 01:47.000
Just a few decades later.

01:47.000 --> 01:52.000
So he's also setting up, not just he, but there's a team by now.

01:52.000 --> 01:55.000
Setting up a algal 68 web page.

01:55.000 --> 02:09.000
And reviving the programming languages, community and inventing or coming up with stuff that you need nowadays that people didn't think about in the 60s.

02:09.000 --> 02:14.000
Like I owe interfaces and all such funny things.

02:14.000 --> 02:15.000
Yeah.

02:15.000 --> 02:18.000
And the GCC now has an algal 68 front.

02:18.000 --> 02:22.000
And you can use it to compile actual code as we have seen before.

02:22.000 --> 02:25.000
And I'm sure you will have some more examples of that.

02:25.000 --> 02:26.000
Yeah.

02:26.000 --> 02:33.000
Thank you.

02:33.000 --> 02:34.000
Is this working?

02:34.000 --> 02:35.000
Yeah.

02:35.000 --> 02:36.000
Yeah.

02:36.000 --> 02:37.000
All right.

02:37.000 --> 02:40.000
So first of all, I would like to say two things about this talk.

02:40.000 --> 02:41.000
First.

02:41.000 --> 02:50.000
I'm sure that at least some of you are here for some cool mega-sega drink cause the console game in things.

02:50.000 --> 02:54.000
Instead, we are, you are here for 25 minutes of two levels of rammers.

02:54.000 --> 02:59.000
Notions, photo notions, meta notions, and so on.

02:59.000 --> 03:00.000
I'm kidding.

03:00.000 --> 03:03.000
But it has been a change in the schedule.

03:03.000 --> 03:07.000
So Falco, I am sure that he's watching from home.

03:07.000 --> 03:08.000
All right.

03:08.000 --> 03:11.000
So this was, we don't have a lot of time.

03:11.000 --> 03:15.000
This is the reviews edition of an updated total that they did in Caltron.

03:15.000 --> 03:17.000
So we are going to do the following.

03:17.000 --> 03:19.000
For 15 minutes.

03:19.000 --> 03:20.000
No, for 10 minutes.

03:20.000 --> 03:25.000
I'm going to do an introduction of the project about the language, blah, blah, blah.

03:25.000 --> 03:30.000
But I promise that as soon as I get the sign of it's only 50 minutes left.

03:30.000 --> 03:33.000
I'm going to shut up and I'm going to show you something cool.

03:33.000 --> 03:39.000
Because I don't want all the blah blah to actually avoid the cool demos.

03:39.000 --> 03:40.000
All right.

03:40.000 --> 03:44.000
So let's get with it.

03:44.000 --> 03:45.000
Right.

03:45.000 --> 03:49.000
The elephant in the room, why algorithm 68?

03:49.000 --> 03:50.000
You are an idiot.

03:50.000 --> 03:55.000
Because algorithm 60 is, you know, like it was completely super seated.

03:55.000 --> 03:58.000
Yes, it was very important in the past.

03:58.000 --> 04:00.000
But who cares about it anymore?

04:00.000 --> 04:01.000
Okay.

04:01.000 --> 04:02.000
First thing first.

04:02.000 --> 04:05.000
Algol 60 was algorithm 60.

04:05.000 --> 04:06.000
Right.

04:06.000 --> 04:11.000
And indeed, almost every aspect of that language has been super seated.

04:11.000 --> 04:15.000
And has been developed by later languages.

04:15.000 --> 04:16.000
Yes?

04:16.000 --> 04:21.000
I don't care.

04:21.000 --> 04:30.000
Algol 60 is basically, well, it has some historical interest if you want to say that.

04:30.000 --> 04:32.000
Remains historical curiosity.

04:32.000 --> 04:34.000
It's actually a nice thing.

04:34.000 --> 04:39.000
Algol 60 is a completely different language.

04:40.000 --> 04:41.000
It has the same name.

04:41.000 --> 04:47.000
It was produced as the result of evolving trying to evolve Algol 60 into something different.

04:47.000 --> 04:52.000
But it is totally and completely a language in its own.

04:52.000 --> 04:56.000
That has absolutely nothing to do with Algol 60 in most aspects.

04:56.000 --> 04:57.000
All right.

04:57.000 --> 05:00.000
And this is a problem that they already had back in the past.

05:00.000 --> 05:05.000
There is a Algol bulletin from beginning of the 70s where they are,

05:05.000 --> 05:07.000
someone was already complaining.

05:07.000 --> 05:09.000
We are calling over self-algo.

05:09.000 --> 05:12.000
So people throw things as conferences.

05:12.000 --> 05:14.000
Anyway.

05:14.000 --> 05:19.000
So it turns out that Algol 68 is modern.

05:19.000 --> 05:22.000
It's more modern than any other programming language.

05:22.000 --> 05:24.000
In fact, that is widely used today.

05:24.000 --> 05:25.000
It is powerful.

05:25.000 --> 05:32.000
It is more powerful as an opponent of fact, as than any other widely used programming language around today.

05:32.000 --> 05:34.000
And it is safe.

05:34.000 --> 05:38.000
And when we finish implementing all the runtime checks, as a mother of fact,

05:38.000 --> 05:43.000
is going to be safer than any other programming language actually widely used around today.

05:43.000 --> 05:45.000
Okay.

05:45.000 --> 05:53.000
And also right in Algol 68 code is a very, very special and nice experience.

05:53.000 --> 05:57.000
Because the language is designing a way that actually,

05:57.000 --> 06:00.000
some of the stuff that you can do with it is feels like magic.

06:00.000 --> 06:02.000
It's not magic, right?

06:02.000 --> 06:04.000
We don't believe in magic here.

06:04.000 --> 06:06.000
We don't do LLM sphere.

06:06.000 --> 06:10.000
But we know that it's not magic, but it just feels like.

06:10.000 --> 06:14.000
So, okay, I have this timeline of Algol 68.

06:14.000 --> 06:18.000
I don't want to get very deep in here, but basically,

06:18.000 --> 06:20.000
there was Algol 60.

06:20.000 --> 06:23.000
Then they said, okay, let's do something else after that.

06:23.000 --> 06:25.000
Then it was Algol X.

06:25.000 --> 06:30.000
Then with the Smilla and the garden, they put together a proposal.

06:30.000 --> 06:35.000
Then they were commanded or commissioned to actually talk among themselves

06:35.000 --> 06:38.000
and come with some agreement proposal.

06:38.000 --> 06:40.000
They did not, of course.

06:40.000 --> 06:42.000
I mean, they competed among them.

06:42.000 --> 06:44.000
And then it was being garden, who actually won.

06:44.000 --> 06:46.000
And that led to Algol 68.

06:46.000 --> 06:48.000
There was a lot of discussions.

06:48.000 --> 06:53.000
Then there was a small part of that committee that included these journals.

06:53.000 --> 06:57.000
So, with that they were very bad losers.

06:57.000 --> 07:02.000
So, they wrote a minority report on nasty stuff.

07:02.000 --> 07:03.000
It doesn't matter.

07:03.000 --> 07:06.000
Well, then there was a revision, but important,

07:06.000 --> 07:10.000
the active support that lasted around until I wrote 18.

07:10.000 --> 07:13.000
And then in 1980, the Dark Ages started,

07:13.000 --> 07:17.000
which basically means that everyone started pushing for simplistic,

07:17.000 --> 07:20.000
extremely simplistic programming languages.

07:20.000 --> 07:26.000
Like C, which are like macrossemblers, as Mohammed was saying before.

07:27.000 --> 07:29.000
What happened recently?

07:29.000 --> 07:33.000
There is another programming language, which is not Algol 68,

07:33.000 --> 07:38.000
that even though it's pretty nasty as a programming language,

07:38.000 --> 07:40.000
it has made something important.

07:40.000 --> 07:41.000
This is Rust.

07:41.000 --> 07:43.000
What has Rust done?

07:43.000 --> 07:47.000
Rust, for some reason that they still don't understand,

07:47.000 --> 07:55.000
it has managed to get people to again think about the tools they used to do a staff.

07:56.000 --> 08:03.000
And people are all once again after 20 years, 30 years of obscurity.

08:03.000 --> 08:10.000
People are once again willing to start thinking about those tools.

08:10.000 --> 08:16.000
And they are willing again to use complicated tools to do complicated things.

08:16.000 --> 08:22.000
Problem, Rust is awful.

08:23.000 --> 08:27.000
So, when Rust crashes and it has to,

08:27.000 --> 08:30.000
then Algol 68 will be there.

08:30.000 --> 08:34.000
Modernized and up of running.

08:34.000 --> 08:36.000
So that's the point.

08:36.000 --> 08:41.000
So to do that, we confront and ignore Algol 68 working group

08:41.000 --> 08:44.000
and you can read there all the main characteristics.

08:44.000 --> 08:48.000
And we want to bring Algol 68 to the first line of programming

08:48.000 --> 08:51.000
and spell all the food surrounding it.

08:51.000 --> 08:56.000
99% of the staff you will hear about Algol 68 is bullshit.

08:56.000 --> 09:02.000
And 99% of anyone that told you about Algol 68 is a bullshitter

09:02.000 --> 09:08.000
because very few people have actually taken time to get a clue about the language.

09:08.000 --> 09:11.000
I am the one percent that is not the bullshitter.

09:11.000 --> 09:14.000
Trust me.

09:14.000 --> 09:18.000
Okay, and of course we want to provide more than implementation

09:18.000 --> 09:21.000
from the language and we will integrate it.

09:21.000 --> 09:26.000
Documentation and also important to maintain and extend the language.

09:26.000 --> 09:27.000
Right.

09:27.000 --> 09:28.000
What do we do?

09:28.000 --> 09:30.000
Can you actually see that?

09:30.000 --> 09:31.000
I don't know.

09:31.000 --> 09:32.000
It's got sunny now.

09:32.000 --> 09:34.000
It must be assigned from this case.

09:34.000 --> 09:37.000
Well, basically, we do all sorts of things.

09:37.000 --> 09:39.000
We do documentation as Tomas mentioned.

09:39.000 --> 09:42.000
We have a homepage for the language because now it has something.

09:42.000 --> 09:46.000
Now you have to have a website for the programming languages.

09:46.000 --> 09:50.000
We have a jargon file.

09:50.000 --> 09:53.000
We will see later why we have that.

09:53.000 --> 09:55.000
And we are evolving the language.

09:55.000 --> 10:00.000
We are actually we have an immax mode with my amazing color codes there.

10:00.000 --> 10:01.000
By default.

10:01.000 --> 10:04.000
And immax mode for everything to to lever grammars.

10:04.000 --> 10:05.000
Don't get the scared about that.

10:05.000 --> 10:07.000
You don't have to do that.

10:07.000 --> 10:08.000
And then we have the tool chain.

10:08.000 --> 10:11.000
At the DCC front end, but also the support in the auto tools.

10:11.000 --> 10:13.000
You know, to make auto calls.

10:13.000 --> 10:15.000
We have to do some door fair stuff as well.

10:15.000 --> 10:16.000
DDB is working progress.

10:16.000 --> 10:17.000
We are starting it right now.

10:17.000 --> 10:19.000
We have support in compiler explorer.

10:19.000 --> 10:21.000
Thanks to Mark here.

10:21.000 --> 10:24.000
And we have a community.

10:24.000 --> 10:25.000
Okay.

10:25.000 --> 10:27.000
So we have the homepage for our goal 68.

10:27.000 --> 10:28.000
You can look it up.

10:28.000 --> 10:31.000
The sources are in that need repository.

10:31.000 --> 10:35.000
Then you have resources links to videos and whatnot.

10:35.000 --> 10:38.000
Then we have the mailing list because we are all files.

10:38.000 --> 10:39.000
You know.

10:39.000 --> 10:41.000
So you will use mailing list and we like it.

10:41.000 --> 10:45.000
So you can subscribe in one of those links there.

10:45.000 --> 10:51.000
And we have an IRC channel as well where we just hang out.

10:51.000 --> 10:53.000
And okay.

10:53.000 --> 10:56.000
So this was like the working group very fast.

10:56.000 --> 10:58.000
The front end.

10:58.000 --> 11:00.000
So this is a GCC front end.

11:00.000 --> 11:02.000
And you can see there.

11:02.000 --> 11:05.000
And it's now in trunk.

11:05.000 --> 11:09.000
And what we do is that we implement the full parameter language.

11:10.000 --> 11:12.000
Plus a lot of kind of extensions to the language.

11:12.000 --> 11:13.000
But as we shall see now.

11:13.000 --> 11:18.000
We don't just throw extensions to the language like the C++ or the people do.

11:18.000 --> 11:20.000
Because we have some respect.

11:20.000 --> 11:23.000
And so we do it very carefully.

11:23.000 --> 11:25.000
Very carefully.

11:25.000 --> 11:30.000
We have the the front end has a user manual and internal manual.

11:30.000 --> 11:31.000
And this is not up to date.

11:31.000 --> 11:35.000
And also we have a style style guide for our goal 68.

11:36.000 --> 11:39.000
Since we are not as many writing out of 68 now.

11:39.000 --> 11:44.000
We have the look short of deciding how every one else is going to write the language.

11:44.000 --> 11:51.000
So we keep a formal description of the language that the compiler compiles.

11:51.000 --> 11:54.000
In form of course of our two levels grammar.

11:54.000 --> 12:00.000
Yeah, yeah, yeah, yeah.

12:00.000 --> 12:04.000
And well then we are adopt in Unicode.

12:04.000 --> 12:08.000
And it's already available in some distros.

12:08.000 --> 12:16.000
Now, the architecture of the of the front end, apparently it's nothing out of the of the of the of the ordinary.

12:16.000 --> 12:25.000
You have a compiler driver, G68, a compiler proper A681 and a runtime library.

12:25.000 --> 12:27.000
I want to continue talking.

12:27.000 --> 12:33.000
Okay, well, the only one thing.

12:33.000 --> 12:39.000
I will see there that the parser is looks as strange because it does all sort of things.

12:39.000 --> 12:40.000
And why is this?

12:40.000 --> 12:45.000
This is because of the main characteristics of the characteristic of this parameter language.

12:45.000 --> 12:46.000
So very quickly.

12:46.000 --> 12:54.000
Normally, if you read the definition of a parameter language, you will always find syntax and semantics.

12:54.000 --> 12:58.000
And since an old 60 precisely, you know, since backwards and these people.

12:58.000 --> 13:02.000
The syntax usually are expressed in a context free grammar.

13:02.000 --> 13:07.000
And then the semantics are expressed like in prosa, right?

13:07.000 --> 13:10.000
Like in normal English or whatever.

13:10.000 --> 13:13.000
Algo 68 is different in that regard.

13:13.000 --> 13:26.000
Because it is simply not right to think that syntax is what you can normalize and semantics is what you cannot normalize.

13:26.000 --> 13:28.000
Sorry, it's the other way around.

13:28.000 --> 13:36.000
It is not right to think that you can only normalize syntax and you cannot normalize semantics.

13:36.000 --> 13:38.000
It's the other way around.

13:38.000 --> 13:47.000
So in language specifications, what they call syntax is what they can actually formalize in a way that it is readable and you can operate with it.

13:47.000 --> 13:49.000
And the rest is semantics.

13:49.000 --> 13:59.000
But it turns out that of the language, the problem with semantics, you can do a further division, which is you have the dynamics semantics and the static semantics.

13:59.000 --> 14:10.000
The dynamics semantics is any characteristic and is semantics that relies to evaluate, to run, to calculate some value, right?

14:10.000 --> 14:15.000
But there is a huge spender, which is like the static semantics.

14:15.000 --> 14:20.000
For aspects like, you cannot use an identifier, it's not been declared before.

14:20.000 --> 14:30.000
Or the widening coercion, which is to conform from interior to real, only here, or many other things.

14:30.000 --> 14:37.000
And in which order those conversions happen, do you convert first to reals and then you convert it to this or the other way around?

14:37.000 --> 14:42.000
Well, it turns out that a lot of that can be actually formalized.

14:42.000 --> 14:46.000
But not with a context free grammar.

14:46.000 --> 14:50.000
Now, you can formalize this with a context sensitive grammar.

14:50.000 --> 14:57.000
But it is unreadable, it's almost unreadable and for sure certainly unreadable, it's not practical.

14:57.000 --> 15:01.000
And that was the genius of being garden with the two levels grammar.

15:01.000 --> 15:10.000
The two levels grammar, what you achieve with that is that you can express, you can formalize in a two levels grammar, a lot of restrictions,

15:10.000 --> 15:20.000
specially applied to programming languages, that you cannot express in a context free grammar, in a way that it is breathable, okay?

15:20.000 --> 15:24.000
And that's what they achieved, and that was the big war.

15:24.000 --> 15:34.000
And as a result of that, I'll go to this state is a programming language in which, almost everything is defined by the syntax.

15:34.000 --> 15:41.000
But the syntax when we talk about syntax is the traditional syntax context free syntax, plus all those extra aspects.

15:41.000 --> 15:49.000
That's what makes the language perfect and eternally in an orthogonal frame, okay?

15:49.000 --> 15:51.000
Okay.

15:51.000 --> 15:54.000
Well, very quickly, what's up with the development?

15:54.000 --> 15:57.000
We send the first part series to UCC in January 25.

15:57.000 --> 16:01.000
We were of three for a while, but then we integrated in Tranking November.

16:01.000 --> 16:05.000
Of last year, we implemented the module systems, the FFI and what not.

16:05.000 --> 16:15.000
So this means that when this is 16 gets released in a by a spring or less, it will contain the, include the existing front end, okay?

16:15.000 --> 16:22.000
The homepage, the test suite, this is the second, the two levels grammar, so on.

16:22.000 --> 16:27.000
Okay, I will go through the, I'm sorry, I'm sorry, I'm sorry, I'm sorry, I'm sorry.

16:27.000 --> 16:31.000
I did not, I did not expect that it would be able to show you all this, but okay.

16:31.000 --> 16:39.000
So now I want to invest the last ten minutes, like showing you some algo-68 code, because what I think is to talk about it,

16:39.000 --> 16:47.000
and there's something else is to actually take a look at it.

16:48.000 --> 16:51.000
We are going to take a look to do different applications.

16:51.000 --> 16:56.000
One is a program, it's called God Cici, and it's a common line interface to compiler explorer.

16:56.000 --> 17:02.000
So you can do something like this, like list compilers.

17:02.000 --> 17:13.000
And let's use, I don't know, or God Cici format, food or C, whatever.

17:13.000 --> 17:16.000
So this is a common line interface to compiler explorer.

17:16.000 --> 17:21.000
Compilers explorer is a web thing, which means that you have to use web things.

17:21.000 --> 17:27.000
And that includes JSON, HTTP, and all sorts of other nastiness.

17:27.000 --> 17:31.000
And this program is written in algo-68.

17:31.000 --> 17:39.000
And as you can see here, well, this is like the build-sist, okay, this is not, this is a patch, forget about that.

17:39.000 --> 17:46.000
And so you have a computer, they see, make file of the M, so let's take a look.

17:46.000 --> 17:50.000
You have an AC proc, AC state in autocomphal radio upstream.

17:50.000 --> 17:53.000
So it's basically the same that you will do in C.

17:53.000 --> 17:57.000
And then once you do, you call this macro, then in AutoMake.

17:57.000 --> 17:59.000
Okay, this is just the sub tiers.

17:59.000 --> 18:02.000
And those are like the source files.

18:02.000 --> 18:08.000
And you just have a primary normal auto-make primary with the normal sources.

18:08.000 --> 18:14.000
And if the station is AC state, auto-make knows what rules to generate and everything.

18:14.000 --> 18:17.000
How the source code looks like?

18:17.000 --> 18:20.000
Well, this is the main program.

18:20.000 --> 18:25.000
Yeah, okay.

18:25.000 --> 18:31.000
So this is the beginning end because this is a particular program.

18:32.000 --> 18:36.000
Then it accesses some modules to specific, it access globals, JSON and ACP.

18:36.000 --> 18:42.000
JSON is, it contains the JSON specification, the LP is the other, it has string with the version.

18:42.000 --> 18:44.000
Then you have some procedures here.

18:44.000 --> 18:53.000
You see that in algo-68, you do procedures like very casually because they are like any other value around.

18:53.000 --> 18:58.000
You pass them as arguments and whole packs and all sorts of stuff.

18:58.000 --> 19:02.000
But let me show you something like JSON.

19:02.000 --> 19:08.000
So this is an algo-68 completed JSON parser and writer in 322 lines of code.

19:08.000 --> 19:12.000
So basically this is a module called JSON.

19:12.000 --> 19:14.000
So what is JSON value?

19:14.000 --> 19:16.000
Mode in algo-68 mode type types.

19:16.000 --> 19:24.000
So a JSON value is either a union is either nothing or a Boolean or an integer or a string or a JSON array or a JSON object.

19:25.000 --> 19:29.000
A JSON array is a set of elements.

19:29.000 --> 19:31.000
A JSON object, it has fields.

19:31.000 --> 19:35.000
A JSON element, it is values and next and so on.

19:35.000 --> 19:43.000
You see, now you have some nickels here that we call them which are like new values for those references.

19:43.000 --> 19:51.000
So if you call JSON new object, it returns a JSON value that you allocate on the heap.

19:52.000 --> 19:55.000
And you write it as simple as this.

19:55.000 --> 20:05.000
This is a variable JSON error which in fact contains can refer to a procedure that gets a string and returns a value.

20:05.000 --> 20:15.000
And the default value for that is this routine that gets a message a string and does nothing and calls a set for.

20:15.000 --> 20:22.000
This is what you will call a lambda in and civilized languages, but we call it routine text.

20:22.000 --> 20:28.000
And the path here is that this particular entry or this particular declaration, they are public of the module.

20:28.000 --> 20:30.000
If you use the module, you get those.

20:30.000 --> 20:32.000
This is an operator.

20:32.000 --> 20:35.000
You can define operators and you can overload them.

20:35.000 --> 20:38.000
And yeah, look, this is a nice operator.

20:38.000 --> 20:41.000
This is an operator, a row, whatever.

20:41.000 --> 20:45.000
And that gets a JSON value and a string.

20:45.000 --> 20:52.000
And then you can create some sort of syntax with this, like you create a new value.

20:52.000 --> 20:55.000
Then you say object name equals this.

20:55.000 --> 21:04.000
And this is internally, the operator is basically internally creating an entry into this composite JSON value, right?

21:04.000 --> 21:07.000
It's handy.

21:08.000 --> 21:13.000
Then this is the code to get a JSON value and print a string.

21:13.000 --> 21:15.000
You will see it's very declarative.

21:15.000 --> 21:19.000
If you get a JSON value, then if the value is avoid, you print null.

21:19.000 --> 21:24.000
If the values are Boolean B, then according to the value you print through or false.

21:24.000 --> 21:27.000
If it's an entire I, then you convert to a string.

21:27.000 --> 21:29.000
If it's a string, you just quote it.

21:29.000 --> 21:35.000
If it's an array, then you iterate among the elements and blah, blah.

21:35.000 --> 21:37.000
It's very declarative.

21:37.000 --> 21:40.000
I think it's very readable.

21:40.000 --> 21:42.000
And this is the parser.

21:42.000 --> 21:43.000
This is a parser.

21:43.000 --> 21:45.000
And this is not a Mickey Mouse Passer.

21:45.000 --> 21:46.000
This is a real one.

21:46.000 --> 21:50.000
Like it gets a file descriptor and tries to not allocate everything in memory.

21:50.000 --> 21:52.000
I mean, it's very useful stuff.

21:52.000 --> 21:57.000
And yeah, well, you see, you know, you have all those auxiliary procedures.

21:57.000 --> 21:58.000
You pass a value.

21:58.000 --> 22:00.000
And this is the parser.

22:00.000 --> 22:03.000
The parser is like 25 lines of code.

22:04.000 --> 22:10.000
And like creating procedures passing them as callbacks and creating stuff on the heap.

22:10.000 --> 22:14.000
And JSON for each element and so on.

22:14.000 --> 22:16.000
320 lines of code.

22:16.000 --> 22:19.000
Okay, let's see the HTTP because to talk with compilers,

22:19.000 --> 22:22.000
you have to do HTTP unfortunately.

22:22.000 --> 22:24.000
Okay.

22:24.000 --> 22:31.000
So this is the implementation of HTTP post in our 68.

22:31.000 --> 22:33.000
You get a socket.

22:33.000 --> 22:35.000
You get a URL.

22:35.000 --> 22:40.000
Then you get headers in the form of a multiple, which is an array of extracts each and three.

22:40.000 --> 22:41.000
Two strings.

22:41.000 --> 22:44.000
Name a value for the, for the header.

22:44.000 --> 22:47.000
Then the contents, you can provide them either as a string.

22:47.000 --> 22:50.000
So that it sends as is for short stuff.

22:50.000 --> 22:55.000
Or as a procedure that gets a reference to a willing and gives you a string.

22:55.000 --> 22:59.000
If you want to send big, big contents in chunks.

23:00.000 --> 23:02.000
Then the response, you get it.

23:02.000 --> 23:03.000
You send another callback.

23:03.000 --> 23:07.000
And then you specify if you want the fragmented or not.

23:07.000 --> 23:09.000
And this is basically how it looks like.

23:09.000 --> 23:11.000
I think this is again very readable.

23:11.000 --> 23:12.000
And yeah.

23:12.000 --> 23:13.000
And it's short.

23:13.000 --> 23:18.000
Then you have HTTP gate and post complete implementation into 120 one lines of code.

23:18.000 --> 23:19.000
Okay.

23:19.000 --> 23:22.000
But there is more.

23:22.000 --> 23:25.000
Let's change program.

23:26.000 --> 23:28.000
Lift term 68.

23:28.000 --> 23:35.000
Lift term 68 is a library because I wanted to do like a city library to distribute to test our module system and everything.

23:35.000 --> 23:40.000
That basically it, it gives you like.

23:40.000 --> 23:44.000
Like it's like a mixture of encourses and something else.

23:44.000 --> 23:45.000
I don't know.

23:45.000 --> 23:48.000
It's like unseterminals that you can have little windows.

23:48.000 --> 23:52.000
You can print colors and all that stuff.

23:52.000 --> 23:53.000
And okay.

23:53.000 --> 23:56.000
So basically you have like a tree structure.

23:56.000 --> 23:57.000
Okay.

23:57.000 --> 23:58.000
So how this looks like?

23:58.000 --> 24:01.000
Well, in the build system is very similar.

24:01.000 --> 24:06.000
You see, you create in automake like a leap to library, leap to support this.

24:06.000 --> 24:10.000
And then you have a, but note there is one which is see here.

24:10.000 --> 24:11.000
Now you will see weights for.

24:11.000 --> 24:12.000
Okay.

24:12.000 --> 24:14.000
So, so lift term 68.

24:14.000 --> 24:16.000
What is the top level of the light of the shared object?

24:16.000 --> 24:21.000
Is a module content 68 which accesses these others and just at a version of string.

24:21.000 --> 24:22.000
Okay.

24:22.000 --> 24:24.000
What is the, the staff?

24:24.000 --> 24:28.000
Well, for example here.

24:28.000 --> 24:30.000
So this is the module the terminal.

24:30.000 --> 24:31.000
This is the terminal.

24:31.000 --> 24:35.000
The terminal itself is an input that file the script or an output file the script or

24:35.000 --> 24:36.000
a standard input.

24:36.000 --> 24:40.000
If you want, then when you cool term open.

24:40.000 --> 24:45.000
It gives you a terminal and a default view port which is a region in the terminal.

24:45.000 --> 24:47.000
That covers the full terminal.

24:47.000 --> 24:53.000
And you see how a ref argument is used here to get the passed by reference parameter.

24:53.000 --> 24:54.000
Right.

24:54.000 --> 24:59.000
And then you have different services here like safe estate, blah, blah.

24:59.000 --> 25:02.000
391 lines of code.

25:02.000 --> 25:05.000
Okay.

25:05.000 --> 25:07.000
Then the answer interface.

25:07.000 --> 25:10.000
It's another little module.

25:10.000 --> 25:15.000
The positions, right, which is like the positions of column rows.

25:16.000 --> 25:18.000
You have some handy operators here.

25:18.000 --> 25:21.000
So you have the mode position, which is columns and row.

25:21.000 --> 25:27.000
And then you define operators operator plus operator minus operator bigger than and so on.

25:27.000 --> 25:28.000
Right.

25:28.000 --> 25:31.000
70 lines of code with comments and headers.

25:31.000 --> 25:32.000
And so on.

25:32.000 --> 25:35.000
And now the C part which automatically shows something before.

25:35.000 --> 25:43.000
But for example, this is a C interface to the T C set attribute and T C get attribute for terminals.

25:43.000 --> 25:45.000
And basically.

25:45.000 --> 25:47.000
Well, I create those two functions.

25:47.000 --> 25:52.000
Termioste C get attribute and termioste C to that attributes to simplify the interface.

25:52.000 --> 25:55.000
Because instead of a termiose is tracked, they get like.

25:55.000 --> 25:58.000
Three sets of flux in and sign integers.

25:58.000 --> 26:02.000
You have to do this because the termiose is tracked in posics is secret.

26:02.000 --> 26:04.000
You have three fields which are those or for that.

26:04.000 --> 26:06.000
You know about them, but there can be anything there.

26:06.000 --> 26:08.000
So you need to do this.

26:08.000 --> 26:10.000
And so this is compiled along with the library.

26:10.000 --> 26:14.000
And then you have the algo-c state interface to that C code.

26:14.000 --> 26:18.000
Which is with the find that termiose is tracked in algo-c state with the three flags.

26:18.000 --> 26:20.000
With the find from flag numbers here.

26:20.000 --> 26:26.000
And with the find here, this is this next C is a C formal hall.

26:26.000 --> 26:27.000
Right.

26:27.000 --> 26:29.000
That basically this is okay, this procedure.

26:29.000 --> 26:34.000
C T C get address, which is this algo-c state procedure corresponds to the C1.

26:34.000 --> 26:36.000
And you can use it as normally.

26:36.000 --> 26:40.000
You can, as a Mohammed Cation before, you can do the same with variables and with other stuff.

26:40.000 --> 26:42.000
So there is a good interface with C.

26:42.000 --> 26:45.000
Because we want to be good citizens in the system.

26:45.000 --> 26:50.000
We don't want to be a get-or-language, you know, like go like even rust.

26:50.000 --> 26:51.000
You know, everything is a static.

26:51.000 --> 26:54.000
We have to rewrite the whole world, you know, in over language.

26:54.000 --> 26:56.000
Because otherwise, you know, everything is horrible.

26:56.000 --> 26:57.000
No, no.

26:57.000 --> 26:58.000
We like shared objects.

26:58.000 --> 26:59.000
We like linkers.

26:59.000 --> 27:00.000
We like the system.

27:00.000 --> 27:01.000
And we want to use it.

27:01.000 --> 27:03.000
And we want to integrate properly.

27:04.000 --> 27:05.000
That's the idea.

27:05.000 --> 27:10.000
And trust me, we are making, we are going through big pains to make that so.

27:10.000 --> 27:13.000
Like in the implementations of the modules and everything else.

27:13.000 --> 27:16.000
I don't have time now to detail how the modules are implemented.

27:16.000 --> 27:19.000
But we did it in a way that it's not intrusive.

27:19.000 --> 27:20.000
You don't need cargos.

27:20.000 --> 27:22.000
You don't need a special tools to build.

27:22.000 --> 27:25.000
You don't need like ADA, a special linkers.

27:25.000 --> 27:30.000
No, you use the normal linker and you use the normal make and everything works.

27:30.000 --> 27:31.000
Okay.

27:32.000 --> 27:33.000
Okay.

27:33.000 --> 27:35.000
And yes, yes, that means up.

27:35.000 --> 27:36.000
Okay.

27:36.000 --> 27:40.000
So there is, I wrote a little demo that, but I don't know where it is.

27:40.000 --> 27:43.000
Ah, it's here.

27:43.000 --> 27:47.000
So basically, well, you have a terminal.

27:47.000 --> 27:48.000
You open it.

27:48.000 --> 27:50.000
This is a little process to program.

27:50.000 --> 27:51.000
You open it.

27:51.000 --> 27:54.000
You, this is for, for drawing a frame around.

27:54.000 --> 27:57.000
This is rainbow to change colors in text.

27:57.000 --> 28:00.000
And then it, it does all sorts of this for testing the library.

28:00.000 --> 28:01.000
Basically.

28:01.000 --> 28:03.000
And so let's run it.

28:03.000 --> 28:05.000
Have it ready here.

28:05.000 --> 28:06.000
What is it?

28:06.000 --> 28:07.000
Here.

28:07.000 --> 28:08.000
So I am in the same directory.

28:08.000 --> 28:09.000
So I'm not.

28:09.000 --> 28:10.000
Oops.

28:10.000 --> 28:11.000
So I'm not cheating.

28:11.000 --> 28:16.000
And I have here ascript, which just calls the compiler with so

28:16.000 --> 28:19.000
minus i options and minus l options.

28:19.000 --> 28:21.000
So let's build it.

28:21.000 --> 28:25.000
And now I execute the demo, but I have to add the

28:25.000 --> 28:28.000
ld library path because this is not installed.

28:28.000 --> 28:32.000
So the real object is in dot leaps.

28:32.000 --> 28:34.000
But it doesn't, but it's just one shared object.

28:34.000 --> 28:35.000
It's library.

28:35.000 --> 28:37.000
It doesn't have either files.

28:37.000 --> 28:40.000
And see.

28:40.000 --> 28:42.000
It works.

28:42.000 --> 28:51.000
So now, this, this, this, this is a Mickey Mouse demo.

28:52.000 --> 28:54.000
But I wanted to make it at risk.

28:54.000 --> 28:55.000
No.

28:55.000 --> 28:57.000
I'm sorry, but no.

28:57.000 --> 28:59.000
Are you serious?

28:59.000 --> 29:01.000
Yes.

29:01.000 --> 29:02.000
Very serious.

29:02.000 --> 29:03.000
Yeah.

29:03.000 --> 29:04.000
Yeah.

29:04.000 --> 29:05.000
I am serious.

29:05.000 --> 29:07.000
What?

29:07.000 --> 29:09.000
What computer?

29:09.000 --> 29:13.000
This is a Panasonic talk book that you can find in internet

29:13.000 --> 29:16.000
for 250 euros used to refer to it.

29:16.000 --> 29:20.000
But 10 years ago, they were like 10, 3 or 4,000 euros,

29:20.000 --> 29:21.000
and it could not afford them.

29:21.000 --> 29:26.000
Now I have like 5 or 6 of them.

29:26.000 --> 29:28.000
Yes?

29:28.000 --> 29:33.000
You can find in eBay.

29:33.000 --> 29:35.000
Oh, sorry.

29:35.000 --> 29:36.000
I'm sorry.

29:36.000 --> 29:39.000
The question was, if you can buy the device report,

29:39.000 --> 29:42.000
you can find copies either original or facsimiles.

29:42.000 --> 29:44.000
Some people are doing facsimiles.

29:44.000 --> 29:47.000
But we plan to do our redition.

29:47.000 --> 29:50.000
And we also plan to do our redition of the informal introduction

29:50.000 --> 29:53.000
to algo assisted from Charles Lince and many other staff.

29:53.000 --> 29:54.000
Yes?

29:54.000 --> 29:56.000
Yeah.

29:56.000 --> 29:57.000
I'd like to thank you.

29:57.000 --> 29:58.000
I'd like to thank you.

29:58.000 --> 29:59.000
How is this dropping?

29:59.000 --> 30:00.000
How is this dropping?

30:00.000 --> 30:01.000
Does it work in your implementation?

30:01.000 --> 30:02.000
I, okay.

30:02.000 --> 30:04.000
I went through that, and I didn't want to,

30:04.000 --> 30:05.000
okay, how is this dropping?

30:05.000 --> 30:07.000
What's in our implementation?

30:07.000 --> 30:08.000
Okay.

30:08.000 --> 30:09.000
Very quickly.

30:09.000 --> 30:11.000
I did not want to go through that because.

30:11.000 --> 30:12.000
Okay.

30:12.000 --> 30:14.000
So the original, the algo assisted code as you can see

30:14.000 --> 30:17.000
an internet looks like this.

30:17.000 --> 30:20.000
For example, this is using quote as dropping.

30:20.000 --> 30:21.000
It's very old stuff.

30:21.000 --> 30:24.000
This comes back to the times where you only had one alpha

30:24.000 --> 30:26.000
vetting your computer and most usefully open

30:26.000 --> 30:27.000
uppercase.

30:27.000 --> 30:30.000
And it happens that the algo's

30:30.000 --> 30:32.000
68 syntax is distinguished between both

30:32.000 --> 30:34.000
wards and normal wards.

30:34.000 --> 30:37.000
And both tag letters and normal letters.

30:37.000 --> 30:39.000
But now, then there were different

30:39.000 --> 30:41.000
walled, a stroping.

30:41.000 --> 30:43.000
This is called stroping.

30:43.000 --> 30:46.000
This technique to distinguish between what is a

30:46.000 --> 30:48.000
ward and what is not.

30:48.000 --> 30:49.000
This was called a stroping.

30:49.000 --> 30:50.000
This is dot stroping.

30:50.000 --> 30:52.000
You see that is dot before.

30:52.000 --> 30:55.000
This is reserved wards, a stroping,

30:55.000 --> 30:57.000
that was not very successful because

30:57.000 --> 31:00.000
some of the of the wards become keywords,

31:00.000 --> 31:02.000
but you cannot do it with the wards that you

31:02.000 --> 31:03.000
defined yourself.

31:03.000 --> 31:05.000
And this is the classic app and a

31:05.000 --> 31:07.000
stroping that is supported by this is it.

31:07.000 --> 31:10.460
in which the ball works to make in uppercase.

31:11.460 --> 31:14.580
We were happy with this apperis shopping,

31:14.580 --> 31:17.020
but other people are not.

31:17.020 --> 31:19.780
So what we did was, as a canoe extension,

31:19.780 --> 31:22.420
we created, well, we added support for voltages

31:22.420 --> 31:24.460
for underscore, and then we created

31:24.460 --> 31:26.100
what we called sapperis shopping.

31:26.100 --> 31:27.340
We call it sapperis shopping

31:27.340 --> 31:28.580
because it's sort of a mixture

31:28.580 --> 31:31.420
between apperis shopping and dresses shopping.

31:32.740 --> 31:36.900
And basically, we managed to come with a shopping regime

31:36.920 --> 31:39.140
that is a still-stop-in-regime,

31:39.140 --> 31:43.420
therefore way more powerful that coding conditions.

31:45.420 --> 31:46.260
Exactly.

31:46.260 --> 31:49.220
You can still have available calling on the spot.

31:49.220 --> 31:50.540
Thank you very much.

31:50.540 --> 31:55.540
And that it looks like nice for the kids, right?

31:58.220 --> 31:59.260
Like, yeah.

32:00.500 --> 32:03.220
So, mission accomplished on the end of that regard.

32:04.140 --> 32:05.700
Yeah?

32:08.700 --> 32:10.140
It can be carvously collected.

32:10.140 --> 32:12.780
And what is it to interact with the device?

32:12.780 --> 32:15.420
We try to create some memory with C?

32:15.420 --> 32:16.420
Yeah.

32:17.700 --> 32:19.180
At the moment, you are on your own.

32:21.180 --> 32:22.260
Well, actually, at the moment,

32:22.260 --> 32:24.620
we are using a conservative nervous collection,

32:24.620 --> 32:26.260
which is like not wearing anything.

32:27.260 --> 32:29.420
But, yeah, you know, but we are going

32:29.420 --> 32:31.100
to change to a precise nervous collection

32:31.100 --> 32:32.420
at the hook, at the hook, and yeah.

32:32.500 --> 32:34.300
But, for the moment, you are on your own.

32:34.300 --> 32:35.140
Good luck.

32:35.140 --> 32:36.780
Can you talk about the syntax or?

32:36.780 --> 32:37.620
No, it's not.

32:38.940 --> 32:39.780
Yeah?

32:39.780 --> 32:43.380
You like a shorter place on Barça, in Moscow?

32:43.380 --> 32:45.380
What did he say?

32:45.380 --> 32:46.220
True.

32:46.220 --> 32:49.020
You've got a shorter place on Barça, in Moscow.

32:49.020 --> 32:49.860
I don't know.

32:49.860 --> 32:51.180
I can't hear you from here.

32:51.180 --> 32:52.020
I'm sorry.

32:53.460 --> 32:54.460
Yeah, time is up.

32:56.460 --> 32:57.700
I'm sorry, time is up.

32:57.700 --> 32:59.700
We should do it, maybe later.

32:59.700 --> 33:00.540
Thank you.

33:00.540 --> 33:01.540
Thank you.

33:01.540 --> 33:02.540
Thank you.

33:02.540 --> 33:07.540
Thank you.

