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