Re: The Complexity of Software

From: Thomas Gagné (tgagne_at_wide-open-west.com)
Date: 04/08/04 

Date: Thu, 08 Apr 2004 12:27:05 -0400

Pradyumn Sharma wrote:

>Thomas Gagné <tgagne@wide-open-west.com> wrote in message news:<fbmdncKRb_EK_-ndRVn-jA@wideopenwest.com>...
>
>
>>If they do the same thing, I suspect the FORTRAN code may have been
>>easier to read and write than the Java code.
>>
>>
>
>Really? Why don't you illustrate your point with some code example
>that shows that Fortran code is simpler than Java?
>
>How about trying to develop, say, a small spread*** using Fortran?
>
>
The assertion to which my reply was made, was that given two programs
that did the same thing (I'm assuming they're already written) the
FORTRAN code would be easier to read and depending on what it did, to
write. I don't suspect someone would attempt a spread*** in a
language without dynamic memory allocation. A "switch" would be useful
too, but that was easily remedied by Plauger's RATFOR. But Java is
frought with multiple mathematical problems Gosling and others agree
ought to be addressed. Obviously, some languages are better suited to
some applications than others. A spread *** might be in Java's or C's
favor than in FORTRAN. Some scientific apps may favor FORTRAN. In the
middle where both languages overlap FORTRAN (I think) would be easier to
learn and read (given two applications doing the same thing).

>
>
>>FORTRAN was a larger improvement over Assembler
>>than Java is to FORTRAN (using the noted metrics).
>>
>>
>
>Even if this can be proved, what does it mean? Why should the utility
>of a language be measured by whether it has a larger improvement over
>its predecessor than any other language had over its respective
>predecessor?
>
>
To be more to the point, FORTRAN (and many of the languages of its time)
were immense improvements over what preceded them. They were simpler
and more could be easily done with them than in assembler. Java is an
unusual phenomena in the sense that instead of being much simpler than
its predecessor (call it C++) it has increasingly become more complex.
I already listed some metrics for consideration. Perhaps some don't
feel the elements of syntax (symbols, keywords, grammar) and
inconsistencies within the language (size, length, length(), primitives,
wrappers, and others I forgot to mention) to be worth considering as
contributions to a language's complexity. For those that don't, let's
imagine a language with twice as many syntactical elements and
incongruencies as Java and consider whether it would be a good thing or
a bad thing. If you suspect it would be a bad direction to go consider
a language that has half the syntactic elements and incongruencies of
Java and consider whether /it/ would be a good or bad thing. Assume
that could be done without forfeiting important features (benefits).
Which /features/ of a language wouldn't you trade for simplicty? Static
type checking? Dynamic type checking? Type safety? Garbage
collection? Object orientation? Pointers? Dynamic memory? Ease of
integration with lower-level languages? Memory footprint? Execution speed? 

-- 
.tom
remove email address' dashes for replies
opensource middleware at <http://isectd.sourceforge.net>
<http://gagne.homedns.org/~tgagne/>