HDTenEightyP/NetNews huggingface dataset:
From: rh@smds.UUCP (Richard Harter)
Newsgroups: comp.lang.misc
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Date: 11 Apr 92 03:37:40 GMT
Organization: SMDS Inc., Concord, MA

In article <1992Apr10.091038.25555@newshost.lanl.gov>, jlg@cochiti.lanl.gov (Jim Giles) writes:
> In article <ROCKWELL.92Apr9231849@socrates.umd.edu>, rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:

This is all very interesting and informative, but one wonders when you
guys get any work done!??

:-)
-- 
Richard Harter: SMDS Inc.  Net address: rh@smds.com Phone: 508-369-7398 
US Mail: SMDS Inc., PO Box 555, Concord MA 01742.    Fax: 508-369-8272
In the fields of Hell where the grass grows high
Are the graves of dreams allowed to die.
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Traveller
	<ROCKWELL.92Apr6233655@socrates.umd.edu>
	<1992Apr7.183717.14733@newshost.lanl.gov>
Date: Wed, 8 Apr 1992 05:22:39 GMT

Jim Giles:
   |> [...]  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.

You misunderstand.  I was talking specifically about the case of
writing tools for generating and/or debugging code.  There is no
requirement that all languages must use system dependent features to
implement these sorts of tools.

Or are you saying that there are system-independent ways of
implementing these sorts of tools in Fortran?

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
The U.S. government went another thousand million dollars into debt today.
Newsgroups: comp.lang.misc
From: peter@ferranti.com (Peter da Silva)
Subject: Re: Fortran90 and Arrays
Organization: Xenix Support, FICC
Date: Mon, 13 Apr 1992 18:03:09 GMT

In article <sb9e0INNdbb@network.ucsd.edu> mbk@lyapunov.ucsd.edu (Matt Kennel) writes:
> On the other hand, what does it mean to index an array with a complex number?

Well, that depends. If you're talking about an integral complex number then
it could be quite useful. If you're talking about a complex real then you need
to address the question of what it means to index an array with a real.

Perhaps your array contains a set of experimental results, and you want to
extract the result for a given phase. Then:

	A = array(complex integer) of float;
	c = function_returning_complex_float(args);

	A(c) = x

Becomes equivalent to:

	A = array(integer, integer) of float;

	A(integer(real(c)), integer(complex(c))) = x

[irrelevant discussion about terse languages omitted... I would
 hardly call Smalltalk terse]
-- 
/F{findfont exch scalefont setfont}def /S{moveto show}def /T{/Times-Roman F}def
8 T(Ferranti International Controls Corporation)24 28 S(+1 713 274 5180)24 12 S
(Sugar Land, TX  77487-5012)24 20 S 12 /Courier F(`-_-')320 32 S( 'U` )320 16 S
12 T(Peter da Silva)24 36 S 16 T(Have you hugged your wolf today?)358 24 S
Newsgroups: comp.lang.misc
From: secrist@kxovax.enet.dec.com (Strong datatypes for weak minds.)
Newsgroups: comp.lang.misc
Subject: OPS5 Implementations / Dynamic Master Systems ?
Summary: Looking for OPS5 inexpensive implementations.
Keywords: OPS5 CP/M MS-DOS RT-11 RSX-11/M
Date: 14 Apr 92 04:00:00 GMT
Organization: Digital Equipment Corporation


	I'm looking for inexpensive OPS5 implementations under
	the MS-DOS, CP/M, RSX-11/M, or RT-11 O/S, or alternatively
	something other than the original Forgy LISP implementation.

	Anybody know if a vendor called Dynamic Master Systems is
	still alive ?  The produced OPS5 implementations circa 1986
	for the IBM-PC (unknown O/S) and CP/M-80.

	Regards,
	rcs
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Traveller
	<ROCKWELL.92Apr10233251@socrates.umd.edu>
	<1992Apr13.173414.2319@newshost.lanl.gov>
Date: Tue, 14 Apr 1992 03:38:37 GMT

Jim Giles:
   It seems silly to me to introduce automatic generality to arbitrary
   rank arrays or arbitrary data types when such generality ignores
   the big picture - which is that few algorithms are stable (or even
   possible) in such generality.

Yes, the generality is not automatic -- you must chose your algorithms
carefully.  I prefer to spend my time this way, as I find I get a
bigger payback from time spent in design than I do from time spent in
re-implementation.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Newsgroups: comp.lang.misc
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Date: 14 Apr 92 21:36:59 GMT
	<ROCKWELL.92Apr8151628@socrates.umd.edu> <id.3CVO.D38@ferranti.com>
Organization: University of Chicago CILS

I'd have said that "storage class" referred to the allocation
technology of a cell. So it would be one of, oh,
	compiler allocated
	ditto readonly
	linker allocated
	ditto readonly
	stack allocated
	heap allocated [with gc]
	registered
	malloc()ed
	allocated to a movable area a la Mac handles
	in a file
	...

In short, what class of STORAGE does it use - "storage class".
Orthogonal to scope, type, and representation and only slightly
related to extent and attributes (like mutability and purity).
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Newsgroups: comp.lang.misc
Subject: Re: Fortran90 and Arrays
Date: 14 Apr 92 22:36:53 GMT
	<ROCKWELL.92Apr8001532@socrates.umd.edu>
	<1992Apr8.180420.9294@newshost.lanl.gov>
	<ROCKWELL.92Apr8164502@socrates.umd.edu>
	<STEPHEN.92Apr9214055@estragon.uchicago.edu>
	<ROCKWELL.92Apr10214059@socrates.umd.edu
Organization: University of Chicago CILS

In article <ROCKWELL.92Apr13215324@socrates.umd.edu> rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|Stephen P Spackman:
|   I'm NOT suggesting having no fixed syntax (there are very GOOD
|   reasons not to want that, including implementability and
|   readability). Just that if I want to write a function called
|	      "if ... represents ... then ... end"
|   the fact that there is one called
|	      "if ... then ... else ... end"
|   in the language core shouldn't stop me. Surely you see the
|   difference?
|
|What is it, here, which is fixed?

The SYNTAX. The fact that a keyword construction has the form

	{keyword expression} "end"

Not the choice of identifiers, but where they are placed and how they
are related. How am I failing to communicate?

|I've never programmed in PL/1.  But I'm not sure what you're saying.
|For instance, in your above example, is the syntax of the word
|'represents' independent of the identifier 'represents'?  If so, how
|does this make it easier to read the code?  If not, could you give an
|example of what you're saying?

The identifier in question is if-represents-then-end. Its syntax is as
in my explanation above. Just as when I say f(x), the identifier of
the function is f (which is user-definable) while its
syntax-of-invocation is

	identifier "(" expression ")"

which is fixed.
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
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 00:59:33 GMT
	<BEVAN.92Apr10173700@panda.cs.man.ac.uk>
	<STEPHEN.92Apr13034706@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:46:59 GMT

In article <STEPHEN.92Apr13034706@estragon.uchicago.edu> stephen@estragon.uchicago.edu (Stephen P Spackman) writes:
   In article <BEVAN.92Apr10173700@panda.cs.man.ac.uk> bevan@cs.man.ac.uk (Stephen J Bevan) writes:
   [ type is a "hidden value" that is optimised away in most languages
     with static typing ]

   Nononono! If this were an accurate description, then the type would be
   stored in a field (possibly optimisaed away!) whose type was described
   by a field of type ?

Why do I have to give the "type" field a "type" using the same
construction mechanism?  Trying to do so obviously results in the same
sort of problem as trying to define the set of all sets.  Why can't I
punt on the issue and call the type field an instance of special
"type" which itself can't appear in the "type" field?  (Forgive me if
this is straying too far, but isn't a similar "trick" done in category
theory, where there are "small" and "large" categories?)

bevan
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Organization: Traveller
	<STEPHEN.92Apr9220641@estragon.uchicago.edu>
	<1992Apr10.093445.26931@newshost.lanl.gov>
Date: Sat, 11 Apr 1992 03:27:19 GMT

Jim Giles:
   In J it is apparently possible for type information to come from
   I/O.

There's two ways for this to happen.

First, J objects can be saved and recovered via operating system
mechanisms (files).  These _are_ associated with identifiers.
[Perhaps there ought to be some sort of general predicate mechanism to
protect these?  If so, what do you do when you find out that there's a
bug in your specification?  Rebuild the entire file system from
scratch?]

J can also accept random character data and, via interpreter
operations, execute these as random expressions.  This can be a great
way to shoot yourself in the foot, but it can also be a great way of
giving users control over their data.

   Certainly two different paths through the code may define these
   characteristics differently.  How do you apply static tests to
   things that can inherently vary at run-time according to the very
   definition of the language?

Either specify a statically useful test or live without it.  Assume
here that a certain amount of flow analysis will be used by the
hypothetical compiler.

   |> But clearly both slightly broken and excessively restrictive: on
   |> the one hand the IDENTITY needs to be specified (in case the
   |> array is empty); and the DIRECTED reduce operator requires only
   |> that the function be in (T x U) -> U (resp. (U x T) -> U), where
   |> T is the element type of the array and U is the result type and
   |> the type of the identity element.

   Good point.  However J doesn't appear to have this property either
   (or no one has seen fit to describe it).

IDENTITY is a property of the built in operators, and may thus be
derived for many user-defined operators.  Thus far, only the left
identity is supported, and there's no general mechanism for specifying
an arbitrary identity element for an operation.  Some function
definition methods don't allow for an identity element, so you can't
use these operations to "reduce an empty vector" -- unless you provide
your own reduction operator.

Note that it's pretty easy to define an arbitrary reduction operator
in J.  How arbitrary would depend on the problem you're trying to
solve.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Newsgroups: comp.lang.misc
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Date: 17 Apr 92 07:52:53 GMT
Article-I.D.: estragon.STEPHEN.92Apr17025302
	<STEPHEN.92Apr16042133@estragon.uchicago.edu>
	<SPOT.92Apr16125751@FORTRAN.FOX.CS.CMU.EDU>
Organization: University of Chicago CILS

In article <SPOT.92Apr16125751@FORTRAN.FOX.CS.CMU.EDU> spot@CS.CMU.EDU (Scott Draves) writes:
|i agree with jim.  a language that is very good at doing things in one
|domain is necessarily not so good at other domains (eg, regexps are a
|specialized language for string searching, they are good for just
|about nothing else).  there are languages that are only somewhat
|specialized towards a particular domain, and they are somewhat
|applicable to other domains (eg snobol).  and there are languages that
|are pretty much neutral wrt domain (eg lisp).

There's a profound difference in kind between regexps and SNOBOL, of
course, since only the latter is a programming language in the usual
sense (perhaps Prolog comes close to the line between the two, but
it's still clearly on the language side).

But take a look at SNOBOL. It has a clear APL-like carrier language:
with strict sequential lines and gotos. Within that it has a
FORTRANesque assignment language. Within that it has specialised
pattern matching facilities.

Now look at Icon. Similar pattern matching, in a structured streams
environment. Look at J: APL with the line-oriented frame largely
removed. Look at Perl: pattern matching bound into a C-cum-BASIC.

|why is this true?  it seems that a language is good at a domain if it
|does a lot of stuff from that domain automatically.  basically, you
|want domain specific stuff baked in.  you might think this is bad, and
|that such things should be provided with libraries, but this is a very
|weak form of support.  could you do TeX with a library?  no.

A library is in no sense a "weaker form of support". It's possible to
provide libraries access to the full syntactic repertoire of the
language (Lisp demonstrates this, as does - almost - J). It's possible
for a library to generate JUST as good code as the "intrinsics" (look
at how MSC compiles strings, look at how Algol 68 and Haskell are
designed).

The traditional difference between libraries and intrinsics is that
you can only redefine the name of a library routine. That is neither a
profound distinction nor one that applies in all languages anyway.

|is this defeatist?  no.  you just need a good way to create new
|languages, and still have them communicate.

If they are communicating then they are in some sense part of the same
language. It's just ugly as hell because you're wrapping in, say, the
Unix shell and C and Lisp.... Well, why not just bring everything
together? Everyone needs function call, after all....
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
Newsgroups: comp.lang.misc
From: ian@syacus.acus.oz.au (Ian Joyner)
Subject: C++ Critique in comp.lang.c++
Organization: ACUS Australian Centre for Unisys Software, Sydney
Date: Wed, 8 Apr 1992 12:02:52 GMT

Heading says it all.
-- 
Ian Joyner                                     ACSNet: ian@syacus.acus.oz
ACUS (Australian Centre for Unisys Software)   Internet: ian@syacus.acus.oz.au
Tel 61-2-390 1328      Fax 61-2-390 1391       UUCP: ...uunet!munnari!syacus.oz
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:19:45 GMT

In article <ROCKWELL.92Apr9233337@socrates.umd.edu>, rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|> [... I want to be able to declare conventional variables ...]
|> Define yourself a verb to modify X.  If you're really paranoid, you
|> can write yourself a routine which does a static analysis of the
|> program text to find any instances where X is modified without the use
|> of this access verb.  If you need to do this sort of thing frequently,
|> you can call this routine a tool.

Well, I think it's rather a pain to have to go to such trouble for 
such a simple and common feature.  Simple things should - if common -
be simple to do.

|> [...]
|> I meant that if you compile a function to take only integer arguments
|> that you won't be able to pass to it arguments representing fractional
|> numbers.  The idea is that this is a restriction imposed during
|> compilation, and is not a property of the code.  Of course, you might
|> consider compiler invocation parameters to be code.

Yes, this is what I want.  Can you give an example of how to do it
that's actually statically checked?

|> [...] Then you can tell me the very thing I keep asking and you
|>    keep dodging - how do I declare that a given identifier has a
|>    specific type for the life of the program - yet its _value_ can
|>    change?
|> 
|> I think I'd define an accessor verb.

That's fine to guard accesses.  How do you guard against reassignments?
Note, the `colon' definitions you described earlier prevent the identifier
from being reassigned at all.  What I want is to allow the _value_ to 
be assigned without allowing the type to ever be alterred.

|> [...]
|> Either that or just do a global search for all instances of that name
|> [though this seems, to me, more useful for maintenence than for
|> design].

This is exactly the kind of search I _don't_ have to make if all the 
type declarations are in the header of the current procedure or module.

J. Giles
From: damico@sw.stratus.com (Dennis Damico)
Newsgroups: comp.lang.misc
Subject: Translator wanted, PL/I to ???
Date: 17 Apr 92 14:23:37 GMT
Followup-To: poster
Organization: Stratus Computer, Inc.

Anyone know where I can find a PD or commercial translator that converts
PL/I to C, C++ or other?  thanks
Newsgroups: comp.lang.misc
From: victor@gran-paradiso.tivoli.com (Brian Victor)
Newsgroups: comp.lang.misc,comp.lang.functional,comp.object
Subject: Re: Types as first-class values?
Keywords: russell acm toplas
Date: 16 Apr 92 05:16:31 GMT
Reply-To: victor@tivoli.com
Followup-To: comp.lang.misc
Organization: Tivoli Systems
In-reply-to: oscar@cui.unige.ch's message of 13 Apr 92 16:50:54 GMT


In article <7597@cui.unige.ch> oscar@cui.unige.ch (Oscar Nierstrasz) writes:
> Can anyone provide any references to programming languages that
> treat types as first-class values?

My memory is quite fuzzy here, but there is an interesting paper entitled "Data
Types are Values", by Donahue (?) et. al., published around five years ago in
ACM TOPLAS.  They talk about a programming language, Russell, that illustrates
their ideas.  I believe a free, real working Russell implementation is
available somewhere.  I can get the full reference, if you like.


bv

--
Brian Victor                 Tivoli Systems                 victor@tivoli.com
                   ...!cs.utexas.edu!tivoli!victor
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Newsgroups: comp.lang.misc
Subject: Re: Fortran90 and Arrays
Date: 12 Apr 92 01:13:38 GMT
	<ROCKWELL.92Apr8001532@socrates.umd.edu>
	<1992Apr8.180420.9294@newshost.lanl.gov> <id.6DTO.VWK@ferranti.com>
Organization: University of Chicago CILS

In article <id.6DTO.VWK@ferranti.com> peter@ferranti.com (Peter da Silva) writes:
|How about:
|
|	   The word `type' refers to the set of operations that may
|	   be performed on a collection of data.

This is still a little buggy. Consider the (constructed :-) example of
a language that has two mappings from the same _abstract_ type to the
same storage format - say 1-s and 2-s complement integers (or an int
and an unsigned both being used to hold numbers between 1 and 100, a
very common case in C).

Now the same "operations", like +, may be available for both, even
with the same meanings. But for SOME purposes we want to be able to
say that they have different types - certainly you can't reliably
substitute equals for equals between them without the language's
intervention.

There's definitely something to the "access path" approach, even in
the absence of explicit pointers.
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Traveller
	<ROCKWELL.92Apr9231849@socrates.umd.edu>
	<1992Apr10.091038.25555@newshost.lanl.gov>
Date: Sat, 11 Apr 1992 04:20:43 GMT

Jim Giles:
   |> 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.

Well, at present (April 10, 1992), J's implementation is neither
complete enough or static enough for large scale programming tasks.
That's why I'm still using APL.

But APL also supports such interaction, and the ability to interact
with the language has not appeared to me as a problem.  Maybe not
incredibly useful in an operating program, but it's great for
debugging.

Also note that modern APL supports calling routines in Fortran, and
being called from Fortran, and you can substitute arbitrary languages
for Fortran.  So apparently there is some sort of demand for these
kind of features.  I don't have the slightest idea if this is useful
for you, but it seems closer to the sort of thing you're interested
in.

Me, I'm more interested in bringing J up to speed.

   |> 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?

[a] make sure that the variable refers to a lot of data -- that way
   function call overhead becomes insignificant.

[b] get a compiler working that strips out the run-time overhead.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
Newsgroups: comp.lang.misc
From: peter@ferranti.com (Peter da Silva)
Subject: Re: Fortran90 and Arrays
Organization: Xenix Support, FICC
Date: Sat, 11 Apr 1992 20:33:21 GMT

In article <1992Apr8.180420.9294@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:
> The word `type' means any static attribute which is associated with
> an identifier in such a way that _every_ occurrence of the identifier
> in a given scope has that attribute.

The word `type' has many meanings, including blocks of material with symbols
in relief on one face, used to create multiple copies of a document for
distribution. Even in the context of languages, I think your definition of
the word "type" is a little narrow. How about:

	The word `type' refers to the set of operations that may
	be performed on a collection of data.
	
In traditional languages, type is usually bound to an identifier. In
object-oriented and dynamically typed languages, type is bound to the
data itself. Now I haven't been exactly happy with our friend at UMD
either, but it would really help us onlookers if you would TRY to use
the same language.
-- 
/F{findfont exch scalefont setfont}def /S{moveto show}def /T{/Times-Roman F}def
8 T(Ferranti International Controls Corporation)24 28 S(+1 713 274 5180)24 12 S
(Sugar Land, TX  77487-5012)24 20 S 12 /Courier F(`-_-')320 32 S( 'U` )320 16 S
12 T(Peter da Silva)24 36 S 16 T(Have you hugged your wolf today?)358 24 S
Newsgroups: comp.lang.misc