One of the "Steelman" requirements that Ada was built to satisfy was that any program should be able to be represented with a subset of ASCII that would be compatible with the largest range of terminals, teletypes, and punched cards as possible. Less relevant today, but that's why Ada has so many keywords in it's syntax.

Just found this:

https://blog.adacore.com/a-modern-syntax-for-ada

That was an April Fools' joke.

Seriously, the curly braces are a huge improvement. That's no joke.

The "fn" and ":" are good too.

I'm less sure about "include", because I doubt Ada does textual inclusion. If it does, then that is good too. Otherwise, better choices might be: using, use, require, requires, depend, depends, external, library, unit, module...

I don't get this whole need to shorten keywords to 2 letters when the IDE will just autocomplete them, it's really stupid.

Not everyone wants to write code in an IDE. Quite a lot of people prefer a text editor of some kind.

VSCode / Atom aren't IDE's, they are editors with lots of plugin's, like VIM and Emacs are.

The wonderful programming experience of UNIX V6.

ed?

I can't stand that autocomplete. It gets in the way of actual typing. What if I want nothing in the list? What if I actually want to use the arrow keys immediately after that thing has decided to trigger?

It probably also cuts down on human ability, like never taking the training wheels off. In the long run productivity might be lower.

The point of using the end statements is to make sure the programmer knows which clause is being closed.

Ha, that's what I get for posting stuff without reading it.

Like all good jokes, there is a grain of truth in it.

You should count up how many keywords C++ has, then count the number in Ada.

Assuming I counted correctly,

Ada 2012 has 73 reserved words: http://www.ada-auth.org/standards/rm12_w_tc1/html/RM-2-9.htm...

C++ 20 has 97 keywords: https://en.cppreference.com/w/cpp/keyword

Ada is actually case insensitive. The uppercase isn’t strictly necessary, more convention.

Rust seems to flourish despite its heavy use of symbols, and I mean... heavy. Plus, code is supposed to be documentation. :)

This is actually one of my few gripes with Rust. I see lots of code that starts to resemble what I call "cryptosyntax" (also a feature of C++).

In this regard, Ada explicitly had maintainability as a design requirement, and I wonder how well Rust will fare with its concise, symbol-heavy code in that regard.

More specifically, "readability" was the sub-goal that fell under. People were thinking about use as pseudo-code in those days as well.

Ada is case insensitive, so if you really wanted to you could write it in all lower or all upper case. Although, your source would be considered hard to read.

It's worth adding that GNAT, at least, has pretty-printing tools that will fix up casing to whatever standard you've specified in your project.

people had similar complaints about python and all the space/tab/indentation. I like to think it was not aesthetically pleasing but also, it was way ahead of it's time. If Rust was released in '95 it may not have been received as well.