Re: is ada dead?

[stephen_bevan@yahoo.com (Stephen J. Bevan)]

James Rogers <jimmaureenrogers@worldnet.att.net> writes:
> Yes. The Stringbuffer class is much more efficient than the String
> class for editing purposes. It is still terribly inefficient 
> compared to, for instance, Ada strings.

Do you mean String or an Unbounded_String?  IMHO a Java StringBuffer
has very similar properties to an Ada Unbounded_String.  If you want
an equivalent of an Ada String, then the best approximation would be
char[] in Java.


> Remember the extra processing overhead needed to use a StringBuffer
> also. Consider the StringBuffer a linked list of characters.
> I say this because the StringBuffer is resizable, while the String
> class, and Java arrays are not. This means that the StringBuffer
> cannot be implemented using an array.

Actually it is implemented as an char[] -- at least in Sun's
implementation anyway.  If you turn a String into a StringBuffer then
it allocates an array large enough for the string plus some slop space
(16 characters).  If you append enough characters to fill the slop
space then a new array is created with a size 2* the current one and
all the characters are copied over.  This has bad worst-case
properties, especially for appending, but it seems to suffice on
average (I've certainly used it on quite a few occasions and it didn't
show up in profiling).  If you need something with better worst-case
properties then you can build it based on a char[].


> by garbage collection. Some Java garbage collectors do not
> defragment memory after collection. Heavy use of a StringBuffer
> can result in highly fragmented memory. This may not be a memory
> leak, but it can result in the eventual inability to allocate
> a needed block of memory.

Agreed, its a quality of implementation issue.  But then so is the
quality of the memory allocation routines you get with an Ada
implementation.  In both cases if you are not happy you can either
write your own pooling code or try a different implementation.


> The StringBuffer is still highly inefficient compared to the 
> ability to edit characters in place in a string.

I agree.  However, if you know you want to edit a String then the best
thing is to avoid making it a String in the first place and either
keep it as a char[] or wrapped in a StringBuffer.