Greetings and introductions

[Jose E. Marchesi]

Hello Chris.

> As a long-time fan of Algol 68, and having written a bit of "real
> code" in that language, I struggle to express how delighted I am to
> see all the amazing work being put into GNU Algol 68.  A heartfelt
> thank you to all involved.

Thanks to you for getting in touch!

> I am no kind of expert in writing compilers (especially GNU cc based
> compilers).  I have made my living over the last 40+ years writing
> mostly data analysis programs in languages including FORTRAN, Pascal,
> C, AWK, Java, Groovy, Python, R and Julia.  I have built a number of
> data-forward web sites in Grails.  Over the last 10 years, I have
> written about programming for a generalist open source audience,
> primarily on https://www.opensource.com, and a bit on
> https://www.opensource.net and https://www.both.org.
>
> After using Algol 68C in my undergraduate years in the latter half of
> the 1970s, I haven't done much more with it than wish that I had a
> decent Algol 68 compiler since then, until I stumbled on Marcel's
> wonderful Algol68g a few years ago.  Since that time, I have written
> many insignificant programs to recover my knowledge and at one point
> built a first version of a hash table capability based on
> split-ordered lists(1) in Algol68g, which at least works, but needs
> some cleaning up.

It would be great to get these hash tables working with GCC.  I could
certainly make good use of them in some of my projects.

At the moment, as you probably know, we don't have support (yet) for
separated compilation, but we manage by including the files.  See for
example how the sources are organized in
https://git.sr.ht/~jemarch/godcc.

We also plan to implement modals, but until we do so, I suppose using
your hash table implementation will require to manually define some
modes before include the source file...

> As a great fan of Java, I would love to see Algol 68 evolve a little bit in
> the direction of being object-oriented; thinking specifically of STRUCTs
> that could refer to "self", simple / single inheritance, MODE templates,
> interfaces.  From my perspective, that would require some very careful
> thinking and design work and being willing to draw a boundary much closer
> to Algol 68 classic and much further away from C++.

I am personally not the biggest fan of object orientation, but having
support for it in an "Algol 68 way" would be useful to have, and quite
interesting to design.

> I might be in the minority but I would see this extension being much
> more useful than implementing transput in all its "glory".

I agree with that.  There are a lot of good ideas in the standard
transput that I think would be useful to recover, but after some (much?)
modernization.

> But nevertheless, having two great mostly standard Algol 68
> implementations is an unimaginable richness!

Right now ga68 is basically complete in terms of standard Algol 68,
modulus parallel clauses, which are currently handled like collateral
clauses.  The compiler is slow and the generated code performs much
avoidable copying (the bane of Algol 68 compilers ^^) so now I am busy
adding some much needed optimizations.

We have a long list of extensions we want to to implement, like support
for modals, partial parametrization, separated compilation, exceptions,
etc, but always keeping our extended language a strict Algol 68
super-language.  You can see a list of extensions already implemented at
https://algol68-lang.org.

So the world domination plan goes like this:

1. Modern Algol 68 compiler in the form of a GCC front-end, functionally
   complete.  This is basically done.  Then optimize the front-end,
   which is work in progress.

2. Add extensions to the language, carefully describing them both
   formally and informally, with two main goals:

   2.1 To fill gaps in functionality.  Examples of these kind of
       extensions are modules, exceptions, modals, OOP, etc.

   2.2 To modernize the language.  Examples of these kind of extensions
       are the modern SUPPER stropping, bold taggles, nestable comments,
       etc.

3. Use the language!  I am already writing some of my new programs in
   Algol 68 ;)

> As to this GNU Algol 68 project, I am excited to try out the compiler as it
> develops.  I'm happy to contribute in the way of testing (of course
> contributing any code that might be useful) and writing.  And of course to
> cheer you all on!

Welcome :)

First step is I guess to get a ga68 compiler up and running.  Debian and
Ubuntu Experimental distribute prepackaged versions of the compiler, but
at this stage it is always better to compile your own and keep it up to
date so problems can be reported and fixed.

There is some documentation on how to build ga68 at
https://gcc.gnu.org/gcc/Algol68FrontEnd.

> And thanks again, with great hopes for success!
> --
> (1) SHALEV, O. and SHAVIT, N. 2006. Split-Ordered Lists: Lock-Free
> Extensible Hash Tables. Journal of the ACM, Vol. 53, No. 3. ACM, New York.