FW: Is the Writing on the Wall for Ada?

FW: Is the Writing on the Wall for Ada?

[Mário Amado Alves]

(Marin, sorry, previously I replied to you only, by mistake.)

> I suppose it would not hurt too much to make a Bounded_String
> version. 
> More for completeness than anything else. (It would look kind 
> of silly 
> to be able to do a Get_Line or Put_Line of String or Unbounded_String 
> but not Bounded_String, right?) But I'd be curious to know if 
> there is 
> *anybody* out there using Bounded_String on a regular basis. 

Bounded_String is useful--and actually used by people. However I don't
agree with multiplying every string-related tool by the three string
versions. Please do them for String only. Keep the ARM small.

Re: FW: Is the Writing on the Wall for Ada?

[Preben Randhol]

On 2003-09-30, M�rio Amado Alves <amado.alves@netcabo.pt> wrote:
> Bounded_String is useful--and actually used by people. However I don't
> agree with multiplying every string-related tool by the three string
> versions. Please do them for String only. Keep the ARM small.

Why?

Preben

Re: FW: Is the Writing on the Wall for Ada?

[Larry Kilgallen]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 688 bytes --]

In article <slrnbnjano.pte.randhol+valid_for_reply_from_news@kiuk0152.chembio.ntnu.no>, Preben Randhol <randhol+valid_for_reply_from_news@pvv.org> writes:
> On 2003-09-30, M�rio Amado Alves <amado.alves@netcabo.pt> wrote:
>> Bounded_String is useful--and actually used by people. However I don't
>> agree with multiplying every string-related tool by the three string
>> versions. Please do them for String only. Keep the ARM small.
> 
> Why?

The function To_String can readily be used to process a Bounded String
when providing it as a parameter to a subprogram that requires an input
String.

Depending on the compiler, this could be as efficient at runtime as
providing a String.

Re: FW: Is the Writing on the Wall for Ada?

[Preben Randhol]

On 2003-09-30, Larry Kilgallen <Kilgallen@SpamCop.net> wrote:
>
> The function To_String can readily be used to process a Bounded String
> when providing it as a parameter to a subprogram that requires an input
> String.

I thought we were talking about a function that /returned/ a
String or Unbounded_String. Of course one can use To_Bounded_String,
but then what's the point of the Unbounded_String function?

Preben

RE: FW: Is the Writing on the Wall for Ada?

[Mário Amado Alves]

> I thought we were talking about a function that /returned/ a 
> String or Unbounded_String. Of course one can use 
> To_Bounded_String, but then what's the point of the 
> Unbounded_String function?

No point. That was my point. Only String versions is enough.

Re: FW: Is the Writing on the Wall for Ada?

[Preben Randhol]

On 2003-09-30, M�rio Amado Alves <amado.alves@netcabo.pt> wrote:
>> I thought we were talking about a function that /returned/ a 
>> String or Unbounded_String. Of course one can use 
>> To_Bounded_String, but then what's the point of the 
>> Unbounded_String function?
>
> No point. That was my point. Only String versions is enough.

And some thing an array of integers are enough. I thought the point of
returning Unbounded_String was to make the Strings a bit easier to
handle.

Preben

Re: FW: Is the Writing on the Wall for Ada?

[Preben Randhol]

On 2003-09-30, Preben Randhol <randhol+valid_for_reply_from_news@pvv.org> wrote:
> On 2003-09-30, M�rio Amado Alves <amado.alves@netcabo.pt> wrote:
>> No point. That was my point. Only String versions is enough.
>
> And some thing an array of integers are enough. I thought the point of
           ^^^^^
           think

> returning Unbounded_String was to make the Strings a bit easier to
> handle.
>
> Preben

RE: FW: Is the Writing on the Wall for Ada?

[Mário Amado Alves]

> > ... Only String versions is enough.
> 
> And some thing an array of integers are enough. I thought the
> point of returning Unbounded_String was to make the Strings a 
> bit easier to handle.

*Unbounded_String* is designed for easier handling of strings, not
necessarily *functions* returning Unbounded_String. Even Unbounded.Slice
returns a String. It's a matter of pros and cons. What do extra versions
of Get_Line buy us? Only that you can write

  An_Unbounded_String := Get_Line;

instead of

  An_Unbounded_String := To_Unbounded_String (Get_Line);

Now balance this with the cons:

- longer ARM, or

- will take space from more important things;

- overloaded functions that in some contexts will produce ambiguity
(which the programmer must resolve with more code).

My impression is cons > pros, that's all.

(What is the AI for this anyway?)

Re: FW: Is the Writing on the Wall for Ada?

[Wes Groleau]

M�rio Amado Alves wrote:
> Now balance this with the cons:
> 
> - longer ARM, or

If the IO packages all have the same "shape"
then they should not require a lot of extra
text.

I see no point in having several pages that
are identical except for part of the type name.
(There's already too much of that in the child
packages of Ada.Text_IO and in Wide_String routines
repeating the text for String routines.)

If they don't have the same "shape" then it
adds complexity to learning the language.

It always bugged me that IO for some data types is
Get() and Put() but for others it's Read() and Write().

-- 
Wes Groleau
-----------
Daily Hoax: http://www.snopes2.com/cgi-bin/random/random.asp

Re: FW: Is the Writing on the Wall for Ada?

[Marin David Condic]

Except that you still have the problem of expanding the validation. 
Every package you add to the ARM needs sufficient documentation of 
behavior to make it validatable - and *then* you've got to go write 
tests to prove that someone's compiler did the job right and **then** 
someone has to run all that validation and make sure it passes. The 
costs keep multiplying and pretty soon the vendors are howling because 
you're driving them into bankruptcy. Adding stuff to the ARM is 
difficult, costly and slow. I'd prefer not to add things to the ARM that 
don't involve some structural change to the language (syntax/semantics 
of the language itself.) Packages that can be implemented totally within 
the syntax/semantics of Ada are best dealt with in other ways.

Add *LOTS* of packages to Ada and make it more useful and convenient. 
Let's just do it in a less formal way so that we don't kill the vendors 
with implementation/validation effort. A Conventional Ada Library would 
accomplish this.

MDC



Wes Groleau wrote:
> 
> If the IO packages all have the same "shape"
> then they should not require a lot of extra
> text.
> 
> I see no point in having several pages that
> are identical except for part of the type name.
> (There's already too much of that in the child
> packages of Ada.Text_IO and in Wide_String routines
> repeating the text for String routines.)
> 
> If they don't have the same "shape" then it
> adds complexity to learning the language.
> 
> It always bugged me that IO for some data types is
> Get() and Put() but for others it's Read() and Write().
> 


-- 
======================================================================
Marin David Condic
I work for: http://www.belcan.com/
My project is: http://www.jsf.mil/NSFrames.htm

Send Replies To: m c o n d i c @ a c m . o r g

     "All reformers, however strict their social conscience,
      live in houses just as big as they can pay for."

          --Logan Pearsall Smith
======================================================================

Re: FW: Is the Writing on the Wall for Ada?

[Marin David Condic]

Well, lets observe that A Solution Does Exist. Right now, you *can* find 
ways of dealing with Unbounded_String in all the contexts you might want 
by making use of To_String and To_Unbounded_String. I think the issue is 
more one of convenience. Personally, I'd prefer not to be jumping 
through all sorts of hoops if I want to just use Unbounded_String and 
forget about String.

Your position of not wanting to make the ARM too big is probably 
desirable. That's where I'd go into my regular rant about having a 
Conventional Ada Library managed externally from the standard. You could 
add packages that made simple, easy access to most of the things one 
might want without having to impact the standard. The language remains 
small(er) and you don't add complexity to the validation effort, yet you 
can have most of the things you might want in a "Standard" way.

MDC



M�rio Amado Alves wrote:
>>>... Only String versions is enough.
>>
>>And some thing an array of integers are enough. I thought the
>>point of returning Unbounded_String was to make the Strings a 
>>bit easier to handle.
> 
> 
> *Unbounded_String* is designed for easier handling of strings, not
> necessarily *functions* returning Unbounded_String. Even Unbounded.Slice
> returns a String. It's a matter of pros and cons. What do extra versions
> of Get_Line buy us? Only that you can write
> 
>   An_Unbounded_String := Get_Line;
> 
> instead of
> 
>   An_Unbounded_String := To_Unbounded_String (Get_Line);
> 
> Now balance this with the cons:
> 
> - longer ARM, or
> 
> - will take space from more important things;
> 
> - overloaded functions that in some contexts will produce ambiguity
> (which the programmer must resolve with more code).
> 
> My impression is cons > pros, that's all.
> 
> (What is the AI for this anyway?)
> 
> 


-- 
======================================================================
Marin David Condic
I work for: http://www.belcan.com/
My project is: http://www.jsf.mil/NSFrames.htm

Send Replies To: m c o n d i c @ a c m . o r g

     "All reformers, however strict their social conscience,
      live in houses just as big as they can pay for."

          --Logan Pearsall Smith
======================================================================

Re: FW: Is the Writing on the Wall for Ada?

[Larry Kilgallen]

In article <slrnbnjc34.pte.randhol+valid_for_reply_from_news@kiuk0152.chembio.ntnu.no>, Preben Randhol <randhol+valid_for_reply_from_news@pvv.org> writes:
> On 2003-09-30, Larry Kilgallen <Kilgallen@SpamCop.net> wrote:
>>
>> The function To_String can readily be used to process a Bounded String
>> when providing it as a parameter to a subprogram that requires an input
>> String.
> 
> I thought we were talking about a function that /returned/ a
> String or Unbounded_String.

At least one person was talking about it the way I described it.

RE: FW: Is the Writing on the Wall for Ada?

[Mário Amado Alves]

> > Bounded_String is useful--and actually used by people. 
> However I don't 
> > agree with multiplying every string-related tool by the 
> three string 
> > versions. Please do them for String only. Keep the ARM small.
> 
> Why?

Why keep the ARM small? A million resaons, including "because the ARG
says so".

Re: FW: Is the Writing on the Wall for Ada?

[Craig Carey]

On Tue, 30 Sep 2003 16:56:56 +0100, M�rio Amado Alves
<amado.alves@netcabo.pt> wrote:

>(Marin, sorry, previously I replied to you only, by mistake.)
>
>> I suppose it would not hurt too much to make a Bounded_String
>> version. 
>> More for completeness than anything else. (It would look kind 
>> of silly 
>> to be able to do a Get_Line or Put_Line of String or Unbounded_String 
>> but not Bounded_String, right?) But I'd be curious to know if 
>> there is 
>> *anybody* out there using Bounded_String on a regular basis. 
>
>Bounded_String is useful--and actually used by people. However I don't
>agree with multiplying every string-related tool by the three string
>versions. Please do them for String only. Keep the ARM small.
>

That suggests balancing reasoning, so on balance your conclusion is
to be rejected. One grounds for that could be: "Bounded Strings is a
useful package." There may not be any principle saying that the RM has
to be small. What can be discarded (even if ignoring your hints that
your view is wrong) is the balancing. At the time of Ada 95, a rationale
was formulated and followed. If there is a rationale in words behind the
idea "keep the ARM small" then do state that for me.

Re: FW: Is the Writing on the Wall for Ada?

[Robert I. Eachus]

Craig Carey wrote:
 >                         If there is a rationale in words behind the
> idea "keep the ARM small" then do state that for me.

Why? Keeping the ARM small was a major design goal for Ada 9X, and you 
can either listen to the people who were involved, look at the Ada 9X 
requirements documents, or look at the minutes of the many meetings at 
which it was discussed.

This time around, keeping the revision small is one of the goals, but 
not keeping the ARM small as such.  So adding things to the standard 
needs to be well justified, but so does changing things, and so would 
removing something, like Ada.Strings.Bounded.

-- 
                                                     Robert I. Eachus

"Quality is the Buddha. Quality is scientific reality. Quality is the 
goal of Art. It remains to work these concepts into a practical, 
down-to-earth context, and for this there is nothing more practical or 
down-to-earth than what I have been talking about all along...the repair 
of an old motorcycle."  -- from Zen and the Art of Motorcycle 
Maintenance by Robert Pirsig

Re: FW: Is the Writing on the Wall for Ada?

[Marin David Condic]

I doubt you could remove it (Ada.Strings.Bounded) now that its there, 
but you may not make a great effort to expound on it either. If a 
feature is not heavily utilized, there doesn't seem to be a point in 
putting much effort into enhancements - unless one perceives that adding 
the enhancements might get more people to utilize it. It all kind of 
comes down to marketing studies, doesn't it? ;-)

MDC


Robert I. Eachus wrote:
> 
> This time around, keeping the revision small is one of the goals, but 
> not keeping the ARM small as such.  So adding things to the standard 
> needs to be well justified, but so does changing things, and so would 
> removing something, like Ada.Strings.Bounded.
> 


-- 
======================================================================
Marin David Condic
I work for: http://www.belcan.com/
My project is: http://www.jsf.mil/NSFrames.htm

Send Replies To: m c o n d i c @ a c m . o r g

     "All reformers, however strict their social conscience,
      live in houses just as big as they can pay for."

          --Logan Pearsall Smith
======================================================================

RE: FW: Is the Writing on the Wall for Ada?

[amado.alves]

Craig Carey wrote:
> On Tue, 30 Sep 2003 16:56:56 +0100, Mário Amado Alves 
> <amado.alves@netcabo.pt> wrote:
> >
> >Bounded_String is useful--and actually used by people. 
> However I don't 
> >agree with multiplying every string-related tool by the three string 
> >versions. Please do them for String only. Keep the ARM small.
> >
> 
> That suggests balancing reasoning, so on balance your 
> conclusion is to be rejected. One grounds for that could be: 
> "Bounded Strings is a useful package." There may not be any 
> principle saying that the RM has to be small. What can be 
> discarded (even if ignoring your hints that your view is 
> wrong) is the balancing. At the time of Ada 95, a rationale 
> was formulated and followed. If there is a rationale in words 
> behind the idea "keep the ARM small" then do state that for me.

I meant *Ada.Strings.Bounded* is useful, not bounded strings everywhere. Just one variety is enough for the each tool, given that there are already conversion utilities to/from the other varieties. How would you regard multiplying Ada.Text_IO by all string varieties?

To my knowledge there is no written rationale for keeping the ARM small, but I perceive it as a tacit requirement--and actually indicated by some people, specially educators.

And I fear that multiplying each tool by every string variety can consume the 'very finite' ARG and community resources that could be devoted to more needed things e.g. persistent containers.

"Keep the ARM small" is backed up by these *two* forces.

Re: FW: Is the Writing on the Wall for Ada?

[Wes Groleau]

amado.alves wrote:
> I meant *Ada.Strings.Bounded* is useful, not bounded strings
> everywhere. Just one variety is enough for the each tool,
> given that there are already conversion utilities to/from
> the other varieties.  How would you regard multiplying
> Ada.Text_IO by all string varieties?

Simply by stating that all the routines behave in exactly
the same fashion as those in Ada.Text_IO, except for....

And then make the list of exceptions as small as possible.
Preferably NONE.

As for resources, in general, a package that is not with'd
does not consume much resources.  And if it is used, a package
that merely calls a conversion routine and then Ada.Text_IO,
probably adds less overhead than an explicit writing of the
same thing by a user.

-- 
Wes Groleau

Is it an on-line compliment to call someone a Net Wit ?