Re: Interfaces.Shift_Left

["Randy Brukardt" <randy@rrsoftware.com>]

"Niklas Holsti" <niklas.holsti@tidorum.invalid> wrote in message 
news:9lc6bqFfhrU1@mid.individual.net...
...
> Is that based on some survey of reasons why Ada is used? That would be 
> interesting. I agree with that ranking only for some Ada applications -- 
> the traditional embedded, bare-machine programs that access hardware 
> registers. Programs that deal with communication protocols may also 
> qualify. And even there, I would not put record representation clauses 
> close to the top of the 5 top reasons.

No, just my gut feeling. At lot of the things that make Ada unique aren't 
things that you really can sell to outsiders (that is, non-Ada users that 
might be interested in using Ada).

For instance, I find that the syntax of Ada has just the right level of 
verbosity (not so much as to be a pain, not so little as to allow one to 
write something other than what they meant to be legal). Most languages 
(especially C-based syntaxes) don't have enough. But I doubt I'm going to 
convince many others of that, at least not until they've had the experience 
of using Ada for a while.

Another truly valuable feature of Ada is the complete coverage rule for case 
statements, aggregates, and the like. The amount of time that it can save 
when adding a new kind of thing (enumeration literal, record component, 
etc.) is amazing. (As the compiler points out the places you've forgotten to 
change; errors of omission are by far the hardest to find.) But again, this 
is a tough sell until you've had the compiler find errors for you.

Most of the big picture things (like packages and generics) are available in 
other languages, and Ada's advantages with them are subtle (physical 
separation of interface and implementation; the contract model of 
generic) -- these are also not that easy to describe to potential users.

The net effect of all of these smallish things leads to a much bigger 
advantage when put together -- but there is nothing "sexy" about any of 
them. Representation clauses in general at least are easy to explain and 
almost everybody remembers times when they would have preferred that the 
compiler did the packing/unpacking of fields. So they make a good lead for 
the advantages of Ada.

                                      Randy.