Re: Ada & MacOS

[Maciej Sobczak <no.spam@no.spam.com>]

Jeffrey R. Carter wrote:

>> Same for C++. One of the users of my recent code (non-trivial, I would 
>> say) compiled it on MacOS by typing "make", even though I've never 
>> touched Mac. So?
> 
> Using which compilers and what language features? Very few "C++" 
> compilers implement the language defined by the ISO standard.

You may find it funny, but since nobody implements the "export" feature, 
then nobody uses it, and then in turn it's not a problem that nobody 
implements it. Similarly, you will not find this feature described in 
beginner's books, nor lectured in courses. For this reason, the one 
compiler which claims to support this feature did not get immediate 
market advantage exactly because there's no code (and no programmers - 
not counting few die-hard enthusiasts) that would benefit from this. And 
for the same reason, other vendors don't rush to implement it.
So, no, I cannot use *all* the ISO features, but since I'm not using 
them anyway, I don't find it to be a showstopper. There is a bunch of 
good compilers targetting most of the platforms I'm interested in and I 
don't find any problems moving my code from one platform to another.

> With Ada, the entire standard language is compiled by every compiler; a 
> compiler that didn't implement, say, generics, would be laughed out of 
> existence. Yet "C++" users regularly use compilers that don't implement 
> templates, exceptions, or namespaces.

Really? Taking into account what I've seen during the last few years on 
comp.lang.c++.moderated, I'd say that today such compilers are 
extraordinarily rare, something like a living mammoth. I don't call it 
"regularly use".

> Ada compilers can implement compiler-dependent pragmas and attributes, 
> and can supply compiler-dependent packages. Many also supply 
> platform-dependent packages. If you use those, you're not writing 
> portable code. If you stick to the standard language, though, 
> portability is pretty much guaranteed.

Yes, sure. Same for C++ - stick to the standard library and you're done. 
The problem is that both Ada and C++ have *very* small standard 
libraries, especially when compared to what you can get from Java or 
.NET stuff. This means that apart from reading from and writing to 
files, there's not much the fully compliant program can do. Not counting 
some extremely encapsulated environments (like embedded), every 
application needs to rely on some non-standard library. Network? GUI? 
XML? Databases? <your-pet-application-area-here>? Say I want to write a 
mail client in Ada - obviously some network and GUI stuff would be 
needed. Then what? Of course, I can use some non-standard library(ies) 
for this. But since the library is non-standard, it does not fall under 
the "we have a standard test suite" label, so the foundation to boast 
unprecedented portability is no longer there.

I'm writing this from Mozilla, written in C++, running happily on most 
desktop platforms you can find today. Have Mozilla been written in Ada, 
it wouldn't be much more portable.

> GNAT is an interesting beast. Versions exist for a number of platforms, 
> and it comes with a large library (GNAT.*) that is compiler dependent, 
> and much of it (such as GNAT.OS_Lib) seems platform dependent, too. 
> These work fine on all platforms that GNAT compiles to. So you have 
> compiler-dependent but platform-independent packages with GNAT.

In C++ there are libraries, which are platform-independent and 
compiler-independent as well (see for example www.boost.org). The 
portability achieved with those libraries is very high.

BTW - why do you write "C++" in question marks, and Ada without them?

-- 
Maciej Sobczak : http://www.msobczak.com/
Programming    : http://www.msobczak.com/prog/