GCC 16 Release Series: Changes, New Features, and Fixes
54 points by jmillikin
54 points by jmillikin
This is the first release since I started working on GCC full time and has some work I’m really proud of in it!
How did you end up working on it fulltime? How did you onboard? What are your focuses? What're the projects current focuses? What are your thoughts so far?
I sought out an open source compiler role after enjoying studying it at university and ended up getting an opportunity at Arm.
I onboarded slowly with lots of effort! I am really privileged to work with some incredibly smart and experienced compiler folk at Arm who I have learned a ton from, and the community are very nice and helpful as well.
Im now working on some vectorisation improvements which is my main area of focus for the next year.
Hard to say what the projects focuses are as there are so many contributors working on their own focuses. C++26 was a ton of work, and the rust front end is a huge project (not that I work on either). Performance is always a strong focus for GCC. I also know there is a lot of work happening on profile guided LTO
Congrats and thanks for the hard work!
What did you work on for this release?
Thanks! I worked on improving function multi-versioning and implementing it for AArch64 (https://gcc.gnu.org/onlinedocs/gcc/Function-Multiversioning.html)
And I added support for some new AArch64 extensions
Not mentioned in the release notes, but this is also the first release with builtin support for the wild linker, a new linker that intends to implement incremental linking, and is in many cases already faster than mold.
Now with this gcc 16 release it is just a simple -fuse-ld=wild away.
I'm excited to play with C++ reflection!
Upvote because if I had the time, I'd like to toy with Algol. That's an important piece of history about which I know nothing.
Although not sure whether I'd go with Algol-68 at first. It's a different type… I mean, mode of beast.
You mean what Wikipedia says?
ALGOL 68 is substantially different from ALGOL 60 and was not well received, so reference to "Algol" is generally understood to mean ALGOL 60 and its dialects.
(Again, I feel too ignorant about Algol!)
I believe Algol 68 is widely treated as a separate language to Algol 60 due to how big a change it was and how vastly different a feature set is has. Unfortunately Algol 68 is also a language that got very few implementations and little use.
I learned about it as a teenager because my first boss in computing (who had also been a Burroughs engineer back in the day) had written an ALGOL 68 interpreter with one major user: the Moroccan Air Force.
Oh nice! That’s the first real world deployment I’ve heard of. I wonder if any of those systems are still running in some basement somewhere
It's been fashionable to bash Algol 68 for almost 60 years. I mean, we've been the Hoare quote ("…not only an improvement on its predecessors, but also on nearly all its successors.") almost as a mantra in the computer sciences. Which is quite ridiculous, considering how complex modern programming languages and their implementations are. Sure, Algol 68 was hard to implement at the time, but now we have C++, Rust etc. ;)
No, I was mostly talking about toying with/learning Algol, where simpler versions like Algol-60 or Algol-W might be better introductions and a good basis to tackle bigger ones.
Having said that, playing around with Algol 68 has been quite easy for a while, due to Algol 68 Genie, a great interpreter. Comes with a very solid introduction book (PDF version here). It has all the language features, and I think even adds some–I think even inner-procedural-refinements, my favorite unused language feature.
What’s an inner procedural refinement? There are some brief words about refinements in the Algol 68 Genie book, but no examples or descriptions of how to use them.
Refinements are somewhere in the area of nested functions, code comments and literate programming. You give a name to a code block and call it, but there's no scoping, it's basically just inserted at the spot.
Quick example, excuse the pseudocode, it's all human garbage output here:
procedure numberwang
introduce ourselves;
loop
var number;
var is_wang := false;
var want_to_continue;
ask user for number;
perform check;
tell user of result;
does user want to continue;
end
say goodbye;
ask user for number:
number = read_line("what's your number? ");
perform check:
is_wang := Vectron.check_numberwang(number);
tell user of result:
if is_wang then
that is numberwang;
else
remain silent;
end
that is numberwang;
write_line("That's numberwang!");
progress_board_randomly();
remain silent:
write_line("");
does user want to continue:
if read_line_yes_no(" do you want to continue") then
write_line("Next round");
else
break;
end
introduce ourselves:
write_line("Welcome to Numberwang!");
say goodbye:
write_line("See you next time on Numberwang!");
end
It's been used in the educational language Elan and I knew of at least two C preprocessors the last time I had a serious look at it. Here's a paper about the concept itself and one of the preprocessors.
It's a curiosity out of the day when "structured programming" and how to achieve it was still a thing, but I quite liked the concept. Note that you often could write with spaces in the refinements even if the language itself didn't allow that (some Algol versions allow for that, although sometimes it got sacrificed on the altar of not having to do complicated "stropping").
Thanks for the example! It has a strong taint of literate programming which I think should be made obsolete by better programming language design. One of the things I dislike about it is the unhygienic macrology, which would be better off done with procedures or closures (depending on how much capturing they need).
I recommend the cauldron talk about it. It was a lot of fun.
(https://m.youtube.com/watch?v=3aMwC24EcJk&pp=ygUSR2NjIGNhdWxkcm9uIGFsZ29s)