You
Why is that pink?
Because you made it pink.
Let me see.
Stop how my aesthetic choice is.
I think the rectangle is the hollow.
Yeah, right.
It's first color.
Quite right.
Yeah.
Okay.
Yeah.
So.
Interesting.
Interesting decision in life.
Or several, I guess.
This is a major one.
That cheesy needs an algal 68 front.
And then this language needs to have a vibrant community.
Just a few decades later.
So he's also setting up, not just he, but there's a team by now.
Setting up a algal 68 web page.
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.
Like I owe interfaces and all such funny things.
Yeah.
And the GCC now has an algal 68 front.
And you can use it to compile actual code as we have seen before.
And I'm sure you will have some more examples of that.
Yeah.
Thank you.
Is this working?
Yeah.
All right.
So first of all, I would like to say two things about this talk.
First.
I'm sure that at least some of you are here for some cool mega-sega drink cause the console game in things.
Instead, we are, you are here for 25 minutes of two levels of rammers.
Notions, photo notions, meta notions, and so on.
I'm kidding.
But it has been a change in the schedule.
So Falco, I am sure that he's watching from home.
All right.
So this was, we don't have a lot of time.
This is the reviews edition of an updated total that they did in Caltron.
So we are going to do the following.
For 15 minutes.
No, for 10 minutes.
I'm going to do an introduction of the project about the language, blah, blah, blah.
But I promise that as soon as I get the sign of it's only 50 minutes left.
I'm going to shut up and I'm going to show you something cool.
Because I don't want all the blah blah to actually avoid the cool demos.
All right.
So let's get with it.
Right.
The elephant in the room, why algorithm 68?
You are an idiot.
Because algorithm 60 is, you know, like it was completely super seated.
Yes, it was very important in the past.
But who cares about it anymore?
Okay.
First thing first.
Algol 60 was algorithm 60.
Right.
And indeed, almost every aspect of that language has been super seated.
And has been developed by later languages.
Yes?
I don't care.
Algol 60 is basically, well, it has some historical interest if you want to say that.
Remains historical curiosity.
It's actually a nice thing.
Algol 60 is a completely different language.
It has the same name.
It was produced as the result of evolving trying to evolve Algol 60 into something different.
But it is totally and completely a language in its own.
That has absolutely nothing to do with Algol 60 in most aspects.
All right.
And this is a problem that they already had back in the past.
There is a Algol bulletin from beginning of the 70s where they are,
someone was already complaining.
We are calling over self-algo.
So people throw things as conferences.
Anyway.
So it turns out that Algol 68 is modern.
It's more modern than any other programming language.
In fact, that is widely used today.
It is powerful.
It is more powerful as an opponent of fact, as than any other widely used programming language around today.
And it is safe.
And when we finish implementing all the runtime checks, as a mother of fact,
is going to be safer than any other programming language actually widely used around today.
Okay.
And also right in Algol 68 code is a very, very special and nice experience.
Because the language is designing a way that actually,
some of the stuff that you can do with it is feels like magic.
It's not magic, right?
We don't believe in magic here.
We don't do LLM sphere.
But we know that it's not magic, but it just feels like.
So, okay, I have this timeline of Algol 68.
I don't want to get very deep in here, but basically,
there was Algol 60.
Then they said, okay, let's do something else after that.
Then it was Algol X.
Then with the Smilla and the garden, they put together a proposal.
Then they were commanded or commissioned to actually talk among themselves
and come with some agreement proposal.
They did not, of course.
I mean, they competed among them.
And then it was being garden, who actually won.
And that led to Algol 68.
There was a lot of discussions.
Then there was a small part of that committee that included these journals.
So, with that they were very bad losers.
So, they wrote a minority report on nasty stuff.
It doesn't matter.
Well, then there was a revision, but important,
the active support that lasted around until I wrote 18.
And then in 1980, the Dark Ages started,
which basically means that everyone started pushing for simplistic,
extremely simplistic programming languages.
Like C, which are like macrossemblers, as Mohammed was saying before.
What happened recently?
There is another programming language, which is not Algol 68,
that even though it's pretty nasty as a programming language,
it has made something important.
This is Rust.
What has Rust done?
Rust, for some reason that they still don't understand,
it has managed to get people to again think about the tools they used to do a staff.
And people are all once again after 20 years, 30 years of obscurity.
People are once again willing to start thinking about those tools.
And they are willing again to use complicated tools to do complicated things.
Problem, Rust is awful.
So, when Rust crashes and it has to,
then Algol 68 will be there.
Modernized and up of running.
So that's the point.
So to do that, we confront and ignore Algol 68 working group
and you can read there all the main characteristics.
And we want to bring Algol 68 to the first line of programming
and spell all the food surrounding it.
99% of the staff you will hear about Algol 68 is bullshit.
And 99% of anyone that told you about Algol 68 is a bullshitter
because very few people have actually taken time to get a clue about the language.
I am the one percent that is not the bullshitter.
Trust me.
Okay, and of course we want to provide more than implementation
from the language and we will integrate it.
Documentation and also important to maintain and extend the language.
Right.
What do we do?
Can you actually see that?
I don't know.
It's got sunny now.
It must be assigned from this case.
Well, basically, we do all sorts of things.
We do documentation as Tomas mentioned.
We have a homepage for the language because now it has something.
Now you have to have a website for the programming languages.
We have a jargon file.
We will see later why we have that.
And we are evolving the language.
We are actually we have an immax mode with my amazing color codes there.
By default.
And immax mode for everything to to lever grammars.
Don't get the scared about that.
You don't have to do that.
And then we have the tool chain.
At the DCC front end, but also the support in the auto tools.
You know, to make auto calls.
We have to do some door fair stuff as well.
DDB is working progress.
We are starting it right now.
We have support in compiler explorer.
Thanks to Mark here.
And we have a community.
Okay.
So we have the homepage for our goal 68.
You can look it up.
The sources are in that need repository.
Then you have resources links to videos and whatnot.
Then we have the mailing list because we are all files.
You know.
So you will use mailing list and we like it.
So you can subscribe in one of those links there.
And we have an IRC channel as well where we just hang out.
And okay.
So this was like the working group very fast.
The front end.
So this is a GCC front end.
And you can see there.
And it's now in trunk.
And what we do is that we implement the full parameter language.
Plus a lot of kind of extensions to the language.
But as we shall see now.
We don't just throw extensions to the language like the C++ or the people do.
Because we have some respect.
And so we do it very carefully.
Very carefully.
We have the the front end has a user manual and internal manual.
And this is not up to date.
And also we have a style style guide for our goal 68.
Since we are not as many writing out of 68 now.
We have the look short of deciding how every one else is going to write the language.
So we keep a formal description of the language that the compiler compiles.
In form of course of our two levels grammar.
Yeah, yeah, yeah, yeah.
And well then we are adopt in Unicode.
And it's already available in some distros.
Now, the architecture of the of the front end, apparently it's nothing out of the of the of the of the ordinary.
You have a compiler driver, G68, a compiler proper A681 and a runtime library.
I want to continue talking.
Okay, well, the only one thing.
I will see there that the parser is looks as strange because it does all sort of things.
And why is this?
This is because of the main characteristics of the characteristic of this parameter language.
So very quickly.
Normally, if you read the definition of a parameter language, you will always find syntax and semantics.
And since an old 60 precisely, you know, since backwards and these people.
The syntax usually are expressed in a context free grammar.
And then the semantics are expressed like in prosa, right?
Like in normal English or whatever.
Algo 68 is different in that regard.
Because it is simply not right to think that syntax is what you can normalize and semantics is what you cannot normalize.
Sorry, it's the other way around.
It is not right to think that you can only normalize syntax and you cannot normalize semantics.
It's the other way around.
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.
And the rest is semantics.
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.
The dynamics semantics is any characteristic and is semantics that relies to evaluate, to run, to calculate some value, right?
But there is a huge spender, which is like the static semantics.
For aspects like, you cannot use an identifier, it's not been declared before.
Or the widening coercion, which is to conform from interior to real, only here, or many other things.
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?
Well, it turns out that a lot of that can be actually formalized.
But not with a context free grammar.
Now, you can formalize this with a context sensitive grammar.
But it is unreadable, it's almost unreadable and for sure certainly unreadable, it's not practical.
And that was the genius of being garden with the two levels grammar.
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,
specially applied to programming languages, that you cannot express in a context free grammar, in a way that it is breathable, okay?
And that's what they achieved, and that was the big war.
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.
But the syntax when we talk about syntax is the traditional syntax context free syntax, plus all those extra aspects.
That's what makes the language perfect and eternally in an orthogonal frame, okay?
Okay.
Well, very quickly, what's up with the development?
We send the first part series to UCC in January 25.
We were of three for a while, but then we integrated in Tranking November.
Of last year, we implemented the module systems, the FFI and what not.
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?
The homepage, the test suite, this is the second, the two levels grammar, so on.
Okay, I will go through the, I'm sorry, I'm sorry, I'm sorry, I'm sorry, I'm sorry.
I did not, I did not expect that it would be able to show you all this, but okay.
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,
and there's something else is to actually take a look at it.
We are going to take a look to do different applications.
One is a program, it's called God Cici, and it's a common line interface to compiler explorer.
So you can do something like this, like list compilers.
And let's use, I don't know, or God Cici format, food or C, whatever.
So this is a common line interface to compiler explorer.
Compilers explorer is a web thing, which means that you have to use web things.
And that includes JSON, HTTP, and all sorts of other nastiness.
And this program is written in algo-68.
And as you can see here, well, this is like the build-sist, okay, this is not, this is a patch, forget about that.
And so you have a computer, they see, make file of the M, so let's take a look.
You have an AC proc, AC state in autocomphal radio upstream.
So it's basically the same that you will do in C.
And then once you do, you call this macro, then in AutoMake.
Okay, this is just the sub tiers.
And those are like the source files.
And you just have a primary normal auto-make primary with the normal sources.
And if the station is AC state, auto-make knows what rules to generate and everything.
How the source code looks like?
Well, this is the main program.
Yeah, okay.
So this is the beginning end because this is a particular program.
Then it accesses some modules to specific, it access globals, JSON and ACP.
JSON is, it contains the JSON specification, the LP is the other, it has string with the version.
Then you have some procedures here.
You see that in algo-68, you do procedures like very casually because they are like any other value around.
You pass them as arguments and whole packs and all sorts of stuff.
But let me show you something like JSON.
So this is an algo-68 completed JSON parser and writer in 322 lines of code.
So basically this is a module called JSON.
So what is JSON value?
Mode in algo-68 mode type types.
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.
A JSON array is a set of elements.
A JSON object, it has fields.
A JSON element, it is values and next and so on.
You see, now you have some nickels here that we call them which are like new values for those references.
So if you call JSON new object, it returns a JSON value that you allocate on the heap.
And you write it as simple as this.
This is a variable JSON error which in fact contains can refer to a procedure that gets a string and returns a value.
And the default value for that is this routine that gets a message a string and does nothing and calls a set for.
This is what you will call a lambda in and civilized languages, but we call it routine text.
And the path here is that this particular entry or this particular declaration, they are public of the module.
If you use the module, you get those.
This is an operator.
You can define operators and you can overload them.
And yeah, look, this is a nice operator.
This is an operator, a row, whatever.
And that gets a JSON value and a string.
And then you can create some sort of syntax with this, like you create a new value.
Then you say object name equals this.
And this is internally, the operator is basically internally creating an entry into this composite JSON value, right?
It's handy.
Then this is the code to get a JSON value and print a string.
You will see it's very declarative.
If you get a JSON value, then if the value is avoid, you print null.
If the values are Boolean B, then according to the value you print through or false.
If it's an entire I, then you convert to a string.
If it's a string, you just quote it.
If it's an array, then you iterate among the elements and blah, blah.
It's very declarative.
I think it's very readable.
And this is the parser.
This is a parser.
And this is not a Mickey Mouse Passer.
This is a real one.
Like it gets a file descriptor and tries to not allocate everything in memory.
I mean, it's very useful stuff.
And yeah, well, you see, you know, you have all those auxiliary procedures.
You pass a value.
And this is the parser.
The parser is like 25 lines of code.
And like creating procedures passing them as callbacks and creating stuff on the heap.
And JSON for each element and so on.
320 lines of code.
Okay, let's see the HTTP because to talk with compilers,
you have to do HTTP unfortunately.
Okay.
So this is the implementation of HTTP post in our 68.
You get a socket.
You get a URL.
Then you get headers in the form of a multiple, which is an array of extracts each and three.
Two strings.
Name a value for the, for the header.
Then the contents, you can provide them either as a string.
So that it sends as is for short stuff.
Or as a procedure that gets a reference to a willing and gives you a string.
If you want to send big, big contents in chunks.
Then the response, you get it.
You send another callback.
And then you specify if you want the fragmented or not.
And this is basically how it looks like.
I think this is again very readable.
And yeah.
And it's short.
Then you have HTTP gate and post complete implementation into 120 one lines of code.
Okay.
But there is more.
Let's change program.
Lift term 68.
Lift term 68 is a library because I wanted to do like a city library to distribute to test our module system and everything.
That basically it, it gives you like.
Like it's like a mixture of encourses and something else.
I don't know.
It's like unseterminals that you can have little windows.
You can print colors and all that stuff.
And okay.
So basically you have like a tree structure.
Okay.
So how this looks like?
Well, in the build system is very similar.
You see, you create in automake like a leap to library, leap to support this.
And then you have a, but note there is one which is see here.
Now you will see weights for.
Okay.
So, so lift term 68.
What is the top level of the light of the shared object?
Is a module content 68 which accesses these others and just at a version of string.
Okay.
What is the, the staff?
Well, for example here.
So this is the module the terminal.
This is the terminal.
The terminal itself is an input that file the script or an output file the script or
a standard input.
If you want, then when you cool term open.
It gives you a terminal and a default view port which is a region in the terminal.
That covers the full terminal.
And you see how a ref argument is used here to get the passed by reference parameter.
Right.
And then you have different services here like safe estate, blah, blah.
391 lines of code.
Okay.
Then the answer interface.
It's another little module.
The positions, right, which is like the positions of column rows.
You have some handy operators here.
So you have the mode position, which is columns and row.
And then you define operators operator plus operator minus operator bigger than and so on.
Right.
70 lines of code with comments and headers.
And so on.
And now the C part which automatically shows something before.
But for example, this is a C interface to the T C set attribute and T C get attribute for terminals.
And basically.
Well, I create those two functions.
Termioste C get attribute and termioste C to that attributes to simplify the interface.
Because instead of a termiose is tracked, they get like.
Three sets of flux in and sign integers.
You have to do this because the termiose is tracked in posics is secret.
You have three fields which are those or for that.
You know about them, but there can be anything there.
So you need to do this.
And so this is compiled along with the library.
And then you have the algo-c state interface to that C code.
Which is with the find that termiose is tracked in algo-c state with the three flags.
With the find from flag numbers here.
And with the find here, this is this next C is a C formal hall.
Right.
That basically this is okay, this procedure.
C T C get address, which is this algo-c state procedure corresponds to the C1.
And you can use it as normally.
You can, as a Mohammed Cation before, you can do the same with variables and with other stuff.
So there is a good interface with C.
Because we want to be good citizens in the system.
We don't want to be a get-or-language, you know, like go like even rust.
You know, everything is a static.
We have to rewrite the whole world, you know, in over language.
Because otherwise, you know, everything is horrible.
No, no.
We like shared objects.
We like linkers.
We like the system.
And we want to use it.
And we want to integrate properly.
That's the idea.
And trust me, we are making, we are going through big pains to make that so.
Like in the implementations of the modules and everything else.
I don't have time now to detail how the modules are implemented.
But we did it in a way that it's not intrusive.
You don't need cargos.
You don't need a special tools to build.
You don't need like ADA, a special linkers.
No, you use the normal linker and you use the normal make and everything works.
Okay.
And yes, yes, that means up.
Okay.
So there is, I wrote a little demo that, but I don't know where it is.
Ah, it's here.
So basically, well, you have a terminal.
You open it.
This is a little process to program.
You open it.
You, this is for, for drawing a frame around.
This is rainbow to change colors in text.
And then it, it does all sorts of this for testing the library.
Basically.
And so let's run it.
Have it ready here.
What is it?
Here.
So I am in the same directory.
So I'm not.
Oops.
So I'm not cheating.
And I have here ascript, which just calls the compiler with so
minus i options and minus l options.
So let's build it.
And now I execute the demo, but I have to add the
ld library path because this is not installed.
So the real object is in dot leaps.
But it doesn't, but it's just one shared object.
It's library.
It doesn't have either files.
And see.
It works.
So now, this, this, this, this is a Mickey Mouse demo.
But I wanted to make it at risk.
No.
I'm sorry, but no.
Are you serious?
Yes.
Very serious.
Yeah.
I am serious.
What?
What computer?
This is a Panasonic talk book that you can find in internet
for 250 euros used to refer to it.
But 10 years ago, they were like 10, 3 or 4,000 euros,
and it could not afford them.
Now I have like 5 or 6 of them.
Yes?
You can find in eBay.
Oh, sorry.
I'm sorry.
The question was, if you can buy the device report,
you can find copies either original or facsimiles.
Some people are doing facsimiles.
But we plan to do our redition.
And we also plan to do our redition of the informal introduction
to algo assisted from Charles Lince and many other staff.
Yes?
Yeah.
I'd like to thank you.
How is this dropping?
Does it work in your implementation?
I, okay.
I went through that, and I didn't want to,
okay, how is this dropping?
What's in our implementation?
Okay.
Very quickly.
I did not want to go through that because.
Okay.
So the original, the algo assisted code as you can see
an internet looks like this.
For example, this is using quote as dropping.
It's very old stuff.
This comes back to the times where you only had one alpha
vetting your computer and most usefully open
uppercase.
And it happens that the algo's
68 syntax is distinguished between both
wards and normal wards.
And both tag letters and normal letters.
But now, then there were different
walled, a stroping.
This is called stroping.
This technique to distinguish between what is a
ward and what is not.
This was called a stroping.
This is dot stroping.
You see that is dot before.
This is reserved wards, a stroping,
that was not very successful because
some of the of the wards become keywords,
but you cannot do it with the wards that you
defined yourself.
And this is the classic app and a
stroping that is supported by this is it.
in which the ball works to make in uppercase.
We were happy with this apperis shopping,
but other people are not.
So what we did was, as a canoe extension,
we created, well, we added support for voltages
for underscore, and then we created
what we called sapperis shopping.
We call it sapperis shopping
because it's sort of a mixture
between apperis shopping and dresses shopping.
And basically, we managed to come with a shopping regime
that is a still-stop-in-regime,
therefore way more powerful that coding conditions.
Exactly.
You can still have available calling on the spot.
Thank you very much.
And that it looks like nice for the kids, right?
Like, yeah.
So, mission accomplished on the end of that regard.
Yeah?
It can be carvously collected.
And what is it to interact with the device?
We try to create some memory with C?
Yeah.
At the moment, you are on your own.
Well, actually, at the moment,
we are using a conservative nervous collection,
which is like not wearing anything.
But, yeah, you know, but we are going
to change to a precise nervous collection
at the hook, at the hook, and yeah.
But, for the moment, you are on your own.
Good luck.
Can you talk about the syntax or?
No, it's not.
Yeah?
You like a shorter place on Barça, in Moscow?
What did he say?
True.
You've got a shorter place on Barça, in Moscow.
I don't know.
I can't hear you from here.
I'm sorry.
Yeah, time is up.
I'm sorry, time is up.
We should do it, maybe later.
Thank you.