Re: Array Of Constant Strings?

[Georg Bauhaus <sb463ba@d2-hrz.uni-duisburg.de>]

Robert A Duff <bobduff@shell01.theworld.com> wrote:
: Georg Bauhaus <sb463ba@d2-hrz.uni-duisburg.de> writes:
: 
:> Should programming languages have string literals at all?
:> I sometimes wonder.
: 
: Heh?!

The reason is that I see many situations where a "string
literal loading mechanism" is preferable. Here are some:

- In many cases programs that do string processing get their
  strings from outside the program, not from literals in the
  program text. No string literals here.

- String literals are hopelessly scattered throughout programs.
  (They need not, but they are, for example ad hoc diagnostic
   messages.) See below.

- String literals are rarely typed (other than being a string).
  That is, string values of the same type are used in very
  different situations. That is, they defeat explicit abstraction,
  even though their content might imply the presence of abstraction.
  (Could be done with wrapper types, but is it done regularly?)

- String literals tend to follow their own non-Ada syntax.
  (Which, again, is not reflected in their type.)

- Lots of textual data can be considered data with a
  structure, but not just a sequence of characters.
  String literals don't help here.

- Often, string literals are in the way of internationalization
  (That's one reason for the mechanism called "externalising strings"
   in some IDEs.)

(All this doesn't mean I wouldn't be missing string literals for example
to quickly add some tracing output.)

Some of the strings mentiones must of course come from somewhere,
so someone must write them or say them, and some strings must
enter program text, for example in exception messages. O.K.

So, absent a "string loading mechanism", the strings could at least
be named using constants, declared in some packages that group them
together according to some predicates like for example, "this is
an error message about erroneous input".  It is much easier to
go from there to internationalisation, than if you had all the
strings scattered throughout the program. Consider a message
on a display of a teller machine, in Russian, outside Russia.
It has been a string literal in the program driving the machine...
If there were no string literals, then wouldn't you be forced to
just circumvent this deplorable incident?

It is so easy, and usual, to (mis)place string literals in
program text that people easily forget these issues. This
is why I sometimes wonder whether a programming language without
string literals is going to be an improvement.

Might there not be a causal relation between the presence of string
literals in programming languages (bad) and a templates mechanism
(Form-Letter Programming) considered a programming pearl (good)?