HDTenEightyP/NetNews huggingface dataset:
From: gvw@epcc.ed.ac.uk (Greg Wilson)
Newsgroups: comp.lang.misc,comp.lang.scheme,comp.lang.forth,comp.lang.logo
Subject: Summary: Small Language Wanted
Date: 23 Aug 92 10:13:35 GMT
Organization: Edinburgh Parallel Computing Centre

My thanks to everyone who replied to my original posting asking for a
small, public-domain language (and my apologies to all those who've been
annoyed by the follow-up discussion on the merits (or otherwise) of
Fortran, C++, etc.).

The most-suggested language was Scheme; the two implementations most
often suggested were SIOD (Scheme In One Defun), written by George
Carrette (gjc@mitech.com, gjc@paradigm.com), and SCM.  Both are
available from a variety of FTP sites (e.g. altdorf.ai.mit.edu);
however, most of the FTP'd versions of SIOD are V2.3, not the latest
V2.8; that can be had from world.std.com in /src/lisp/siod-v2.8-shar. 
SIOD is about 4000 lines, SCM more than twice that, so I have decided to
go with SIOD, even though it lacks objects (I am told that there are
several OO libraries for Scheme, and I will try to pick up one of
these.) My particular thanks to Brent W. Benson for his help. 

Several other suggestions included:

* several PD versions of Forth
* some PD Logo's
* Sather (an Eiffel-like language whose interpreter is PD)

In addition, Norm Smith has written "Write Your Own Programming Language
Using C++", which describes the implementation of a simple Forth-like
language, while Samuel Kamin wrote "Programming Languages: An
Interpreter-Based Approach", which presents a small Scheme interpreter
and then modifies it to handle APL, Smalltalk, Prolog, and others. 
Finally, Colas Nahaboo (colas@sa.inria.fr) sent me a list of
ready-to-embed languages, for which I am very grateful.

Thanks once again,

 ========================================================================
  Gregory V. Wilson                    ||  For in much wisdom is much
  Technical Coordinator                ||  grief; and he that increaseth
  Edinburgh Parallel Computing Centre  ||  knowledge, increaseth sorrow.
  gvw@epcc.edinburgh.ac.uk             ||               - Ecclesiastes
 ========================================================================
From: napi@jaring.ism.my (Mohd Hanafiah Abdullah)
Newsgroups: comp.lang.misc,comp.compilers
Subject: Rounding modes.
Keywords: arithmetic, question, comment
Date: 26 Aug 92 10:56:01 GMT
Reply-To: napi@jaring.ism.my (Mohd Hanafiah Abdullah)
Organization: Compilers Central

Is there any High Level Language which allows one to select the different
rounding modes as provided by the IEEE 754 floating point standard?

Thanks.

Napi
[Many C implementations have library functions to set the mode dynamically,
e.g. fpsetround() in System V. -John]
-- 
Send compilers articles to compilers@iecc.cambridge.ma.us or
{ima | spdcc | world}!iecc!compilers.  Meta-mail to compilers-request.
Newsgroups: comp.lang.misc
From: sani@att.com (Sani Nassif [227])
Subject: Re: AWK using an array to subscript an array??
Organization: AT&T
Date: Fri, 4 Sep 1992 11:51:39 GMT
X-Newsreader: Tin 1.1 PL5

Anthony P Scott (aps583@huxley.anu.edu.au) wrote (with some edits):
: Say for instance that I wanted to read a line of text containing
: one character and output that line in terms of the postion of the
: letters in the alphabet.
: 
: ie  like:
:  a
:  b
:  c
:  d
: 
: would be printed as:
:  1
:  2
:  3
:  4
: 
: One way I visualized doing this is to read the alphabet into an array
: such as:
: 
: alph[a] = 1
: alph[b] = 2
: alph[c] = 3
: ...
: 
: and then read the line of text into another array by
: 
: {
:     line_arr[NR] = $1
: }
: 
:  and then using something like
: 
: for (i=1; i<=NR; i++) {
:     alph_pos[i] = alph[line_arr[i]]
:     print alph_pos[i]
: }
: 
: However this doesn't work. Does any body have any suggestions?
: Thanks in anticipation.
: 
: Tony Scott

For one thing, you might want to try to have the array contain
the "string" alphabets:

 alph["a"] = 1
 alph["b"] = 2
 alph["c"] = 3

Otherwist, AWK will just put zeros for a, b, c assuming they are
variables. In general, a program to do this might look like:

BEGIN	{
    while (getline < INDEXFILE > 0) {
	index[$1] = ++N
    }
}

{
    print index[$1]
}

where INDEXFILE is passed in pointing to some file that has
your "alphabet".

Sani.
----------------------------------------------------------------------
Sani R. Nassif
(sani.nassif@att.com)
----------------------------------------------------------------------
Newsgroups: comp.lang.misc
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.lang.misc
Subject: Re: Scientists as Programmers (was Re: Small Language Wanted)
Date: 2 Sep 92 09:13:15 GMT
Organization: Department of Computer Science, University of Manchester
In-reply-to: mbk@lyapunov.ucsd.edu's message of 1 Sep 92 20:06:47 GMT

In article <180ignINN60q@network.ucsd.edu> mbk@lyapunov.ucsd.edu (Matt Kennel) writes:
   Scientist computer not bit one syntax about care.

What is writing it in (inconsistent) RP supposed to prove?  I can
produce various versions in English all having a different structure,
so what?  As to the substance of the sentence, this computer scientist
doesn't, but I don't presume to speak for others.  


   I think it would be nice to "import" a set of syntax rules for whatever
   particular domain you're using, so as to make programming in that domain
   easiest.  It won't make compiler writing easiest, but then again, 
   we have our biases, and we don't care that much how hard that task is.
   :-)

A number of languages have been constructed which allow this to be
done to some extent or other, the latest being Galaxy.  Why not try
one of them out and then tell us how you faired.


   Computer scientists have this bias that the choosing the 
   particular permutation of symbols (how disparaging!) is either
   trivial or irrelevant.

It obviously can make a lot of difference to subjective qualities such
as naturalness, readability ... etc., but it makes no difference
whatsoever to the semantics.  To give you an example, when I'm
attempting to implement some mathematical algorithm in FORTRAN, it is
not the syntax that bugs me, rather it is the fact that it forces me
to write at the lowest level, using DO loops to iterate through arrays
... etc.  This is not a matter of syntax, it is one of semantics.
I much more interested in improving the semantics to support higher
level concepts (such as those found in APL, Haskell or partly FORTRAN
90), than fussing over syntax.  One reason for this is to find out
what the required concepts are, rather than get lost in irrelevant
syntax.  For exmple, consider distributed sum and product in maths:
each has a separate notation (sigma, capital pi) and there is no
general distribution notation.  As APL programmers have found, there
are lots of useful things you can do once you have a general notation
for distribution, reducing, scanning ... etc.  I therefore advocate
getting the semantics right, _then_ you can worry about producing a
"nice" syntax.  Of course Iverson has already done this to some
extent, but still FORTRAN looms large and few people use Iverson's
notation in general mathematics.  So whilst I'll agree that "CS
people" could be more flexible and try to accomodate "scientists"
syntactic wishes, I also think that "scientists" could do with
questioning the notation they come up with and look for underlying
concepts rather than producing endless stream of special cases.

bevan
From: ganesh@cs.albany.edu (Ganesh Murugesan)
Subject: Re: Origin of "curried"
Originator: ganesh@karp.albany.edu
Organization: Computer Science Department, SUNY at Albany, Albany, NY 12222
Date: Thu, 27 Aug 1992 16:54:11 GMT

In article <1992Aug26.184302.17123@dg-rtp.dg.com> banksd@hydra.rtp.dg.com (E du^2 + 2F dudv + G dv^2) writes:

>   The discussion of "dope vector"'s etymology reminds me -- what 
>  is the origin of the obligatory "curried add" in lisp examples? 
>  Have you ever encountered this sense of "curry" elsewhere?
>

    I came across the term "currying" in my Prog. Lang. Course, in 
Scheme and Lambda Calculus. 

It was essentially breaking up say n arguments to a function as n functions
taking one argument each, but both methods producing the same result,

eg

	(lambda (x y z)  body)  

         (lambda (x) (lambda (y) ( lambda (z)  body) body) body)

Ganesh
From: ardtlong@adam.adelaide.edu.au (Dale T. Long)
Newsgroups: comp.lang.misc
Subject: Help Needed:
Date: 2 Sep 92 06:38:54 GMT


        I am using Qbasic, the one that comes with Microsoft DOS 5.00 for the
IBM PC. I have a problem in that the space allocated for strings is only
8000 bytes. In the old GWbasic I would have done a CLEAR xxx to free up xxx
amount of bytes. However Qbasic only has the ability to clear the stack using
CLEAR ,,xxx . Paramaters before the first two commas don't do a thing. Is there
a way to allocate more string space? I am using a two dimensional dynamic
string array. Help indicates that individual strings can be up to 32767 bytes
long but I can't even have a single string longer than the 8000 byte limit.
Help also says that a string array can be up to 64K in size. Is there any way
to over come this problem? Is the Qbasic (interpreter) just a sales pitch
that makes people need to buy the full Quick Basic (compiler) out of neccesity?
Has anyone else had this problem? How do I increase the amount of string space
from 8000 bytes?

Dale Long.
ardtlong@adam.adelaide.edu.au
From: peter@ferranti.com (peter da silva)
Subject: Re: Origin of "curried"
Organization: Xenix Support, FICC
Date: Fri, 28 Aug 1992 18:45:22 GMT

In article <1992Aug27.160259.15445@dcs.glasgow.ac.uk> jack@dcs.glasgow.ac.uk (Jack Campin) writes:
>                   I've always thought the culinary analogy ought to be
> "schongefilte" instead - Schonfinkel invented the idea, not Curry, and
> the word suggests removing something rather than, like "currying", adding
> extra ingredients.

I've always thought of it like currying a horse, not currying a meal.
-- 
Peter da Silva                                               `-_-'
$ EDIT/TECO LOVE                                              'U` 
%TECO-W-OLDJOKE Not war?                        Have you hugged your wolf today?
Ferranti Intl. Ctls. Corp.      Sugar Land, TX  77487-5012       +1 713 274 5180
From: mbilbo@digi.lonestar.org (Matt Bilbo)
Newsgroups: comp.lang.misc
Subject: COFF Patcher
Keywords: COFF patcher
Date: 3 Sep 92 18:05:17 GMT
Organization: none

I have been given the requirement to develop an absolute address object
patcher for COFF files.

Obviously this is not something I want to spend 6-8 months working on.

Does anyone know of such a beast?

The basic requirement is to provide the capability of patching COFF
executable programs in the field, with the following restrictions:

o)  Symbolic debug information would not have to be kept upto date.
o)  Patching of the COFF .lib and .init sections (shareable library information)
    will not be required.
o)  Only executable binaries will be required to be patched.
o)  The execution of a COFF disassembler should not be required.
 
Any help or direction is appreciated.

Matt
-- 
----------------------------------------------------------------------------
Matt Bilbo        mbilbo@digi.lonestar.org OR ...!uunet!digi!mbilbo
DSC Communications Corporation   Addr: MS 150, 1000 Coit Rd, Plano, TX 75075
----------------------------------------------------------------------------
Newsgroups: comp.lang.misc
From: banksd@hydra.rtp.dg.com (E du^2 + 2F dudv + G dv^2)
Subject: Origin of "curried"
Date: Wed, 26 Aug 92 18:43:02 GMT
Organization: Data General Corporation, RTP, NC.

The discussion of "dope vector"'s etymology reminds me -- what 
is the origin of the obligatory "curried add" in lisp examples? 
Have you ever encountered this sense of "curry" elsewhere?
From: shome@mailhost.aa.cad.slb.com (Probal Shome)
Newsgroups: comp.lang.misc
Subject: Re: Origin of "curried"
Summary: Haskell B. Curry
Keywords: Currying, Etymology
Date: 31 Aug 92 17:54:33 GMT
Followup-To: <id._HRS.HNK@ferranti.com>
Organization: Schlumberger CAD/CAM at Ann Arbor, MI


Peter da Silva ( peter@ferranti.com ) writes , in comp.lang.misc 
<28 Aug 92 18:45:22 GMT> : 

>In article <1992Aug27.160259.15445@dcs.glasgow.ac.uk> jack@dcs.glasgow.ac.uk (Jack Campin) writes:
>>                   I've always thought the culinary analogy ought to be
>> "schongefilte" instead - Schonfinkel invented the idea, not Curry, and
>> the word suggests removing something rather than, like "currying", adding
>> extra ingredients.
>
>I've always thought of it like currying a horse, not currying a meal.


   Probably it is Curry who is popularly attributed with inventing the operation

rather than Schoenfinkel ?

( The Amerigo Vespuchi/Christopher Columbus phenomenon in reverse ? )

   
   - Probal Shome.

   ( shome@aaaca1.sinet.slb.com )
From: rro@cs.ColoState.EDU (Rod Oldehoeft)
Newsgroups: comp.lang.misc
Subject: Re: Origin of "curried"
Date: 27 Aug 92 14:22:27 GMT
Reply-To: rro@cs.ColoState.EDU
Organization: Colorado State University

In article <1992Aug26.184302.17123@dg-rtp.dg.com>, banksd@hydra.rtp.dg.com (E du^2 + 2F dudv + G dv^2) writes:
|> The discussion of "dope vector"'s etymology reminds me -- what 
|> is the origin of the obligatory "curried add" in lisp examples? 
|> Have you ever encountered this sense of "curry" elsewhere?

Of course this comes from Haskell B. Curry, the American mathematician
and logician who helped make this way of thinking widespread as part
of his (and others') development of combinatory logic.  The act of
currying was invented by Moses Schoenfinkel in 1924. (This comes from
MacLennan's book.)

Guess what else has been done with his name.  Yes, the lazy functional
language Haskell is named for him.

Quel whimsy!

-- 
|--------------------------------------------------------------|
| Rod Oldehoeft                    Email: rro@cs.colostate.edu |
| Computer Science Department      Voice: 303/491-5792         |
| Colorado State University        Fax:   303/491-6639         |
| Fort Collins, CO  80523                                      |
|--------------------------------------------------------------|
| Three outstanding attitudes---obliviousness to the growing   |
| disaffection of constituents, primacy of self-aggrandizement,|
| and the illusion of invulnerable status---are persistent     |
| aspects of folly.   ---Barbara Tuchman, "The March of Folly" |
|--------------------------------------------------------------|
Newsgroups: comp.lang.misc
From: aps583@huxley.anu.edu.au (Anthony P Scott)
Subject: AWK using an array to subscript an array??
Originator: aps583@huxley
Organization: Australian National University
Date: Fri, 4 Sep 92 00:40:20 GMT

Say for instance that I wanted to read a line of text containing
one character and output
that line in terms of the postion of the letters in the 
alphabet.

ie  like:

 a
 b
 c
 d
 e
 f
 g
 h
 i
 j
 k
 l
 m
 n
 o
 p
 q

would be printed as:
1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17 

One way I visualized doing this is to read the alphabet into an array
such as:

alph[a] = 1
alph[b] = 2
alph[c] = 3
...

...
alph[q] = 20

and then read the line of text into another array by

{
line_arr[NR] = $1
}

 and then using something like

for (i=i; i<=NR; i++) {
alph_pos[i] = alph[line_arr[i]]
print alph_pos[i]
}

However this doesn't work.

Does any body have any suggestions?

Thanks in anticipation.

Tony Scott
From: vladimir@Eng.Sun.COM (Vladimir Ivanovic)
Newsgroups: comp.lang.misc
Subject: Constraint Programming Languages: Bertrand, etc.
Date: 25 Aug 92 22:23:04
Organization: Sun Microsystems, Inc.
NNTP-Posting-Host: ronnie

In Wm Leler's book, "Constraint Programming Languages", the appendix gives
an interpreter written in Scheme for an augmented term rewriting system.
Can someone save me the typing (and the inevitable typos) and point me to a
copy?

In the Preface, Wm Leler give as his address P.O. Box 69044, Portland OR
97201 for inquiries on Bertrand, his general-purpose specification
language.  Does anyone have experience with Bertrand and is the address
still good?

Many thanks for any information.

-- Vladimir
--
Vladimir G. Ivanovic                            Sun Microsystems, Inc
(415) 336-2315                                  MTV12-33
vladimir@Eng.Sun.COM                            2550 Garcia Ave.
{decwrl,hplabs,ucbvax}!sun!Eng!vladimir         Mountain View, CA 94043-1100
                         Disclaimer: I speak for myself.
From: jack@dcs.glasgow.ac.uk (Jack Campin)
Newsgroups: comp.lang.misc
Subject: Re: Origin of "curried"
Date: 27 Aug 92 16:02:59 GMT
Reply-To: jack@dcs.glasgow.ac.uk (Jack Campin)
Organization: COMANDOS Project, Glesga Yoonie

banksd@hydra.rtp.dg.com (E du^2 + 2F dudv + G dv^2) wrote:
> The discussion of "dope vector"'s etymology reminds me -- what 
> is the origin of the obligatory "curried add" in lisp examples? 

Named after Haskell B. Curry.  Coined by David Turner at the time he was
working on SASL.  I've always thought the culinary analogy ought to be
"schongefilte" instead - Schonfinkel invented the idea, not Curry, and
the word suggests removing something rather than, like "currying", adding
extra ingredients.  Schonfinkel's original 1924 paper is translated in
Jean van Heijenoort's "A Source Book in Mathematical Logic".

Incidentally, does "Iliffe vector" predate "dope vector"?  It was the usual
word for the concept in the UK for a long time - did Iliffe use them in
Manchester in the mid-50s?  If so, in what language or machine?

-- 
--  Jack Campin    room G092, Computing Science Department, Glasgow University,
17 Lilybank Gardens, Glasgow G12 8RZ, Scotland   TEL: 041 339 8855 x6854 (work)
INTERNET: jack@dcs.glasgow.ac.uk or via nsfnet-relay.ac.uk    FAX: 041 330 4913
BANG!net: via mcsun and uknet     BITNET: via UKACRL    UUCP: jack@glasgow.uucp
Newsgroups: comp.lang.misc
From: gfadel@eng.clemson.edu (George Fadel)
Subject: help using BASIC (gwbasic, basica or qbasic)
Reply-To: gfadel@eng.clemson.edu
Organization: College of Engineering, Clemson Univ.
Date: Thu, 3 Sep 1992 12:37:30 GMT


-I ran into a strange problem with an old basic program.  The program attempts to read from a random access file opened with the following statement:
OPEN,"XXXXXXX.XXX" as #1 LEN=200
The program works on a pc clone running DOS 5.0.  It supposedly ran under DOS 3.2
I brought it to my PC running DOS 4.02?  and keep getting an error message.  It does not seem to like the reclen greater than 128.  
Does anyone have a clue as to why this is happening?  I tried to run the program
with the three basic interpreters mentioned earlier, but to no avail.

Georges M. Fadel 
Clemson University
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.misc
Subject: Re: Mutating Data Organization:  Practical?
Date: 1 Sep 1992 18:29:25 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com

In article <1992Sep1.142643.3061@coe.montana.edu> oususalg@cs.montana.edu (Glassy) writes:
>Suppose the machine representation of one's data could transparently
>mutate in response to the way one uses it.

I've seen data structures that mutate in response to the contents, but not
to the references.  For instance, different hash table designs are
appropriate for different sizes of hash tables.  The Symbolics
implementation of Common Lisp hash tables uses different strategies for
different sizes.

>i mentioned that i'd like to do this mutation 'transparently', because
>as a user of the data, i don't care what its internal representation
>is, as long as i can efficiently monkey with the data right *now* :-).

I don't think it is reasonable to expect good performance in response to a
heuristic determination of access patterns, as you suggest.  By the time
the heuristic recognizes a pattern and mutates the data structure, the
pattern may be mostly done and it's too late.  For instance, if it takes 10
accesses to establish a recognizable pattern, and the application typically
does 11 accesses of a particular type in a row, the data structure is going
to mutate just before the last access, which is going to be pessimal.  And
one or two unusual accesses in the middle of a pattern are likely to
confuse the heuristics.

However, I agree with you that the user shouldn't be concerned with the
representation, either.  However, providing higher-level access hints is
not the same thing as requesting a particular implementation.  Thus, one
might write:

access_mode(data_structure, MODE_SEQUENTIAL);

to indicate that upcoming access to the structure will be sequential.  It's
up to the implementation of the data structure to translate that into
whatever representational strategy is appropriate.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: mbk@lyapunov.ucsd.edu (Matt Kennel)
Newsgroups: comp.lang.misc
Subject: Re: Scientists as Programmers (was Re: Small Language Wanted)
Date: 30 Aug 92 03:14:34 GMT
Article-I.D.: network.17peeqINNkg8
Organization: Institute For Nonlinear Science, UCSD
NNTP-Posting-Host: lyapunov.ucsd.edu
X-Newsreader: Tin 1.1 PL3

bevan@cs.man.ac.uk (Stephen J Bevan) writes:
: In article <17n6fjINNhvt@network.ucsd.edu> mbk@lyapunov.ucsd.edu (Matt Kennel) writes:
:    I have no idea what Mr Rubin really wants but here are a couple of 
:    easy ones of the top of my head:
: 
:     P, D, Q <- singular_value_decomposition(A);
: 
: How about :-
: 
: (p,d,q) = singular_value_decomposition A

This is perfectly sensible.

:    Array index notation:
: 
:    for all i <= j: a(i,j) <- sum over (k) ( b(i,k)*c(j,N,k) )
: 
: I'm not _exactly_ sure what the above does (e.g. is N constant?), so
: the following may be wrong (but it is better than my previous attempt
: which I hopefully cancelled correctly :-)

What I mean is that the upper triangular part of "a" is equal to B *
transpose("C"), but where the matrix "C" is "spread" out through different
parts of a 3tensor arrays.

: 
: foo b c = array bds vs
:   where
:     vs = [ (i,j) := f i j | (i,j) <- range bds, i <= j ]
:     f i j = sum [ b!(i,k)*c!(j,n,k) | k <- range (klb,kub) ]
:     bds = ((ilb,jlb),(iub,jub))
:     ((ilb,klb),(iub,kub)) = bounds b
:     ((jlb,_,_),(jub,n,_)) = bounds c

This is perfectly ridiculous!  I have no clue what that means.
I don't think one should have to write a subroutine to implement each simple
array statement.

: An alternative (and possibly more efficient) version of _vs_ is :-
: 
:   vs = [ (i,j) := f i j | i <- range (ilb,iub), j <- range (i,jub) ]
: 
: Note this is untested as I currently don't have a compiler installed.
: As to the notation, I'll do you a deal: you explain the one you're
: using and I'll explain the one I'm using :-)

What's called "implied summation convention" means "sum over repeated
indices"on the right hand side of the assignment
and iterate over covarying indices on both sides.  (No I didn't invent
this...heard it's also called "Einstein summation convention" as it's
very useful in relativity calculations).

So if C(i,j,k) is a 3-tensor, then 

T(i) = C(i,j,j)

means for each matrix C(i,*,*) compute its trace and assign to T(i).
(Yes the indices should automatically figure out their bounds).

I think it wouldn't be so bad to allow you to explicitly say these things:

for all i T(i) = sum_over(j) C(i,j,j)

sum_over or sum or whatever is the of course just the traditional capital
sigma symbol used in math, and of course all it means is add everything
up.

:    I won't bore you with the obvious complex numbers, exponentiation, etc.
: 
: Why not, you may be pleasantly suprised.
: 
: bevan

--
-Matt Kennel  		mbk@inls1.ucsd.edu
-Institute for Nonlinear Science, University of California, San Diego
-*** AD: Archive for nonlinear dynamics papers & programs: FTP to
-***     lyapunov.ucsd.edu, username "anonymous".
Xref: sparky comp.lang.misc:2808 comp.compilers:1476