Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!laura
From: laura@utzoo.UUCP (Laura Creighton)
Newsgroups: net.lang
Subject: Re: levelheight
Message-ID: <4950@utzoo.UUCP>
Date: Thu, 17-Jan-85 22:41:00 EST
Article-I.D.: utzoo.4950
Posted: Thu Jan 17 22:41:00 1985
Date-Received: Thu, 17-Jan-85 22:41:00 EST
References: <2673@dartvax.UUCP> <4890@utzoo.UUCP>, <247@gumby.UUCP>
Organization: U of Toronto Zoology
Lines: 95

Reply to Dan Frank:

I don't know how many people use the ``well, the ++ instruction was
clearly designed for the pdp11, therefore C is low level'' argument.
I have heard at from at least 10 independent sources, though. Maybe
it is only a Toronto-area-argument against using C.
The lack of pass by reference (explicitly) is interesting. It is
funny, but I don't see it as any more difficult to say ``*c'' than
``var c''. The problem I get to see a lot with languages that 
have explicit pass by reference is that *everything* is done by
pass by reference! Of course, no language can ever protect one from
stupidity...

I find that I almost never use arrays when writing C. I always use
pointers instead. it gets me wonderfing as to whether thinking of
arrays is a very good coceptual model at all. With double and
triple pointers I can have very non-regular shapes of data, which
has often proven useful. I can still remember how getting used to
not being able to dynamically build arrays the way I was used to
used to drive me nuts when I was first using C, though.

Of course, the concept of a ``for loop'' took a while to get used to
as well...

I have sometime used ``if (disaster) goto error_exit'' type constructs,
but not all that frequently. I have found that in C you almost always
can use perror to get what you want. THESE DAYS THE *error* ROUTINE IN
KERNIGHAN AND PIKE'S BOOK THE UNIX PROGRAMMING ENVIRONMENT IS A MUCH
BETTER SOLUTION THAN *perror*. COULD EVERYBODY PLEASE USE IT? [Thanks,
this has been a free announcemnet by the ad-hoc committee to improve
the quality of life for C programmers everyhere...]

Lisp qualifies for ``all high level languages have a way of defining
types and letting you use them conveniently''. Or, at least, COMMON
Lisp does. Right now there are too many Lisps... but any lanuage which
can write things like ``give me the third noun on this list which is
abstract, plural and starts with the letter ``g'' '' is rather good
at defining complicated types. . . . just different at it than the
normal block-structured type languages.

I don't know about Prolog. the last time I looked at Prolog I said
``shudder! Case is important in this language! My eyes will never
hack this one -- I will go away and only come back if there is so
much interest in this one that I figure it is worth my while, even if
I already know I will never program well in the language.'' I just can't
tell the differnce between `c' and `C' and `s' and `S' for instance, to
ever be very comfortable with the language.

Lint should be rather easy to write for any non-Unix system. I keep meaning
to write one and sell if to the PC world and make a fortune -- when I have 
time. Somehow, I never have time...

I think that the ``A high level language is fun'' versus ``A high
level language is beautiful, but not fun, because while giving
greater expressiveness it also imposes discipline, which human beings
find inconvenient'' debate is unnecessarily dividing.

Of course a high level language is fun! Watching yourself think in
efficient and different ways is always fun. I am not kidding about
learning a new language as a consciousness-raising experience. If
it were not fun, I would not do it. For the same reason it is
beautiful. but discipline is not the bitter pill so many people
think it is. If you want to do somethin well, you impose your own
sort of discipline and definition of ``what is well'' on the subject.
Haven't you ever written a particularily neat piece of code and looked
at it full of elation and thought ``wow! is that ever gorgeous!''?

If not, I question why you are doing whatever you are doing in this
field. Wonderful opportunities for sheer joy like this should not
be passed up. Of course, there are some people who write abysmal
code (the kind that it pains me to read) and probably feel good about
writing it. I figure that these people are the ones in need of more
discipline. [I remember the horrid days when I wrote code that I would
retch at now...anybody out there who has code written before 1978 by
me, kindly do the world a favour and burn it...]. They are busy with
self-deception when thy try to claim that their trash is ``perfectly
good code'' and really haven't ``groked in fullness'' how truly
beautiful well written code can be... (thanks to Robert Heinlein)

Once they have, the effort that goes into discipline gets sent back
hundredfold in the joy of writing really good code, so it is no big
effort.

I can't say that I have found code written by Europeans to be in any
way more disciplined (read: less trashy) than code written by North
Americans.  There is a better chance that it is written in
Algol 68 if it was written by a European which I find very pleasing to
read, but that is not the same thing...

Frank Adrian is right. Orthagonality is beautiful to contemplate and
beautiful to use.

Laura Creighton
utzoo!laura