HDTenEightyP/NetNews huggingface dataset:
From: katz@quilty.stanford.EDU (Morry Katz)
Subject: Case sensitivity
Reply-To: katz@cs.stanford.edu
Organization: The Internet
Date: Thu, 5 Nov 1992 18:01:12 GMT

   Date: Sun, 1 Nov 1992 05:52:01 GMT
   From: Ozan Yigit <oz@ursa.sis.yorku.ca>
   Organization: York U. Student Information Systems Project

   gls@think.COM (Guy Steele) writes:

      How about some arguments of the form, "Case [in]sensitivity is good/bad
      because of how it affects that person over there, or because of
      how it affects how well a group of programmers can work together"?

   Those are the type of arguments [and one can think up a slew of
   them] that require serious study, which appearently neither the
   language designers, nor the advocates on one side of the issues
   or the other, are willing to undertake. This is why one ends up
   with "historial reasons" or "religion". ;-)

I suggest that you attend one of the Scheme Report meetings and
observe the techincal discussions that take place at the forum before
you impune our willingness to apply sreious study to the issues.  Just
because you may disagree with our point of view or because the people
at those meetings have chosen not to type in the entire discussion on
the net does not mean there has not been a serious, protracted, and
well thought out discussion. 

It is in fact the case that "historical reasons" are viewed with great
suspicion boardering on distain in that forum.  Religion since it is
basically a synonym for point of view used by those who disagree with
ones position is impossible to get around.  When individual
fundamentally disagree on a point, it often is the case that this
results from a fundamental difference in perspective that cannot be
changed by pointing to any set of "facts" that their position
contradicts.
--------------------
Morry Katz
katz@cs.stanford.edu
--------------------
From: gls@think.COM (Guy Steele)
Newsgroups: comp.lang.scheme
Subject: Scheme Digest V4 #292
Date: 5 Nov 92 18:36:16 GMT
Organization: The Internet


   Date: 1 Nov 1992 06:16:14 GMT
   From: Brian Harvey <bh@anarres.cs.berkeley.edu>
   Organization: University of California, Berkeley
   Subject: Case sensitivity
   Message-Id: <1cvsneINNn5d@agate.berkeley.edu>
   In-Reply-To: <OZ.92Nov1005201@ursa.sis.yorku.ca>
   To: scheme@mc.lcs.mit.edu

   oz@ursa.sis.yorku.ca (Ozan Yigit) writes:
   >gls@think.COM (Guy Steele) writes:
   >
   >   How about some arguments of the form, "Case [in]sensitivity is good/bad
   >   because of how it affects that person over there, or because of
   >   how it affects how well a group of programmers can work together"?
   >
   >Those are the type of arguments [and one can think up a slew of
   >them] that require serious study, which appearently neither the
   >language designers, nor the advocates on one side of the issues
   >or the other, are willing to undertake. This is why one ends up
   >with "historial reasons" or "religion". ;-)

   I understand neither Guy's original comment nor Ozan's reply.  When one
   says, "I as a programmer would like X," it doesn't mean that one wishes
   to prosper at the expense of others; it means "I see myself as sharing
   common needs with other programmers, and if I want X, perhaps my reasons
   will appeal to others also."

Brian, you are one of the most charitable people I know, and far be
it from me to try to change that.  And I accept what you say above
when "one" = "Brian Harvey".  But I was complaining about more extreme
forms of argumentation that, indeed, struck me as remarkably self-centered.

Once it is established that there is a conflict of desires or opinions,
then a statement of the form "I want X", when others have clearly stated
"I *don't* want X", cannot so clearly be assumed by default to be completely
altruistic, or even benign, in nature.  Indeed, the purpose of my
admittedly oblique comment was to try to focus discussion back on the
needs of the community as a whole rather than of individuals.

\begin{flame}
  American society, in particular, has of late developed a style
  of speaking in which there is much discussion, and claiming,
  of "freedoms" and "rights" and relatively little discussion
  of corresponding responsibilities and obligations--most
  notably the obligation of allowing others to have the same
  rights and freedoms.  This worries me.  So I put in my two
  cents' worth.  Now I'll stand back and let others do the same.
\end{flame}
From: kaplan@marula.cs.uiuc.edu (Simon Kaplan)
Newsgroups: comp.lang.scheme
Subject: SCOOPS and "self"
Date: 10 Nov 92 03:51:23 GMT
Article-I.D.: marula.KAPLAN.92Nov9215123
Distribution: comp
Organization: University of Illinois at Urbana-Champaign

I'd like to be able, in scoops, for an object to be able to refer to
itself.  This would allow one to write methods on a class in which the
objects return themselves as results, or pass themselves as arguments to
other methods, and so on.  The authors of SCOOPS make the argument that
such facilities are not necessary, but I cannot see how to avoid an
equivalent of SmallTalk's self, c++'s this, etc.  

Since Scoops does not have a "self" in object right now, if anyone can help
me modify scoops to do this I'd be most greatful.   I've tried some obvious
(to me) things, but have not seemed to get it to work.  

If anyone has working code that does this, that would be even better.
Ideally we need it for PC Scheme and MIT CScheme 7.x.  


thanks
Simon Kaplan
--
Simon Kaplan					ConversationBuilder Project
Human-Computer Interaction Laboratory
Department of Computer Science			kaplan@cs.uiuc.edu 
University of Illinois at Urbana-Champaign	uiucdcs!kaplan@uunet.uu.net
1304 W. Springfield Ave				phone: +1 217 244 0392
Urbana Illinois 61801, USA			fax:   +1 217 333 3501
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.scheme
Subject: Re: Code is not portable across case folding methods
Date: 5 Nov 1992 18:48:48 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com

In article <PK.92Nov5142038@talitiainen.cs.tut.fi> pk@cs.tut.fi (Kellom{ki Pertti) writes:
>I have run into this, but in a different way: I have a Scheme reader
>that reads Scheme expressions, and returns a data structure that is
>basically the s-expression with information about where in the source
>file the expression was. The reader uses string->symbol to make a
>symbol out of the string it has read, but for example in sci I get
>
>  (string->symbol "define") => \d\e\f\i\n\e

This is not the only problem with trying to use string->symbol for this.
Consider:

(string->symbol "\#f") -> \\\#f

when it should result in \#f.  Unless you're prepared to emulate all the
features of the reader prior to calling string->symbol, you can lose
lose.  This is why Common Lisp has READ-FROM-STRING.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: spot@CS.CMU.EDU (Scott Draves)
Newsgroups: comp.lang.scheme
Subject: case sensitivity
Date: 6 Nov 92 17:36:19 GMT
Article-I.D.: cs.BxB28r.356.1
Distribution: comp
Organization: School of Computer Science, Carnegie Mellon University
Originator: spot@HOPELESS.MESS.CS.CMU.EDU



i think we would all agree that things work best when the different
parts of a software system use the same alphabet.  if you are adding a
new component to a system, you benefit by using the common subset of
the other systems you communicate with for your alphabet: that way you
can talk to all the existing components.  when lisp, and later, scheme
were designed, a significant proportion of the software world was case
insensitive.  it made sense to choose insensitivity then.  i think the
basis for that decision is gone.  i think most scheme users now work
on case sensitive systems (eg unix), and that scheme will need to
communicate with more case sensitive systems in the future.  i think
this is far more important than the code remembering/vocalizing
issues.  as someone else mentioned, the real issue is alphabet
independence, not just case in/sensitivity.  i wouldn't recommend just
changing what the standard has to say about case, but making the whole
thing parameterized in some way.

-- 
				orgasm
Scott Draves			nitrous
spot@cs.cmu.edu			death
From: kend@data.rain.com (Ken Dickey)
Newsgroups: comp.lang.scheme
Subject: Re^2: Case sensitivity
Date: 5 Nov 92 18:37:04 GMT
Article-I.D.: data.728
Organization: Microtek DSD, Hillsboro, OR

schwartz@roke.cs.psu.edu (Scott Schwartz) writes:

>How about, we should make a case sensitive language because that way
>it is easier to interoperate with popular languages like C and C++.
>Does that count as an argument for helping other people?

I equate this with the argument that we should not use first class
procedures so as to make it easier to interoperate with C/C++.


-Ken
--------------------------
C++ is a language you want your competitors to use.
Newsgroups: comp.lang.scheme
From: rolfl@ulrik.uio.no (Rolf Lindgren)
Subject: Re: Scheme Digest V4 #292
Organization: Institutt for Humanistisk Informatikk, Blindern, Oslo, Norway
Date: Fri, 6 Nov 1992 08:16:18 GMT

In article <9211051836.AA07012@ukko.think.com> gls@think.COM (Guy Steele) writes:
>   Once it is established that there is a conflict of desires or opinions,
>   then a statement of the form "I want X", when others have clearly stated
>   "I *don't* want X", cannot so clearly be assumed by default to be completely
>   altruistic, or even benign, in nature.  Indeed, the purpose of my
>   admittedly oblique comment was to try to focus discussion back on the
>   needs of the community as a whole rather than of individuals.
>
>   \begin{flame}
>     American society, in particular, has of late developed a style
>     of speaking in which there is much discussion, and claiming,
>     of "freedoms" and "rights" and relatively little discussion
>     of corresponding responsibilities and obligations--most
>     notably the obligation of allowing others to have the same
>     rights and freedoms.  This worries me.  So I put in my two
>     cents' worth.  Now I'll stand back and let others do the same.
>   \end{flame}
>

This is not particular to American culture. This has been going on in
Europe for so long that the pendulum is starting to turn in the other
direction, i.e. it's no longer automatically considered 'fascistoid' to
talk about responsibility and obligation.

--
       Rolf Lindgren           |       "The opinions expressed above are
       616 Bjerke Studentheim  |        not necessarily those of anyone"
       N-0589 OSLO 5           |           rolf.lindgren@usit.uio.no 
Newsgroups: comp.lang.scheme
From: montas@stable.ecn.purdue.edu (Hubert J Montas)
Subject: Re: PC Scheme/Geneva release 4 available !
Organization: Purdue University Engineering Computer Network
Date: Thu, 5 Nov 1992 21:43:27 GMT

In article <Bx8HAw.Drv@news.cso.uiuc.edu> sas52992@uxa.cso.uiuc.edu (Sanjay Ashok Sheth) writes:
>
>One possibility may be an interface similar to one present in Schematik for the
>NeXT operating system. The main features are that it is possible to have 
>multiple windows open at the same time - for example, one for the kernel/
>interpreter and one for the editor. In Schematik, they also replace Edwin with
>an editor in which you can  use the mouse to move around the source code of
>your program and highlight text to cut/copy/paste. This is a very useful
>function that is much harder to do in a character based editor like Edwin.
>
>Another feature that would be useful would be that you could use the Windows
>help interface to possibly provide some help or description for all the 
>commands. (i.e. for the let construct, you could have a little window where
>the syntax of the command is explained as well as possibly an example of it
>in use -- mainly the same kind of thing as the MIT Scheme manual.)
>

     Yet another window-based improvement: the possibility to evaluate a
lambda expression by selecting it with the mouse and then using the app-
ropriate menu option. Smalltalk V/PM has that feature for OOP. I just
never really got round to remebemring the appropriate PC Scheme Edwin
commands for evaluating a single lambda expression and returning to break
mode.
     A question: does Schematik do that, and does it run on SPARCs under
X or OpenWindows?

     Hubert.
From: jpiitula@plootu.Helsinki.FI (Jussi Piitulainen)
Newsgroups: comp.lang.scheme
Subject: Re: Case sensitivity
Date: 6 Nov 92 13:00:19 GMT
Organization: University of Helsinki

> Just because [...] the people at those meetings have chosen not to
> type in the entire discussion on the net does not mean there has not
> been a serious, protracted, and well thought out discussion.

I would like to see at least the minutes of the meetings.  The last I
know are R4RS and what has appeared in nexus.yorku.ca---and I have no
idea whether, say, SYNTAX-CASE has been discussed, liked or disliked
among the authors.

While I trust that good work is being done somewhere, I would like to
know more.  Other people have expressed similar wishes, in
comp.lang.scheme, with little response.  Would the Scheme community
not be well served with more open policy?

I suppose CALL-WITH-VALUES and VALUES have been accepted---am I right?
Will MAKE-RECORD-TYPE ever be there?  Has SYNTAX-CASE been supported?
Is some version of EVAL being discussed?  Environments?  What about
error handling?  What current issues am I missing?

--
Jussi Piitulainen
jpiitula@waltari.helsinki.fi
Newsgroups: comp.lang.scheme
From: kobler@informatik.tu-muenchen.de (Daniel Kobler)
Subject: case sensitivity
Organization: Inst. fuer Informatik, Technische Univ. Muenchen, Germany
Date: Fri, 6 Nov 1992 06:23:57 GMT
Distribution: comp.lang.scheme

hi,

when I asked about the WHY of 'Wall being different from 'WALL a
couple of weeks ago I didn't expect to rise a discussion like this.

Well I know I'm talking about a religious issue, but ...

    'Wall is claimed to be the same as 'WALL,

whereas

    (string->symbol "Wall") and (string->symbol "WALL") are different.

And again my question: why these differences? Wouldn't it be better to
do it the one OR the other way, i.e. allow symbols with upper/lower
case letters or strictly converting all letters inside symbol names to
the case preferred by the respective implementation?

-Daniel ][
--
Daniel Kobler                        kobler@kiss.informatik.tu-muenchen.de
 TU  Muenchen, Arcisstr.21,          "Once upon a time I had a good girl,
 8000 Muenchen 2, Germany             once upon a girl I had a good time."

Newsgroups: comp.lang.scheme
From: katz@quilty.stanford.EDU (Morry Katz)
Subject: Case sensitivity
Reply-To: katz@cs.stanford.edu
Organization: The Internet
Date: Fri, 6 Nov 1992 17:51:34 GMT

   Date: 	Thu, 5 Nov 1992 22:22:41 -0500
   From: Ozan Yigit <oz@sis.yorku.ca>


   > I suggest that you attend one of the Scheme Report meetings and
   > observe the techincal discussions that take place at the forum before
   > you impune our willingness to apply sreious study to the issues.

   I will be there next time around, time and money permitting [and of
   course, guests permitting, as I stand a good chance of being declared
   a persona-non-grata by then. :-)] . In any case, I took Steele's
   commentary to be applicable to many of the current languages in
   general, and I responded in general. Based on my reading [or skimming]
   of most every scrap of published material on scheme [see my biblio],
   I happen to think that Scheme may be quite unique in its development
   with respect to people carefully studying various semantic issues.
   But, even in Scheme, can the same be said of issues of syntax? If so,
   maybe I am missing something, and feel free to correct me. If not, why
   not? If issues such as case sensitivity matter, why not study them
   properly?

Syntax issues have been discussed in the past.  In particular, there
have been long and heated discussions about naming of functions.
Until now noone seemed to feel very strongly about case.  I suspect
that this issue will be raised and discussed at R6RS.

					   ... When individual
   > fundamentally disagree on a point, it often is the case that this
   > results from a fundamental difference in perspective that cannot be
   > changed by pointing to any set of "facts" that their position
   > contradicts.

   I am well aware that some people will close their eyes, grit their teeth
   and ignore any set of "facts". I just want to know what those facts are,
   if they exist at all.

You missed my point (or maybe I stated it poorly).  In many cases
there are no incontroverible facts.  More precisely, what are stated
as facts are actually a combination of fact and interpretation of
those facts.  Two individuals with very different interpretations and
goals may never be able to come to the same comclusion, even in the
absence of pure religion.
------------------------------------------------------
Morry Katz
Rockwell Science Center
administrator@rpal.rockwell.com (machine administration issues)
katz@rpal.rockwell.com (other)
------------------------------------------------------
From: pk@cs.tut.fi (Kellom{ki Pertti)
Newsgroups: comp.lang.scheme
Subject: Location tags of primitive procedures
Date: 13 Nov 92 12:26:24
Organization: Tampere Univ. of Technology, Finland.
Distribution: comp
NNTP-Posting-Host: talitiainen.cs.tut.fi

R4RS requires that each procedure created as the result of evaluating
a lambda is tagged with a storage location. This location can then be
used for comparing procedures with eqv? and eq?. My question is: does
this also hold for builtin procedures, and if it does, do the tags of
builtins have to be unique?

I have run into situation in practise where this matters. In my
debugger I try to catch application of a primitive procedure that
would cause a runtime error. This is done by having an alist of
procedures and associated information about the parameters they
accept, for example

  ...
  (,close-input-port (1 ,(assert 1 input-port?)))
  (,close-output-port (1 ,(assert 1 output-port?)))

Before a procedure is actually applied, it is first looked up in the
alist. Thus, for the call

  (close-output-port port)

the entry for close-output-port is fetched. There is only one
parameter, so that part is ok, and if the value of port is an output
port, the call will be made.

It now happens that in scm there is a more general procedure
close-port, to which both close-input-port and close-output-port are
bound, which makes perfect sense to me. For my debugger it does not
make sense, though, because it will find the entry for
close-input-port, and test wether the value of port satisfies
input-port?.

I know how to work around this (as T. Kurt Bond suggested in his bug
report): redefine close-input-port and close-output-port using lambda,
and everything will be all right. However, I can imagine other situations
where it would be nice for builtin procedures to have a unique
identity. 
--
Pertti Kellom\"aki (TeX format)  #       These opinions are mine, 
  Tampere Univ. of TeXnology     #              ALL MINE !
      Software Systems Lab       #  (but go ahead and use them, if you like)


Newsgroups: comp.lang.scheme
From: 71020.1774@compuserve.COM (Terry Kaufman)
Subject: CTY-JHU switching to Scheme
Organization: The Internet
Date: Tue, 10 Nov 1992 19:02:06 GMT

The Center For Talented Youth Program at The Johns Hopkins University
(CTY-JHU) teaches a 3-week computer science course each summer to about
200 very talented 7th, 8th, and 9th graders.  Last summer they tried out
Scheme using "The Schemer's Guide" and EdScheme with 18 students in one
of their 10 sections.  They were so pleased with the results that they
decided to use Scheme with all of their CS students this coming summer.

When I spoke to Robyn Krentz, the administrator for CTY, she indicated
that they have a need for several instructors experienced in teaching
Scheme.  If you are qualified and interested in teaching a 3-week course
during the summer, you should contact Robyn for more details on 
(410) 388-8427.

... Terry


Newsgroups: comp.lang.scheme
From: A4422DAB@vm.univie.ac.at (Erich Neuwirth)
Subject: arity problem
Organization: University of Vienna
Date: Thu, 12 Nov 1992 23:43:22 GMT

i want to do the following:
i need a function which takes a logical function as input and
returns the function which is just the negation.
as long as i know the arity of the input function it is easy
to write this meta function just uning lambda, but i want this
operation to work with functions of any arity (=number of arguments)
in the best case it even should work with functions with variable arity.
is there a way to acomplish this?
Newsgroups: comp.lang.scheme
From: matt@volga.Berkeley.EDU (Matt Wright)
Subject: Re: arity problem
Organization: University of California, at Berkeley
Date: Fri, 13 Nov 1992 18:01:32 GMT

Erich Neuwirth writes:
>i want to do the following:
>i need a function which takes a logical function as input and
>returns the function which is just the negation.

(define (negate f)
   (lambda args
      (not (apply f args)) ))


If the first "argument" to lambda isn't a list, then the function that's
returned takes any number of arguments.

You can also say

(lambda (foo bar . baz)
    ...)

Meaning two or more arguments.  The first is foo, the second is bar, and the
rest (if any) are put in a list that baz is bound to.

-Matt
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.lang.scheme
Subject: Re: overwriting files?
Date: 7 Nov 92 13:40:50 GMT
Organization: Department of Computer Science, University of Manchester
In-reply-to: dorai@cs.rice.edu's message of 5 Nov 92 22:58:25 GMT

In article <Bx9MHE.6MM@rice.edu> dorai@cs.rice.edu (Dorai Sitaram) writes:
   Imho, Scheme needs to allow _some_ way to test if a file
   exists and to delete a file. 
   [ some systems return #f when failing to open a file ]
   I'm curious that this area remains untouched in all the reports.

I assumed (without any foundation) that the reason this area hadn't
been touched upon was because one possible soulution involves
"exception handling" whose status has yet to be decided upon.  For
example, if you try to open a file that doesn't exist should you
return #f or call an "exception" (or just leave it undefined :-).  If
"exceptions" are to be used, ther are number of different styles
ranging from DIY cheap and cheerful ones created with say
macros+call/cc+set! to larger ones requiring additional primitives
such as the Common Lisp and MIT Scheme condition systems.

bevan
Newsgroups: comp.lang.scheme
From: hester@informatik.uni-wuerzburg.de (Christian Hestermann)
Subject: Wanted: Solutions to Abelson/Sussman: Struct. & Interpr. of Comp.-Programs
Followup-To: comp.lang.lisp
Organization: Inst. Informatik VI, Univ. Wuerzburg
Date: Thu, 5 Nov 1992 18:14:45 GMT

Hi you, 

does anyone know if there is a list or even a book with solutions to the 
exercises from Abelson/Sussman? I am an assistant at the Institute for 
Artificial Intelligence in Wuerzburg (Germany) and will use the book for 
an introductory course in computer science and would like to control (and 
improve) my own solutions. 

Thanks for any hint!

Christian Hestermann
Lehrstuhl Informatik VI
Universitaet Wuerzburg
Allesgrundweg 12                         Tel. 0931 / 70561-11
W-8708 Gerbrunn              e-mail: hester@informatik.uni-wuerzburg.de
Germany
Newsgroups: comp.lang.scheme
From: rpg@cs.tulane.edu (Robert Goldman)
Subject: Modules for Scheme
Reply-To: rpg@cs.tulane.edu (Robert Goldman)
Organization: Department of Computer Science, Tulane University
Distribution: comp
Date: Wed, 11 Nov 1992 02:37:48 GMT
Nntp-Posting-Host-[nntpd-6201]: clones


I was considering composing a package of definitions to give a
module facility to Scheme (Scheme does what we want with just
lexical scoping, o' course, but I would like to augment the syntax
to enhance readability).  I would like to take a look at any such
packages which exist now to avoid reinventing the wheel.  Any
pointers to such would be appreciated.

Best,
R