HDTenEightyP/NetNews huggingface dataset:
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Organization: Traveller
	<ROCKWELL.92Apr10011141@socrates.umd.edu>
	<1992Apr10.103445.1055@newshost.lanl.gov>
	<1992Apr13.153807.9524@yrloc.ipsa.reuter.COM>
Date: Tue, 14 Apr 1992 02:32:18 GMT

Robert Bernecky:
   >|> Yes.  It gets worse: J doesn't allow you to change a single
   >|> element of an array without respecifying the entire array.

   Ahoy, there lad! You is confusing the semantics of the operation
   with its implementation on a real system ...

Yes.  Er, no.

I was speaking of semantics.  "Respecifying" doesn't mean
re-calculating -- or at least it doesn't mean that to me.

   ... NO APL system I have EVER used would perform merge-like
   operations except in place, when reference counts permit.  For most
   operations, the indexed assignment (whether performed with indexed
   assign or a detected merge) IS done in place.

Yes.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Fortran90 and Arrays
Organization: Traveller
	<1992Apr15.233338.3786@yrloc.ipsa.reuter.COM>
	<STEPHEN.92Apr16051241@estragon.uchicago.edu>
Date: Fri, 17 Apr 1992 01:28:15 GMT

Robert Bernecky:
   [Morgan Stanley and stock market crash, fall 1990]:
   |  Morgan's APL-based system not only didn't die (integers went to
   |  real instead of getting integer overflow death), but the system
   |  didn't fall behind, AND Morgan made a profit that day!

Stephen P Spackman:
   This is a practise that will LITERALLY send you to prison in most
   countries. Financial calculations MUST be performed to 100ths of a
   cent (or whatever local law prescribes) and must NOT be rounded
   except as permitted by law.

Eh?  Why would the numbers be rounded?

If integers become large enough to exceed 2 billion pennies (or Lyra,
or whatever it was that was overflowing the statically allocated
space), you can represent them as floating point without any loss of
precision.

Now, sure, they'll have problems when the the numbers get a few
million times larger than this.  And, maybe, if the US economy keeps
going the way it has, you'll see numbers like that next year.  But a
safety net (even if it's not a shiny new one) is nice to have.

   I am literally shocked that you would consider this a good solution
   to a practical problem.

I'm suprised you think that there would have been rounding problems.
But I guess it's a common superstition.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
Newsgroups: comp.lang.misc
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Subject: Re: Fortran90 and Arrays
Organization: University of Chicago CILS
	<ROCKWELL.92Apr8001532@socrates.umd.edu>
	<1992Apr8.180420.9294@newshost.lanl.gov>
	<ROCKWELL.92Apr8164502@socrates.umd.edu>
Date: Fri, 10 Apr 1992 02:40:48 GMT

In article <ROCKWELL.92Apr8164502@socrates.umd.edu> rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|J uses '.' and ':' as inflection marks, which modify the token
|immediately preceeding them on the line.  It's not very hard to
|remember to use <<space dot>> where before you just used <<dot>>.  Or,
|to be more accurate, you must now use <<slash space dot>> where before
|you used <<dot>>.
|
|But I think the thing you're really objecting to is that J doesn't
|impose any reserved words on the user.

Actually, one of my biggest criticisms of J is that it is one of the
worst "reserved word" offenders I've seen: there is a large vocaublary
of operator symbols allowed by J's lexical rules (like & and *:) and
EVERY ONE of them is reserved. If this isn't foolish I don't know what
is. Part of the reason, of course, is that there isn't enough of a
type system to resolve overloads. But it seems really silly to say
"these are my letters and those are yours" and make it impossible to
build application-specific notation within the language.
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
Newsgroups: comp.lang.misc
From: jlg@cochiti.lanl.gov (Jim Giles)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Los Alamos National Laboratory
Date: Wed, 8 Apr 1992 17:00:23 GMT

In article <id.KXOO.61F@ferranti.com>, peter@ferranti.com (Peter da Silva) writes:
|> In article <STEPHEN.92Apr6203432@estragon.uchicago.edu> stephen@estragon.uchicago.edu (Stephen P Spackman) writes:
|> > I think the redefinability of globals is a practical necessity when
|> > writing languages with read-eval-print style interactivity that lack
|> > first-class namespaces. Corrections welcome.
|> 
|> You've fallen into Jim's trap. Since identifiers aren't typed in J, there is
|> no such thing as a redefinition of a global. There is just assignment of a
|> new value with a possible new type.

That's _NOT_ what the supporters of J are claiming.  They are saying that
every occurrence of an assignment introduces a new scope and that the 
assignment was a _definition_ of the variable.

Whatever you call it, an identified may refer to something of different
type in different parts of the program - something which I consider to
be undesirable.

J. Giles
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Subject: Re: What is a type? (was Re: Fortran90 and Arrays)
Organization: University of Chicago CILS
	<BEVAN.92Apr9151907@panda.cs.man.ac.uk>
	<1992Apr10.095151.28116@newshost.lanl.gov>
	<BEVAN.92Apr10180934@panda.cs.man.ac.uk>
Date: Mon, 13 Apr 1992 08:59:41 GMT

In article <BEVAN.92Apr10180934@panda.cs.man.ac.uk> bevan@cs.man.ac.uk (Stephen J Bevan) writes:
|In article <1992Apr10.095151.28116@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:
|   I specified an explicit criterion for deciding what constitutes
|   type: those properties which are permanently associated with a name
|   (or function, expression, etc.) regardless of run-time variations.
|
|And I objected, because I think this is one particular type of `type'
|namely the `static type' of the object.  Whilst it is true that in a
|certain class of languages there is no difference between the `static'
|and `dynamic' type of an object, I don't think you can generalise to
|saying that this means `type' = `static type' and the `dynamic type'
|somehow isn't a `type'.

Wait, wait! Are we talking about LEXICAL occurrences of names or about
INSTANCES? These are profoundly different. Consider the parametric
polymorphic identity function (nonce-notation, . is
lambda-abstraction):

	f: TYPE => (T . T -> T) = T . t . t

Is "t" statically typed? Its type is "T" which is itself an argument
to f.... Statically bound but not lexically bound, I would have said,
but perhaps that isn't the clearest way of expressing it.

|   In a typeless language (say, SmallTalk for variation in the
|   discussion)
|
|Smalltalk is not "typeless" as far as I'm concerned, it has strong,
|dynamic (or latent) types.

I would have said it was unityped: it has *one* type for objects,
which is (formally, internally) a dependent product:

	TYPE =, (T . T)

(Pardon notation!). But strongly typed, certainly.
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
Newsgroups: comp.lang.misc
From: volker@vlsivie.tuwien.ac.at (Volker Hamann)
Subject: Re: "M" language
Reply-To: volker@vlsivie.tuwien.ac.at (Volker Hamann)
Organization: Technical University of Vienna
Date: Tue, 14 Apr 1992 08:35:08 GMT

In <1992Apr12.005850.19735@csn.org> sullivan@teal.csn.org (Steve Sullivan) writes:


>Where can I find info about a language called "M"?
>I've checked Bill Kinnersley's list, and found nothing.

>Many thanks ...

>Steve Sullivan
>sullivan@csn.org

M is a multilevel hardware description language which was developed from C.
As a result, it exposes very close similarities to C.
It was formerly commercially distributed by Silicon Compiler Systems,
which has been bought by Mentor Graphics.
Mentor Graphics still supports this language in a package called GDT.

	Volker Hamann

--
|   /| ! Volker Hamann              ! Email: volker@vlsivie.tuwien.ac.at
|  / | ! Department for VLSI Design ! Phone: (++43 1) 58801-8142
|-/--| ! University of Technology   ! Fax:   (++43 1) 569697
|/   | ! Vienna, Austria              "IS THERE ANYBODY OUT THERE?"
Newsgroups: comp.lang.misc
From: jhf@c3.lanl.gov (Joe Fasel)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Organization: Los Alamos National Laboratory
Date: Tue, 14 Apr 1992 15:23:03 GMT

In article <1992Apr13.172433.1633@newshost.lanl.gov>, jlg@cochiti.lanl.gov (Jim Giles) writes:
|> In article <ROCKWELL.92Apr10230632@so
|> |> [...]
|> |> J's style of programming _is_ a bit different than what is
|> |> traditionally used.  Where it shines is in applicative code:  [...]
|> 
|> Haskell is also vastly different from traditional languages.  Haskell
|> is a strict functional language - so it shines _MORE_THAN_J_ for those
|> applications where applicative programming is natural to the problem.

Well, Haskell is a _nonstrict_ functional language.  I think Jim meant
to say that it is a pure functional language--that is, without any
imperative features.

No flames here--just trying to avoid confusion.

--Joe
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Traveller
	<ROCKWELL.92Apr8151628@socrates.umd.edu> <id.3CVO.D38@ferranti.com>
Date: Tue, 14 Apr 1992 02:43:38 GMT

I wrote:
   > 'storage class' is a concept used when talking about the machine
   > representation of data.

Peter da Silva:
   No, it's used when talking about the lifetime of data...

Yes, that's the meaning used in the C language specification.  C's
treatment of concepts related to 'type' is a bit different from that
of most other languages.  I'm not sure why its terminology should be
used in a discussion of these concepts.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
Newsgroups: comp.lang.misc
From: gudeman@cs.arizona.edu (David Gudeman)
Newsgroups: comp.lang.misc
Subject: Re: What is a type? (was Re: Fortran90 and Arrays)
Date: 14 Apr 92 00:24:55 GMT
Organization: U of Arizona CS Dept, Tucson

In article  <1992Apr13.180334.4861@newshost.lanl.gov> Jim Giles writes:
]In article <15195@optima.cs.arizona.edu>, gudeman@cs.arizona.edu (David Gudeman) writes:
]
]|> [...]                 What JLG describes is usually refered to
]|> as a "static property of an identifier".  The word "type" has several
]|> completely different definitions, but none that I know of refer to
]|> static properties in general.  Furthermore, it is only in low-level
]|> languages that type is an attribute of identifiers at all.  In
]|> high-level languages type is an attribute of a value.
]
]
]It is absolutely false and incorrect that my definition has no application
]to high-level languages.  In fact, I got this definition from the person
]who wrote the abstract semantics definition for Haskell.

What does Haskell have to do with high-level languages?

]It was the
]fact that he stated this particular insight into type (which I agreed
]with) when we disagreed on so much else that particularly impressed it
]into my mind.  His specific statement was, however, that the distinction
]between `type' and `value' is meaningless in languages in which neither 
]is static...

Then his specific statement was wrong.  Given a language with dynamic
types, the expressions "X = Y" and "type(X) = type(Y)" are entirely
different and may have entirely different results.  You might as well
take any function of one argument and claim that there is no
distinction between a value and the result of the function applied to
the value.
-- 
					David Gudeman
gudeman@cs.arizona.edu
noao!arizona!gudeman
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Newsgroups: comp.lang.misc
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Date: 7 Apr 92 01:34:24 GMT
	<ks8boqINN8ht@network.ucsd.edu>
	<ROCKWELL.92Apr5115242@socrates.umd.edu>
	<1992Apr6.193950.5862@newshost.lanl.gov>
Organization: University of Chicago CILS

In article <1992Apr6.193950.5862@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:
|Yes.  You have yet to present _how_ explicitly defined routines are
|delimited and named.  You have yet to present whether such definitions
|may be nested.  You have yet to explain why you think the ability to 
|redefine globals is desirable (I don't think it is).

I think the redefinability of globals is a practical necessity when
writing languages with read-eval-print style interactivity that lack
first-class namespaces. Corrections welcome.
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
From: jlg@cochiti.lanl.gov (Jim Giles)
Newsgroups: comp.lang.misc
Subject: Re: What is a type? (was Re: Fortran90 and Arrays)
Date: 13 Apr 92 18:03:34 GMT
Article-I.D.: newshost.1992Apr13.180334.4861
Organization: Los Alamos National Laboratory

In article <15195@optima.cs.arizona.edu>, gudeman@cs.arizona.edu (David Gudeman) writes:

|> [...]                 What JLG describes is usually refered to
|> as a "static property of an identifier".  The word "type" has several
|> completely different definitions, but none that I know of refer to
|> static properties in general.  Furthermore, it is only in low-level
|> languages that type is an attribute of identifiers at all.  In
|> high-level languages type is an attribute of a value.


It is absolutely false and incorrect that my definition has no application
to high-level languages.  In fact, I got this definition from the person
who wrote the abstract semantics definition for Haskell.  It was the
fact that he stated this particular insight into type (which I agreed
with) when we disagreed on so much else that particularly impressed it
into my mind.  His specific statement was, however, that the distinction
between `type' and `value' is meaningless in languages in which neither 
is static.  It was my extension of this reasoning to use this criterion 
as the definition of `type' as opposed to `value'.

J. Giles
Newsgroups: comp.lang.misc
Subject: Mumps for PCs??
From: mas@skcla.monsanto.com
Date: 7 Apr 92 13:14:21 GMT
Organization: Searle, Skokie, IL
Nntp-Posting-User: omeara

Can anyone recommend a MUMPS language for the IBM pc (either Dos or
Windows).  Any information (companies, reviews, experience, etc ...)
would be helpful.

Please e-mail to MAS@SKCLA.MONSANTO.COM.

Thanks!

John Mas
Newsgroups: comp.lang.misc
From: rbe@yrloc.ipsa.reuter.COM (Robert Bernecky)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Reply-To: rbe@yrloc.ipsa.reuter.COM (Robert Bernecky)
Organization: Snake Island Research Inc, Toronto
Date: Mon, 13 Apr 92 15:33:22 GMT

In article <1992Apr10.093445.26931@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:
>In article <STEPHEN.92Apr9220641@estragon.uchicago.edu>, stephen@estragon.uchicago.edu (Stephen P Spackman) writes:
>|> In article <1992Apr9.003132.5175@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:

Umm, I'm suffering from a bad case of Giles/Rockwell bandwidth 
overdose. May I suggest that you guys duke it out over email, and get
back to us when you're done. Perhaps we can even send Giles a 
J kit, and let him learn it, rather than inundate the net with
misunderstandings. 

Or am I being rude, and everyone else finds this highly edumcational?

Bob

Robert Bernecky      rbe@yrloc.ipsa.reuter.com  bernecky@itrchq.itrc.on.ca 
Snake Island Research Inc  (416) 368-6944   FAX: (416) 360-4694 
18 Fifth Street, Ward's Island
Toronto, Ontario M5J 2B9 
Canada
Newsgroups: comp.lang.misc
From: jlg@cochiti.lanl.gov (Jim Giles)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Los Alamos National Laboratory
Date: Fri, 10 Apr 1992 09:10:38 GMT

In article <ROCKWELL.92Apr9231849@socrates.umd.edu>, rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|> [...]
|> define a set of arbitrary assertions (about code and data, e.g. x is
|>  a member of the set 5, 6, 7, 9)
|> trace execution until an assertion fails
|> allow programmer to modify program
|> allow programmer to continue execution from present location, or after
|>  backtracking, if desired.

I can do that with any language with explicit run-time tests.  Which
is what I assume you must do with J. 

|> [...]
|> The advantage of an interactive session is that you don't have to
|> go through the process of writing programs to solve simple problems.

Ok.  I'll consider J for simple problems.  But it's hardly worth 
learning such an obscure language for such applications.  And the
interaction you covet is a definite liability for large-scale 
programming tasks.

|> [...]
|> Note that if you use access "functions" (verbs) for your global
|> variables you get similar properties.

How do you denote simple variables as functions without paying a
severe run-time penalty?

J. Giles
From: jlg@cochiti.lanl.gov (Jim Giles)
Newsgroups: comp.lang.misc
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Date: 7 Apr 92 18:37:17 GMT
Article-I.D.: newshost.1992Apr7.183717.14733
Organization: Los Alamos National Laboratory

In article <ROCKWELL.92Apr6233655@socrates.umd.edu>, rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|> [...]                               But the Fortran implementation will
|> be considerably more complex, and many of the details will be specific
|> to the operating system under which Fortran is running.

The only things in standard Fortran which are system dependent are those
which must be system dependent on _ALL_ languages.  Things like the
maximum size of an array, the precision of numbers, the available
character set are not things that J can magically avoid dependency
on.

J. Giles
Newsgroups: comp.lang.misc,comp.lang.functional,comp.object
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Subject: Re: Types as first-class values?
Organization: University of Chicago CILS
Date: Tue, 14 Apr 1992 22:46:11 GMT

I'm a little confused by the notion of type you are looking for: the
fact that you specify that you want a membership TEST suggests that
you're thinking of a set theory rather than a type theory at all -
types are properties of the expressions, not the values, *even when
the types are values themselves*.

Languages that provide first-class types include Russell and (the
spectacularly non-trivial) NuPRL (which doesn't think it's a
programming language, but is. We had a language called Brouwer that
used the same logic as the source language for a compiler. I;d point
you at that but I don't thnk there's a running implementation
anymore, or much in the way of literature).

Languages that provide first-class sets? I can't think of any; in
fact, I'm not sure how you could do that. Unless you restricted
yourself to small finite sets a la SETL, most of your primitives would
be too expensive (the advantage of the type-theoretic approach is that
while compilation may fail to terminate unexpectedly, a successfully
compiled programme won't misbehave in that way).
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
Newsgroups: comp.lang.misc
From: jlg@cochiti.lanl.gov (Jim Giles)
Subject: Re: Fortran90 and Arrays
Organization: Los Alamos National Laboratory
Date: Tue, 14 Apr 1992 08:35:05 GMT

In article <id.OCVO.D6A@ferranti.com>, peter@ferranti.com (Peter da Silva) writes:
|> [...]
|> In C, the type is bound to the identifier, so you can set up an alias
|> for a collection of data that treats it as a different type. But the
|> type can still be defined as the set of operations you can perform on
|> that data. This is referred to in C as "type punning" and is considered
|> as bad thing.

Type punnung is illegal in ANSI C.  Casts of pointers to/from anything
but (void *) is undefined.  Unions (when used for punning) are undefined.
Are there any other methods?

J. Giles
From: jlg@cochiti.lanl.gov (Jim Giles)
Newsgroups: comp.lang.misc
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Date: 6 Apr 92 19:39:50 GMT
Article-I.D.: newshost.1992Apr6.193950.5862
Organization: Los Alamos National Laboratory

In article <ROCKWELL.92Apr5115242@socrates.umd.edu>, rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|> [...]
|> The lifetime of a definition created by name=.expr is similar to a
|> '=:' definition, but the definition is additionally tied to the
|> explicitly defined routine in which it appears. [...]
|>
|> [...]
|> Have I left any situation uncovered?

Yes.  You have yet to present _how_ explicitly defined routines are
delimited and named.  You have yet to present whether such definitions
may be nested.  You have yet to explain why you think the ability to 
redefine globals is desirable (I don't think it is).

J. Giles
Xref: sparky comp.lang.misc:1748 comp.lang.functional:500 comp.object:1780
From: raghu@nihdna.ncifcrf.gov (Raghu Nathan)
Newsgroups: comp.lang.misc,comp.lang.functional,comp.object
Subject: help in data structure in PASCAL or C
Date: 17 Apr 92 01:50:29 GMT
Followup-To: comp.lang.misc
Organization: NCI Supercomputer Facility, Frederick, MD

I am posting this for a friend of mine who does not have access to the net. 
If anyone has suggestions, please mail me. 

We can represent each node in a binary tree by
 

          type node
                =record
                 value=integer;
                 link =^node;
                 Rlink=^node;
                 end;

My friend wants procedures 

1. to create a binary tree from a file which contains an inorder and 
post order sequences of a tree T

2. list all the leaf nodes of the tree T.

3. to delete a node S from a binary tree T.

4. list the data files of the nodes of the binary tree T by level.  

Thanks.
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.lang.misc
Subject: Re: What is a type? (was Re: Fortran90 and Arrays)
Date: 14 Apr 92 16:36:59 GMT
	<BEVAN.92Apr9151907@panda.cs.man.ac.uk>
	<1992Apr10.095151.28116@newshost.lanl.gov>
	<BEVAN.92Apr10180934@panda.cs.man.ac.uk>
	<STEPHEN.92Apr13035948@estragon.uchicago.edu>
Organization: Department of Computer Science, University of Manchester
In-reply-to: stephen@estragon.uchicago.edu's message of 13 Apr 92 08:59:41 GMT

In article <STEPHEN.92Apr13035948@estragon.uchicago.edu> stephen@estragon.uchicago.edu (Stephen P Spackman) writes:

   Wait, wait! Are we talking about LEXICAL occurrences of names or about
   INSTANCES? These are profoundly different.

To be honest I'm not sure which is being discussed.  I've a feeling
that some people in the discussion are equating types with
identifiers, whilst I'm trying to relate them to "values" (instances?)


   [parametric polymorphic identity function deleted]

   Is "t" statically typed? Its type is "T" which is itself an argument
   to f.... Statically bound but not lexically bound, I would have said,
   but perhaps that isn't the clearest way of expressing it.
   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

My feelings on the question are summed up by the underlined part :-)


   I would have said it [Smalltalk] was unityped: it has *one* type
   for objects,  which is (formally, internally) a dependent product:

IMHO it has one "static" type, OBJECT, but many "dynamic" types e.g.
integer, string, boolean, set, ... etc.

bevan
Newsgroups: comp.lang.misc