[jordanb]

When Ada came out a lot of programmers couldn't even touch type. You're right there's a generational change and a lot of of the Ada stuff won:

    * strong typing
    * lots of annotations
    * keywords over syntax, support for long variable and token names
    * object focus (Ada 83 had some limitations on inheritance so it wasn't OO strictly speaking) 
    * exceptions
    * large standard library

These things were controversial in the 1980s. They are not today.

[phicoh]

I think that is not correct.

One of the big differences between K&R C and C89 is the introduction of function prototypes. Strong typing was certainly considered positive for compiled languages. Of course C is a lot less strict than Ada.

If we compare the Rust subset that has similar functionality as C then there is not much difference. You get 'fn'. The is 'let' but Rust often leaves out the type, so 'int x = 42;' becomes 'let x = 42;' in Rust. Rust has 'mut' but C has 'const'. Rust introduced '=>' and removed '->' from object access and moved it to the return type of a function.

The C language has support for long variable names. Some early linkers didn't, but that's an implementation issue, people were certainly unhappy about that.

C++ started in the 80s. Objects were not controversial back then. The same applies to exceptions.

I don't have a metric for the size of a standard library. For its time, the C library in Unix system had a large number of functions. Later that was split in a C standard part and a POSIX part. But that was for practical reasons. Lot's of non-Unix systems have trouble implementing fork().

I have no clue what you mean with annotations. If you mean non-function annotations along with code, then generally Rust programs don't have those.

[jordanb]

Exceptions were controversial into the 90s which is why Java went down that whole checked-exceptions rabbit hole. The argument was that an exception was essentially a GOTO (or even COME FROM) which broke functional abstraction.

The Ariane 5 crash involved an exception and that was the central "Ada is unsafe actually" argument from C people.

In fact "exceptions are bad" is so baked into a lot of C people's brains that they left them out of Go!

Short variable names were a technical limitation in early languages but style guides were still arguing against long, descriptive variable names in languages like C into the 2000s.

Objects were also likewise controversial and you can see that in the design of Ada 83 where they were both inspired by OO languages like smalltalk but also hesitant to adopt stuff like inheritance. Inheritance was again, seen as a way to break encapsulation (it kinda is) but also a lot of object implementations were slow and memory inefficient in the 80s. Smalltalk was pretty much the reason why the Apple Lisa failed as a product.

OO became a massive buzzword in the 90s but by that time it had already been around for quite a long time.

By annotations I mean mostly type annotations, of course there's also aspect annotations and other stuff ex: Ada SPARK.

[pjmlp]

Function prototypes were actually taken from the C++ ISO process, back into C, originally.

Back when I learnt C, I think you could go beyond 8 or 12 characters in the symbol tables of compilers like Small-C.