Re: Ada 2005?

[jayessay <nospam@foo.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:


Generally speaking I don't think you understand these issues enough to
have a profitable discussion.  It seems clear that you are only
interested in engaging various sophistries in some weird effort to
"win" something or other.  This is likely my last effort to get dawn
to break over your marblehead.


> >>> However, these rules really have nothing to do with restricting
> >>> "dynamic declarations" (Ada is static and so of course there are no
> >>> dynamic declarations at all).
> >> 
> >> This is wrong.
> > 
> > So where can you _declare_ a new entity at runtime?
> 
> See ARM 3.1.

That section specifically notes that declarations are _declared_ at
_compile_ time.  At _runtime_ they are _elaborated_.  So, you are just
plain wrong.


> >> Not all dynamic declarations are of primitive operations.
> >> Ada is a statically *typed* language.
> > 
> > Yeah.  So?
> 
> So dispatching is not equivalent to halting problem.

I think you need to learn how to read things better.  No one ever said
that multiple dispatching was _equivalent_ to the halting problem.
What I pointed out was that statically determining in all cases that
dispatching will not result in a runtime error is equivalent to the
halting problem.  The reason I pointed this out is that you claimed
that it was indeed possible to never have a runtime error with
dispatching.  You were and are just plain wrong.


> > The general case is simply one where you cannot determine at compile
> > time things like uninitialized variables,
> 
> Class-wide variables cannot be left uninitialized.

It would be nice if you quit playing these silly sophistry games.
Let's take the full quote:

"The general case is simply one where you cannot determine at compile
time things like uninitialized variables, the specific type of a class
wide variable at any given point in time, etc.  These still apply to
Ada.  I'm not sure you actually understand any of this as you keep
making these irrelevant or incorrect claims."

Note the important part about unknown specific types of class wide
variables at any given point.  This is especially apropos wrt class
wide parameters.


> > the specific type of a class
> > wide variable at any given point in time, etc.
> 
> Present us any example of (but not one classified as a bounded error).

Bounded errors are those that are not caught at all.  Are you really
this thick?  I have stated clearly that the issue is that dispatching
in general can result in runtime errors that cannot be determined at
compile time.


> >> case, it is trivial to find a match. Moreover it requires bounded time.
> >> Otherwise, I guess polymorphic calls would never be adopted in Ada. The
> >> problems with implementation of MD in Ada lie elsewhere.
> > 
> > MD is irrelevant to to this point, which is the need for runtime
> > exceptions.
> 
> So it has nothing to do with halting problem? Fine. Then what's the point?

Do you have any idea how stupid this makes you look?


> > Ada has these and you can easily get them with it's
> > polymorphic calls (which cannot be MD), i.e., Constraint_Error can be
> > raised.  What's more, some of these constraint errors are _exactly_
> > the equivalent of "method not found"
> 
> Nope, in Ada it is the equivalent of "method is final and defined to raise
> Constraint_Error". It is a fundamentally different case.

First, you are wrong here - it is indeed the equivalent of "method not
found".  The constraint error will be issued in exactly the same
circumstances.  It is extremely easy to construct examples of this.

Second, I don't see your "method is final" anywhere in the LRM.  But
in any case, the examples I am talking about are _missing_ methods,
not ones that exist but happen to be "final ones".


> > No, the original, as I noted here was and is the one under discussion
> > and it is quite proper.
> 
> OK, I'll make it easier for you:

Let's have the whole quote again you sophist:

"No, the original, as I noted here was and is the one under discussion
and it is quite proper.  In particular it means that Ada has no MD.
There is nothing controversial about this, and several books
(including even the Rationale) discuss how an Ada programmer can
achieve a simple version of MD by rolling their own via redispatch."

MD is all about _multiple_ dispatches, not a single dispatch on
multiple operands of multiple parameters.  That you cannot understand
this is amazing.  Just take a look at the rationale or Barne's book or
Cohen' or ...  They all acknowledge this and that Ada has no MD.
Instead of trying to understand things here you are simply playing
sophist and trying to redefine MD so that you can attempt to claim
that Ada has it.  Why you want to do this is beyond me.


> > The point is an elegant solution cannot be expressed cleanly without
> > recourse to pounding because the language lacks the proper
> > expressivity.
> 
> or that the person lacks some vital knowledge about software design...

I think it has become clear that it is you who lacks the vital
knowledge.


> > Yes.  This means that in this case, intelligent people will _abandon_
> > the tool (in this case the language) so that the elegant correct
> > solution can be expressed without pounding.
> 
> Then you are in a wrong group. It seems that people in c.l.a are
> pretty unintelligent to keep on using Ada, or maybe, there must be
> something wrong with your theory...

Here is a hint:  Neither of your stupid options is correct.


/Jon

-- 
'j' - a n t h o n y at romeo/charley/november com