Why Ada Is the Language You Want to Be Programming Your Systems With

I am obviously teasing the OP, but there's IMO a lot of truth to it. Safety-critical stuff damn better be simpler, smaller and fundamentally easier or it will fail and kill people. That's why stuff like https://groups.google.com/forum/message/raw?msg=comp.lang.ad... makes sense. In a lot of aspects, mission critical-software is much, much "easier": easier to stretch the budgets, easier to not have competition, easier to justify why something can't be done or why it has to take another 3 years of work.

While a modern fully functional web browser is a huge pile of complexity, technologies, requirements and yet it is still needs to work under much tighter social, economical and performance pressures. Any bug being widely exploited, could lead to people literally dying or at least having their lives ruined. It's just not as spectacular as "missiles".

So I think the OP (and probably you as well :P) is being arrogant by dismissing "firefox", that's all.

There is something to be said for a language that was written to a spec from the beginning, however. That is a luxury that few languages today can claim; most language specs were written after the first version(s) of the language were implemented, and were written to match the implementation, not the other way around.

Writing the specification first makes for a much cleaner language, though not always the most comfortable, if you put any weight in your own opinions.

[I am speaking generally from here onwards and I am not looking for specific examples to the contrary. I know full well that there are exceptions to the generalizations below.]

Lots and lots of engineers today would (and do) express complete comfort in their daily drivers of C and C++, while producing buffer overflow bugs and use-after-free bugs all the while. Maybe it isn't in the best interest of the software landscape to let developers choose the languages they use...

We have, as a community, let our feeling that software development is an art dictate how we react and deal with new information; we overwhelmingly reject it. What we're doing now is so much more comfortable, and we feel like we know what we're doing with [language x] finally! Why would I want to overturn all that comfort?

Software development is not an art, it is a science, and we've been ignoring the science part of that as we refuse to abandon our favorite language(s) for things that could easily be proven to be better, if we would just do the testing to determine performance numbers, ease of bug introduction, ease of maintenance, and so on.

We call ourselves "software engineers" and we don't measure anything beyond the most rudimentary measurements. We DEFINITELY do not actively look to overturn our comfort in favor of finding a better language to use. We don't try to improve anything the moment that might mean that we switch languages, no matter how significant the long term advantages could be. We don't even think about what the long term advantages could be; we're too busy telling ourselves that we are smart and that we can do it in whatever language we are comfortable with.

Embedded people care.

I haven't touched it in a long time, but I remember some of the impressions it made on me when I first used it.

The type system: I think you could do some really fancy things like:

  speed := miles_traveled / elapsed;

the thing is, I think you had to create some conversion stuff for the "/" so that it allowed two types to be divided, returned a third type.

unchecked conversion: no matter what you did, you had to interface with hardware. So there was a lot of unchecked_conversion() stuff to convert between basic machine stuff.

argument lists: You couldn't have a printf() or any other varargs type stuff that I remember. This made interfacing with external libraries that needed this kind of stuff lots harder. (maybe there are ways to do this)

there were things I really did like

the package and package body stuff: You could implement a bunch of interfaces, and compile against the prototypes before the implementations were written.

the attributes, like foo'Size and the system package let you write your code to be correct even if system types or machine types changed

A lot of Ada is really tedious, but once you got over that, working with an existing project was usually really nice.