Re: Why .ads as well as .adb?

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

> That is not possible. You cannot generate specification from 
> implementation and conversely.

Yes, you can. You can generate specs from implementations.

> In both cases there is additional 
> information missing.

Why is it missing? What if we put all information in implementation? Then there is nothing missing and we can generate specs from it.

Your argument is not convincing. It can be expanded into:
- I have separate spec and implementation files, so I can write my contracts in the spec and then I don't have to repeat them in bodies.
- Well, I did not write my contracts in bodies, so they are not there and therefore something is missing, so I cannot generate specs from it.

?

> Compare also Ada's declarative regions with C++'s 
> ad-hoc declarations:
> 
>     declare
>        X : Integer;
>     begin
>        ... -- Some code
>        X := 1;
>     end;
> 
>     {
>        ... // Some code
>        int X;
>        X = 1;
>     }

When I compare these two examples, I see that C++ is more readable, because it allows me to minimize the scope of names that are not needed until in later parts of code, without messing with useless constructs like this:

begin
   -- some code
   declare
      X : Integer;
   begin
      X := 1;
   end;
end;

There is *nothing* gained in this construct and it is equivalent to the C++ example above.

> BTW when writing OS-dependent code it is very convenient 
> to have one *.ads file and several *.adb files.

I do that in C++, too.

> And, in the 
> tool-chain you just switch to another *.adb when changing the target.

And, in the tool-chain you just switch to another *.cpp when changing the target.
 
> Compare that with C++'s #ifdef infestations.

What? Why would anybody do that, apart from those few cases where this approach genuinely improves the readability of the code and where having separate compilation units would actually be more difficult to maintain?

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?

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