Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10.2 (Tek) 9/28/84 based on 9/17/84; site hercules.UUCP
Path: utzoo!watmath!clyde!burl!ulysses!allegra!mit-eddie!godot!harvard!seismo!hao!hplabs!tektronix!teklds!hercules!franka
From: franka@hercules.UUCP (Frank Adrian)
Newsgroups: net.lang
Subject: Re: levelheight
Message-ID: <369@hercules.UUCP>
Date: Fri, 11-Jan-85 11:49:31 EST
Article-I.D.: hercules.369
Posted: Fri Jan 11 11:49:31 1985
Date-Received: Mon, 14-Jan-85 03:18:42 EST
References: <2673@dartvax.UUCP> <4890@utzoo.UUCP> <247@gumby.UUCP>
Reply-To: franka@hercules.UUCP (Frank Adrian)
Organization: Tektronix, Beaverton OR
Lines: 91
Summary: 

In article <247@gumby.UUCP> g-frank@gumby.UUCP writes:
>> 2.	all high level languages have a variety of types, including
>> 	a string type.
>> 
>> 3.	all high level languages have a way of defining types and
>> 	let you use them conveniently.
>> 
>
>Yup.  But does Lisp qualify for number 3?  How about Prolog?  (This is
>not a rhetorical denial.  I'm curious how you feel about this.)
>
Common LISP qualifies for 3. Interlisp does. In any case, the use of
lists for data structures (although inefficient for the most part) doesn't
cause much confusion. The main problem is that you do have to define
access macros (something that Common LISP gives you automatically), but
how long does it take to write a couple of macros that take the n'th item
down a list? Or else store structure values on the property list. That way
you just do a (get subItem atomRepresentingTheStruct). You can't get much
more high level than that.
Prolog, on the other hand, is a toy...
>> 4.	all high level languages have a way of ``hiding'' information.
>> 	Here I am thinking of procedures and functions, but this can
>> 	include modules as well.
>> 
>
>And not just hiding, but making less susceptible of meddling, and of making
>sure that invocations or uses of the encapsulation mechanism match its
>definition.  In other words, unchecked and sloppy use of pointers, a lack
>of array bounds checking, and no ability to check the number and type of
>parameters to function calls all violate this one, in spirit at least.
>(Don't tell me about lint.  YOU try to find it for anything but an ortho-
>dox Unix system).
>
>
I'm sorry, but I really, really, really dislike strong type checking.
Unless your language allows operator overloading, there is no way to
write generic packages without defining everything as a huge, ugly
union (which sorta defeats the whole notion of the thing, eh?).
Array bounds checking usually just gets in the way.
Optional and multiple length procedure calls are so useful as to make
the idea of the language not having them completely ludicrous.
The only way to get secure code is to get a secure programmer...

>> Can anybody come up with any other heuristics? So far, my favourite
>> of the ``block structured'' types of languages is Algol 68 -- though
>> I am  told that Simula is rather nice as well.
>> 
>
>Modula-2, if you don't mind doing without gotos, and the complete lack
>of a standard for library modules isn't too galling for words.  Ada, if
>you don't mind doing without a compiler.
>
I have to agree with Laura on this one. Algol 68 had one feature that all
languages since then have forgotten... Orthogonality!!! The only language
that comes close in this respect is LISP. Any language that does not have
orthoganality (e.g., allowing me to assign pointers to procedures, etc.)
is brain damaged.

>> For sheer joy of writing code I would rather be writing in Lisp, but
>> I don't think that Lisp is ``higher level'' than Algol: I just have
>> a severe case of Hofstadter's disease (all the world is recursive,
>> and hence wonderful) which I am entirely uninterested in curing...
>> 
>> Laura Creighton
>> utzoo!laura
>
>I think you have the right idea.  What's really needed is a debate on
>two opposing viewpoints:
>
>  "A high level language is fun."
>
>  "A high level language is beautiful, but not fun, because while
>   giving greater expressivity, it also imposes discipline, which
>   humans find inconvenient."  (The European view, I think).
>
>But do you really enjoy writing code?
>
>
>-- 
>      Dan Frank
>
Yes, I do enjoy writing code. I don't like hairbrained notions of some
Godlike imperative called "security" getting in the way. For example,
you tell me how to get a generic routine written in a vanilla PASCAL.
You're right. The second view is a European view. Maybe the programmers
over there are so bad as to need this sort of thing (at least most of
the code I've seen, written by Europeans, is). The first seems to be
an American view. Give me #1 any day and let me get the job done...

				"Same as it ever was..."
					Frank Adrian