🚀 go-pugleaf

In article <ROCKWELL.92Apr10223545@socrates.umd.edu> rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|Stephen P Spackman:
|   What, you think I'm defending J, just because I don't like FORTRAN?
|   They're practically dialects of each other anyway, with their
|   array-o-centrism, type-o-phobia, line-oriented syntax,
|   proliferation of system-reserved mechanisms, encouragement of
|   semantically inexplicable floating-point arithmetic and general
|   inattention to actually solving the problem....
|
|I was going to let all that bs slide until you got to "general
|inattention to actually solving the problem"....  What do you mean
|general inattention to actually solving the problem?
|
|Where in the world do you think J (or APL) get their reputation for
|solving arbitrary problems in one line of code if they don't pay any
|attention to problem solving?  The big reason I prefer J over a
|language like Fortran is that I can develop code in J (or APL) a lot
|faster than in a less structured language.

What, you think I'm defending FORTRAN, just because I don't like J?

I code in C and I hate it. But C (now) has almost enough type
structure that I can write code that runs as soon as it compiles clean
- presumably because I'm reasonably good at what I do. A tighter type
system would be better still - I spend a lot of extra time typing in C
to try and explain to it that I really WANT checks performed, and I'd
like to lose that by having more of them performed implicitly.

But what you pay for you also can get to use: one of the really nice
things about writing explicit type declarations is - or ought to be -
that the information about the INTENT of the programmer is visible to
the compiler. For instance, all it would take is a type declaration
for "a , b" to catenate lists - but take the union of sets, the
bagunion of bags, and the cons of trees. More generality, more
notational density (in the "throw out the irrelevancy" sense), more of
the underlying APL philosophy - accomplished by having type
declarations, static typing, and abandoning the magic status of
arrays. Heresy? Maybe. But think about it anyway.

J is just too notationally FLABBY to deal with anything outside of its
narrow floats-and-arrays outlook - which is why I say it is cut from
the same cloth as FORTRAN.
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------