🚀 go-pugleaf

 As we are talking about Turing-Machine equivalent languages, thus about
languages that are equivalent one to each other, the only bare "power"
difference is execution time and memory use; and with this approach of
"power" down with semantics, grammar, etc.
 But assuming that we have ideally optimized compilers which could produce
roughly the same object code for similar programs on different languages
(which is a very vague assertion, and moreover proves false), and knowing
that (by including a compiler of a language in another, for example), any
language have the same asymptotic siwe limit for very large programs,
we have no more *internal* "power" criterion to evaluate a language.

 Now, if we want to compare languages, we have to consider a human point of
view: what is interesting is not the theoritical potential of the language,
the shortest and/or fastest program that an programmer could produce if he
thought several centuries about the problem; what is interesting is what actual
human (bad) programmers can do.
 This implies that you must take into account the amount of time the programmer
will spend formulating his ideas, re-reading his own sources (or another one's),
making and correcting mistakes in his source program, debugging his program (if
he has to, frequency increasing exponentially with the program length), 
re-adapting previous code for a new use, feeding the input and examining the
output, etc.
 These must be the criteria, for a single program cannot be isolated; if so,
once a program had been written, there would be no more use to express it in a
new language.
 In a good language, a good program must be easy to read, to write, and
to modify as to generalize (or particularize) it.

 That's why I don't know any assembly language that's good: not only do you
spend an enormous amount of time writing and reading it, but you must rewrite
all your code if you want to introduce some important generalization.
 That's why Forth, powerful and easy to write, is not a good language, because
it is VERY difficult to figure out what a not so complex program does with the
stack.
 That's why all those old languages (and direct machine-code) that used (uses) 
line numbers were so bad, because you couldn't modify your program without
checking it all to verify and change every line number reference.
 That's why (original) BASIC is so bad even without line numbers, because you
can't introduce new structures to generalize usual operations.
 That's why C++ is better than Pascal, because redefined operations allow you
to reuse direct affectation of formulae where you had to use a series of
clumsy difficult-to-understand without-recognised-convention procedures which
each did one operation.

 That's why languages with class inheritance are better than languages without,
because you can maintain code more easily, and produce general purpose code.
 That's why languages with classes as objects are even better, because you *can*
produce even more general and easy-to-maintain code (but you can also produce
even more pointless unreadable programs, now it's up to you).
 That's why languages with readable english (I'd rather say french) keywords
are somehow better than languages with ununderstandable symbols and/or
abbreviation, because you can read it more easily.
 That's why a language with more built-in standard and well documented but
redundant features is better than a minimal language, if not as
"expressive".

 What do you think about that (I'm not talking about my pityful frenchman's
english, but about my opinions) ?
 Isn't any discussion about intrinsic "power" of a language other than
performance evaluation otherwise pointless ?
 Or am I the one totally wrong ?
					   ,
					Fare
				(with an accent on the ``e'')

 P.S.: you can answer in this newsgroup, or e-mail me ; my adress is
  rideau@clipper.ens.fr