Re: Why .ads as well as .adb?

[Maciej Sobczak <see.my.homepage@gmail.com>]

> No. Specification describes a class of implementations. You cannot 
> deduce class from its single member.

So what exactly cannot be deduced? Please provide some challenging example.

> It is not possible as well. The language of specifications (to be 
> useful) must have statements non-existing in the language of 
> implementations.

Why not put those statements in the implementation file? The compiler should be smart enough to distinguish them.

> No. The right statement would be: I cannot write contract in the body.

Why? The text editor should not stop you and the compiler should figure out which is which.

> Contract and an implementation of are in two different languages with 
> two different domains. They cannot be spelt in a single language.

What is a single language? A set of keywords with grammar? I can invent the keywords and grammar to cover both needs. Heck, it was already invented, just write them in a single file.

Your arguments are self-contradictory anyway. What about the package declaration in the some declarative part within the implementation file? I can even declare a helper package in the subprogram scope (in its declarative part), so all arguments about the necessity to keep specs and implementation files separate, on the basis that they must be separate "languages", are pointless anyway. Ada already allows to mix everything together, so why pretending to be so pure? The purity is gone already.

> The gain is definition of the scope. C++ equivalent, which I would force 
> in each C++ programming guideline, would be:
> 
>     {
>        ... // Some code
>        {
>           int X;
>           X = 1;
>           ..
>        }
>        .. // Some code
>     }

This is useful if there is a reason to not have X in the second "Some code" part. Especially if X is handling some resource. Otherwise there is no gain.
Still (in both variants), C++ is more readable (the proportion of useful code to the whole is higher).

> Yes, why? There must be something contagious in #ifdef's, or maybe, it 
> just what C/C++ inherently is?

Or maybe this is just what you want it to be, so that Ada looks better?
The problem is - there is nothing stopping you using the same good programming principles and idioms. Especially with regard to physical code design (we have discussed that already (as most of the other things)).

> > In other words: for multiplatform development, C++ gives me 2 solutions and I can choose the one which is more beneficial in the given context. Ada offers only one. How is this better?
> 
> Choice is a burden.

Yet I know how to benefit from it. And I don't want to resign from it.

-- 
Maciej Sobczak * http://www.inspirel.com