Re: Ada OOP alternatives?

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Fri, 18 Jul 2008 08:54:54 -0400, Robert A Duff wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
> 
>> There are two problems with that. The first one is that the difference is
>> not obvious. Why legality check is less than "full compilation", so that
>> the delta cannot be left for the binder/linker. The second one is that if
>> the delta is sufficient, then the reader should probably become aware of
>> it. In short, it is difficult to drive a margin.
> 
> I don't understand.  To (e.g.) determine whether a procedure call is
> legal, you need to know its name, parameter types, etc.  (Whether "you"
> is the human or the compiler.)  To generate code, you need to know more
> -- which register to put the parameter in, etc

But call convention could be a subject of specification (choosing pragmas
for that was probably a mistake). Register allocation can be postponed (if
the architecture supports renaming) etc. It is not obvious why namely the
body shall determine such things.

> -- and if inlined, what code is in the body.

Inlining should not influence the semantics. Thus if the body is not
available, the client should still be compilable.

>>> The compiler should check legality without looking at other bodies.  But
>>> it should look at bodies when generating code (at least if optimization
>>> is turned on).
>>
>> But what would you do with dynamically linked libraries, remote partitions
>> and other lately bound stuff?
> 
> I don't see what that has to do with organization of the source code.
> These things are implemented using "extra" levels of indirection at run
> time.  E.g. you can't very will inline a call in an executable, and then
> expect that updating a shared library used by that executable will
> update the call by magic.  So don't inline across such boundaries.

I don't want such decisions to propagate into specifications. To me it is
an implementation detail. If an ability to compile without the bodies is
not constant, then something in the specifications shall tell if it is a
pure specification or else that the body will be required. I don't like
this. It would mean mixing interfaces and implementations.

>>... I think that the time of monolithic systems
>> is gone.
> 
> I don't think so.  Certainly some embedded systems are monolithic,
> and should be.

Maybe, though, newer embedded systems have to communicate with other
systems in the outer world. Anyway, Ada is a general purpose language. I
buy some performance loss if it comes to cleaner separation of interface
and implementations. Baked sand is cheap... (:-))

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de