HDTenEightyP/NetNews huggingface dataset:
From: hanche@ams.sunysb.edu (Harald Hanche-Olsen)
Subject: Re: Something I don't understand about bindings
Organization: University at Stony Brook, NY
Date: Tue, 15 Dec 1992 18:43:43 GMT

>>>>> On 15 Dec 1992 17:03:04 GMT, doner@Aero.org (John Doner) said:
John> NNTP-Posting-Host: armadillo.aero.org

John> In article <a2vogler.724431792@rzdspc23>, a2vogler@rzdspc23.informatik.uni-hamburg.de (Christian Vogler) writes:

John> |> The following fragment is supposed to measure how much time
John> |> execution of the procedure took (assuming that there is a
John> |> runtime primitive):
John> |> 
John> |> (define (timed-prime-test n)
John> |>   (define start-time (runtime))
John> |>   (define found-prime? (prime? n))
John> |>   (define elapsed-time (- (runtime) start-time))
John> |>   (print n)
John> |>   (cond (found-prime?
John> |>          (print " *** ")
John> |>          (print elapsed-time))))
John> |> 
John> |> The procedure then correctly prints the elapsed time for finding
John> |> a prime number, but why does this work?  [...]

John> You are probably interpreting the define's as defining
John> functions, whereas they are actually binding variables to new
John> locations and assigning numeric values to those locations.  The
John> defines are evaluated sequentially, and all three of start-time,
John> found-prime?, and elapsed-time have their values before the
John> printing begins.

That is not what r4rs says.  Indeed the above code is completely
equivalent to

  (define (timed-prime-test n)
    (letrec ((start-time (runtime))
	     (found-prime? (prime? n))
	     (elapsed-time (- (runtime) start-time)))
      (print n)
      (cond (found-prime?
	     (print " *** ")
	     (print elapsed-time)))))

which should not work, in standard r4rs scheme.  Not only is the order
of evaluation in a letrec unspecified, but as it says in the section
of internal defines:

Just as for the equivalent \ide{letrec} expression, it must be
possible to evaluate each \hyper{expression} of every internal
definition in a \hyper{body} without assigning or referring to
the value of any \hyper{variable} being defined.

I can only conclude that the original poster uses a non-r4rs
conforming scheme.

- Harald
Newsgroups: comp.lang.scheme
From: burchard@horizon.math.utah.edu (Paul Burchard)
Subject: SET-WRITE-CIRCLE! in Scheme-to-C (for Thomas)?
Keywords: dylan thomas scc sci scheme scheme-to-c
Organization: University of Minnesota
Date: Sat, 12 Dec 1992 04:18:35 GMT

I am trying to use DEC's Thomas implementation of Dylan with Scheme-to-C.   
 
Everything works fine, except that none of the 01nov91 versions of Scheme-to-C that I've been able to find define certain very necessary functions whose purpose is to prevent infinite looping when circular data structures are printed out in the REPL.  These functions are called in the M 
 
AIN routine.

These functions include for example SET-WRITE-CIRCLE!.  The Thomas README refers me to sci docs for more info, but the functions simply don't exist.  I've tried writing a replacement but I wasn't able to figure out enough of the internals of both systems.

How are other folks getting Thomas to run?
--
--------------------------------------------------------------------
Paul Burchard	<burchard@geom.umn.edu>
``I'm still learning how to count backwards from infinity...''
--------------------------------------------------------------------
Newsgroups: comp.lang.scheme,comp.lang.lisp
From: net@cs.tu-berlin.de (Oliver Laumann)
Subject: Re: Want history/command editing facilities in free Lisps
Organization: Technical University of Berlin, Germany
Date: Wed, 16 Dec 1992 10:04:02 GMT

> I'm really thankful to all of the free Lisp and Scheme
> implementors out there, but I want to put in a plug for adding a
> command line editing/history mechanism to these programs.  If I
> were a real C programmer, and had time, I suppose I'd do it myself. 

While we're at it-- how about symbol completion?  How many times have
you typed "call-with-current-continuation" in an interactive Scheme
session *without* making a typo?  (Not to mention the function
"empty-list-is-false-for-backward-compatibility" that is provided
by Elk 2.0a).

Symbol completion should be easy to implement on UNIX systems that
support a user-defined end-of-line character (like the tty interface
of 4.3 BSD and the "termio" interface do).

--
Oliver Laumann    net@cs.tu-berlin.de  net@tub.UUCP  net@tub.BITNET
From: bh@anarres.CS.Berkeley.EDU (Brian Harvey)
Newsgroups: comp.lang.scheme
Subject: LOAD in what environment?
Date: 15 Dec 1992 06:59:40 GMT
Organization: University of California, Berkeley
Distribution: world
NNTP-Posting-Host: anarres.cs.berkeley.edu

It's not clear to me from r4rs what happens if you call LOAD other than
at toplevel.  I'd like to be able to do a quick-and-dirty autoload by
saying

(define (foo . args)
  (load "foo.scm")
  (apply foo args))

but I suspect that compiler writers would rather that I not be allowed
to do that.  Can anyone clarify this for me?  Tnx.
Xref: sparky comp.lang.scheme:2751 comp.lang.lisp:3085
From: gjc@mitech.com (George J. Carrette)
Newsgroups: comp.lang.scheme,comp.lang.lisp
Subject: Re: Want history/command editing facilities in free Lisps
Date: 15 Dec 92 10:49:06 GMT
Organization: Mitech Corporation, Concord MA

In article <1992Dec15.034053.10061@midway.uchicago.edu>, ab2r@quads.uchicago.edu (Marshall Abrams) writes:
> I'm really thankful to all of the free Lisp and Scheme
> implementors out there, but I want to put in a plug for adding a
> command line editing/history mechanism to these programs.  If I
> were a real C programmer, and had time, I suppose I'd do it
> myself. 

You don't need to create any new program. The GNU software has a subroutine
library for adding command-line editing.

On the other hand, it is not unusual to find that command line
editors (and/or fancy rubout handlers) are in fact LARGER than
otherwise complete LISP implementations like SIOD.

Everything has its cost.

-gjc
From: gjc@mitech.com (George J. Carrette)
Newsgroups: comp.lang.scheme
Subject: Re: Are interpreters now as fast as compiled code used to be?
Date: 15 Dec 92 10:40:39 GMT
Organization: Mitech Corporation, Concord MA

In article <BzA0Mo.II@cs.psu.edu>, schwartz@roke.cs.psu.edu (Scott Schwartz) writes:
> With Bartlett's Scheme->C on a sparcstation 2,  I get:
> 	0.2 real         0.0 user         0.1 sys
> 
> Of course, nothing that runs for that short a time will be a sensible
> yardstick.

Indeed. Of course when I first ran the thing (fib 20) was a reasonable
chunk of time! A Sun 3/180 took 17.5 seconds. The first Sun 4's took 4.2
seconds. (My 0.42 second time figure on ALPHA/VMS is accurate, by the way).

Obviously on an operating-system/machine with a lousy clock we are going
to have to up the time figures back into the range of seconds.

How about (standard-fib 25) ;; 4.85 seconds on Alpha.
or        (sfib 25)         ;; 3.98 seconds on Alpha.

Where sfib has built-in procedures pre-bound:

   (define sfib
     (eval `(lambda (x)
              (,if (,< x 2)
                  x
                (,+ (sfib (,- x 1))
                    (sfib (,- x 2)))))))


  
Newsgroups: comp.lang.scheme
From: oz@ursa.sis.yorku.ca (Ozan Yigit)
Subject: Re: Are interpreters now as fast as compiled code used to be?
Organization: York U. Student Information Systems Project
	<1992Dec16.190713.20460@netcom.com> <1gocpvINN3i8@agate.berkeley.edu>
Date: Thu, 17 Dec 1992 05:41:20 GMT

Brian Harvey writes:

   Implementation inefficiency isn't the only problem with continuations.
   [etc etc...]

Is "Implementation inefficiency" still a problem? Some interesting
methods to deal with them have been cataloged by Clinger et al.[1]
as well, there is a very fast method by Hieb et al.[2] [I used the
heap method [1] in PSI with great results]. Are there any specific
reasons why you would think there still is a problem?

... oz
---
With diligence, it is possible to make | electric: oz@sis.yorku.ca
anything run slowly.         -Tom Duff | ph:[416] 736 2100 x 33976
---
[1] William D. Clinger, Anne H. Hartheimer, Eric M. Ost
    Implementation Strategies for Continuations
    Conference Record of the 1988 ACM Conference on Lisp
    and Functional Programming, August 1988

[2] Robert Hieb, R. Kent Dybvig, Carl Bruggeman
    Representing Control in the Presence of First-Class Continuations
    Proceedings of the SIGPLAN '90 Conference on Programming Language
    Design and Implementation, White Plains, New York, June 1990

Newsgroups: comp.lang.scheme
From: Joerg Beekmann <jbeekman@prodigy.bc.ca>
Subject: Re: Are interpreters now as fast as compiled code used to be?
Organization: Prodigy Technologies Corp.
X-Useragent: Nuntius v1.0
     <4067@mitech.com>
Date: Thu, 17 Dec 1992 19:10:58 GMT

What I would like to know is how is the equation affected by 
machines with large caches and slow main memory systems.

If an interpreter could fit into the cache could the greater
density of byte code compensate (and to what extent) for
the need to interprete it.  In other words the cache would
be the "micro store" and the chip would become a scheme 
machine. 

Finally will this factor become more improtant?  CPU's 
seem to be increasing in speed faster than ram (where 
the empasis is on greater size) 

Any thoughts??
From: doner@Aero.org (John Doner)
Newsgroups: comp.lang.scheme
Subject: Re: Something I don't understand about bindings
Date: 15 Dec 1992 21:23:15 GMT
Organization: The Aerospace Corporation
Distribution: world
NNTP-Posting-Host: armadillo.aero.org

In article <HANCHE.92Dec15134343@ptolemy.ams.sunysb.edu>, hanche@ams.sunysb.edu (Harald Hanche-Olsen) writes:
|> >>>>> On 15 Dec 1992 17:03:04 GMT, doner@Aero.org (John Doner) said:
|> John> NNTP-Posting-Host: armadillo.aero.org
|> 
|> John> In article <a2vogler.724431792@rzdspc23>, a2vogler@rzdspc23.informatik.uni-hamburg.de (Christian Vogler) writes:
|> 
...
|> John> |> (define (timed-prime-test n)
|> John> |>   (define start-time (runtime))
|> John> |>   (define found-prime? (prime? n))
|> John> |>   (define elapsed-time (- (runtime) start-time))
|> John> |>   (print n)
|> John> |>   (cond (found-prime?
|> John> |>          (print " *** ")
|> John> |>          (print elapsed-time))))
|> John> |> 
|> John> |> The procedure then correctly prints the elapsed time for finding
|> John> |> a prime number, but why does this work?  [...]
|> 
|> John> You are probably interpreting the define's as defining
|> John> functions, whereas they are actually binding variables to new
|> John> locations and assigning numeric values to those locations.  The
|> John> defines are evaluated sequentially, and all three of start-time,
|> John> found-prime?, and elapsed-time have their values before the
|> John> printing begins.
|> 
|> That is not what r4rs says.  Indeed the above code is completely
|> equivalent to
|> 
|>   (define (timed-prime-test n)
|>     (letrec ((start-time (runtime))
|> 	     (found-prime? (prime? n))
|> 	     (elapsed-time (- (runtime) start-time)))
|>       (print n)
|>       (cond (found-prime?
|> 	     (print " *** ")
|> 	     (print elapsed-time)))))
|> 
|> which should not work, in standard r4rs scheme.  Not only is the order
|> of evaluation in a letrec unspecified, but as it says in the section
|> of internal defines:
|> 
|> Just as for the equivalent \ide{letrec} expression, it must be
|> possible to evaluate each \hyper{expression} of every internal
|> definition in a \hyper{body} without assigning or referring to
|> the value of any \hyper{variable} being defined.
|> 
|> I can only conclude that the original poster uses a non-r4rs
|> conforming scheme.
|> 
|> - Harald

You're right, it says there is an equivalent letrec expression, but isn't very
precise about how to determine that.  And indeed, the letrec order of evaluation is
unspecified.  On the other hand, his original define (again according to r4rs) is
equivalent to

	(define timed-prime-test
		(lambda (n)
			(define start-time (runtime))
			(define found-prime? (prime? n))
			.
			.
			.
				))

So the sequence of expressions beginning with the inner defines is the body of
a lambda expression.  And r4rs says the expressions in the body of a lambda
expression are to be evaluated sequentially.

Now I don't know what to think.

John
From: gjr@zurich.ai.mit.edu (Guillermo J. Rozas)
Newsgroups: comp.lang.scheme
Subject: Re: Are interpreters now as fast as compiled code used to be?
Date: 15 Dec 92 21:45:17
Organization: M.I.T. Artificial Intelligence Lab.
	<1992Dec15.201735.21731@netcom.com>
Reply-To: gjr@zurich.ai.mit.edu
NNTP-Posting-Host: klosters.ai.mit.edu
In-reply-to: thinman@netcom.com's message of Tue, 15 Dec 1992 20:17:35 GMT

In article <1992Dec15.201735.21731@netcom.com> thinman@netcom.com (Technically Sweet) writes:

|   From: thinman@netcom.com (Technically Sweet)
|   Date: Tue, 15 Dec 1992 20:17:35 GMT
|
|   I would have thought that the primary issue was keeping the 
|   interpreter code area in cache?  And, of course, using memory
|   mapping to implement continuations.

If only "modern operating systems" (aka. Unix) only allowed us
arbitrary control over our address space...
From: gwilson@majestix.cs.uoregon.edu (Gregory Vance Wilson)
Newsgroups: comp.lang.scheme
Subject: xref for Scheme?
Date: 13 Dec 92 19:29:33 GMT
Article-I.D.: cs.1992Dec13.192933.27322
Organization: University of Oregon Computer and Information Sciences Dept.

I am looking for a tool like Mark Kantrowitz's xref which is written in, and
works for, Scheme (rather than Lisp).

Thanks,

 ========================================================================
  Gregory V. Wilson                          || Work as though you lived
  Dept. of Computing and Information Science || in the early days
  University of Oregon                       || of a better nation.
  gwilson@cs.uoregon.edu                     || - Alasdair Gray
 ========================================================================
From: gjr@zurich.ai.mit.edu (Guillermo J. Rozas)
Newsgroups: comp.lang.scheme
Subject: Re: Something I don't understand about bindings
Date: 15 Dec 92 21:41:41
Organization: M.I.T. Artificial Intelligence Lab.
	<HANCHE.92Dec15134343@ptolemy.ams.sunysb.edu>
Reply-To: gjr@zurich.ai.mit.edu
NNTP-Posting-Host: klosters.ai.mit.edu
In-reply-to: hanche@ams.sunysb.edu's message of Tue, 15 Dec 1992 18:43:43 GMT

In article <HANCHE.92Dec15134343@ptolemy.ams.sunysb.edu> hanche@ams.sunysb.edu (Harald Hanche-Olsen) writes:

|   I can only conclude that the original poster uses a non-r4rs
|   conforming scheme.

SICP ("the book") precedes R2RS let alone R2RS and R3RS.
Xref: sparky comp.lang.scheme:2740 comp.lang.lisp:3079
From: brent@ssd.csd.harris.com (Brent Benson)
Newsgroups: comp.lang.scheme,comp.lang.lisp
Subject: Re: Want history/command editing facilities in free Lisps
Date: 15 Dec 92 14:53:25 GMT
	<HANCHE.92Dec9104214@ptolemy.ams.sunysb.edu>
	<1992Dec15.034053.10061@midway.uchicago.edu>
Organization: Harris Computer Systems

ab2r@quads.uchicago.edu (Marshall Abrams) writes:

> I'm really thankful to all of the free Lisp and Scheme implementors
> out there, but I want to put in a plug for adding a command line
> editing/history mechanism to these programs.  If I were a real C
> programmer, and had time, I suppose I'd do it myself.  (Hmm--Maybe

It's already been done for you: the GNU readline library.  Just plug
it in and play.

--
Brent Benson                     
Harris Computer Systems
Newsgroups: comp.lang.scheme
From: igor@research.nj.nec.com (Igor Rivin)
Subject: Re: Are interpreters now as fast as compiled code used to be?
Originator: igor@ridley
Organization: NEC Research Institute
Date: Wed, 16 Dec 92 06:19:43 GMT

In article <FEELEY.92Dec15153031@zohar.ai.mit.edu> feeley@zurich.ai.mit.edu (Marc Feeley) writes:
>In article <4067@mitech.com> gjc@mitech.com (George J. Carrette) writes:
>
>   In article <FEELEY.92Dec14215701@zohar.ai.mit.edu>, feeley@zurich.ai.mit.edu (Marc Feeley) writes:
>[..stuff deleted...]
>Well a factor of 3 for the last decade is clearly not valid but for
>the next 5 years it might be.  DEC's Alpha introduced this year (200 MIPS
>or so) is about 3 times faster than last year's HP9000/700 (70 MIPS).

gjc's benchmarks do not seem to support the 200 MIPS claim. I would be
curious to see more (though this obviously is not the right forum for
this... )




Newsgroups: comp.lang.scheme
From: thinman@netcom.com (Technically Sweet)
Subject: Re: Are interpreters now as fast as compiled code used to be?
Organization: International Foundation for Internal Freedom
Date: Wed, 16 Dec 1992 19:07:13 GMT


In comp.lang.scheme "Jinx" writes:

>If only "modern operating systems" (aka. Unix) only allowed us
>arbitrary control over our address space...

BSD, SUNos, and AT&T Unix V.4 all have something called 'mmap'
which does precisely this.  The long dark night is over.

This is why Dylan should have continuations.  The only target
Dylan platform that causes problems for continuations is the Mac
without PMMU.

-- 

Lance Norskog

Data is not information is not knowledge is not wisdom.
From: a2vogler@rzdspc23.informatik.uni-hamburg.de (Christian Vogler)
Newsgroups: comp.lang.scheme
Subject: Something I don't understand about bindings
Date: 15 Dec 92 15:03:12 GMT
Organization: University of Hamburg, FRG

Hi folks!

While working through the book "Structure and Interpretation of
Computer Programs" by Abelson/Sussman, I found a piece of code
I can't explain (p. 49/50).
The following fragment is supposed to measure how much time
execution of the procedure took (assuming that there is a
runtime primitive):

(define (timed-prime-test n)
  (define start-time (runtime))
  (define found-prime? (prime? n))
  (define elapsed-time (- (runtime) start-time))
  (print n)
  (cond (found-prime?
         (print " *** ")
         (print elapsed-time))))

The procedure then correctly prints the elapsed time for finding
a prime number, but why does this work? Why is the (runtime) in
the definition of start-time being evaluated at once, when the
procedure (timed-prime-test) is entered, while the
(runtime) in the definition of elapsed-time apparently is not evaluated
before it actually is printed?

Any hints are appreciated.

with regards
       Christian
From: doner@aero.org (John Doner)
Newsgroups: comp.lang.scheme
Subject: Re: Something I don't understand about bindings
Date: 18 Dec 1992 00:46:04 GMT
Organization: The Aerospace Corporation, El Segundo, CA
Distribution: world
NNTP-Posting-Host: armadillo.aero.org

In article <MAX.92Dec16143412@Kolmogorov.gac.edu> Max Hailperin <max@nic.gac.edu> writes:
>In article <1glic3INNq5b@news.aero.org> doner@Aero.org (John Doner) writes:
>
>   ... On the other hand, his original define (again according to r4rs) is
>   equivalent to
>
>           (define timed-prime-test
>                   (lambda (n)
>                           (define start-time (runtime))
>                           (define found-prime? (prime? n))
>                           .
>                           .
>                           .
>                                   ))
>
>   So the sequence of expressions beginning with the inner defines is
>   the body of a lambda expression.  And r4rs says the expressions in
>   the body of a lambda expression are to be evaluated sequentially....
>
>Ahhh..., but they *aren't* expressions.  Read R4RS carefully and you
>will find that a definition is not an expression.  Thus the fact that
>the body *expressions* are evaluated in order is irrelevant, and

U R Right! Thanks.  Coming from the culture of logicians, I was used to the
term "expression" referring to any sequence of symbols of the language, whereas
it has a much more narrow meaning here.

John
From: gjc@mitech.com (George J. Carrette)
Newsgroups: comp.lang.scheme
Subject: Re: Are interpreters now as fast as compiled code used to be?
Date: 16 Dec 92 17:23:31 GMT
Organization: Mitech Corporation, Concord MA

In article <FEELEY.92Dec15153031@zohar.ai.mit.edu>, feeley@zurich.ai.mit.edu (Marc Feeley) writes:
> Well a factor of 3 for the last decade is clearly not valid but for
> the next 5 years it might be.  DEC's Alpha introduced this year (200 MIPS
> or so) is about 3 times faster than last year's HP9000/700 (70 MIPS).
> If next year DEC comes out with their BIPS processor (1000 MIPS) my
> factor of 3 seems about right.

You need to track a given manufacturer, not jump from one to another,
because the computer guys are not -really- leapfrogging each other.
They just appear to be for marketting purposes. Also "benchmark rot"
is involved as people play games with funky preprocessors that don't
always mean much for what good programmers would write.

  [Also, people with real work to do hardly ever win by jumping from
  one machine manufacturer to the next ever year or two].

Look at what SUN has done with 680xx and SPARC since say 1983 to present.

And HP the same, starting with their 680xx machines and their new RISC line.

And for the longest time curve, you have the DIGITAL VAX line. Where this
years VAXSTATION is about the same speed as last years HP RISC machine.
And this years lowest-end ALPHA about 3 times faster than that. Ah,
the famous factor of 3.

> Clearly this increase in performance will level off at some point in
> the future. 

No, I think we have seen a pretty steady factor of 100 over the last
decade. That works out to be about a factor of 1.6 per year.

Glitches are caused by project start up, manufacturing, and other
lead-time delays. Where you can get shifts of two years, typically.
And 1.6 squared is about your factor of 3.

> When that happens the additional factor of 100 or so
> provided by compilers will be more valuable.

I don't agree that compilers give a factor of 100. 
On simple numerical stuff, yes. But that is easy operator
specialization. Even interpreters can do that.

> Note that parallel
> processing does not change the argument because what counts is the
> number of MIPS you can get with your budget.

Bring back timesharing?

Newsgroups: comp.lang.scheme
From: thinman@netcom.com (Technically Sweet)
Subject: Re: Using memory mapping to implement continuations
Organization: International Foundation for Internal Freedom
Date: Thu, 17 Dec 1992 18:25:03 GMT


Memory mapping is not necessarily slow.  Some Unix implementations are.
Under DOS you can change the stack segment register with a few
instructions overhead; at 64k per stack you quickly run out of RAM.
SUNos 4.2 (??) has a revamped multi-processor thread system
which is apparently very fast; there's no reason you can't
make the relevant page tables writeable by the user process.

-- 

Lance Norskog

Data is not information is not knowledge is not wisdom.
From: eigenstr@cs.rose-hulman.edu (Todd R. Eigenschink)
Newsgroups: comp.lang.scheme
Subject: Numerical analysis routines, anyone?
Date: 19 Dec 1992 00:03:17 GMT
Organization: Computer Science Department at Rose-Hulman
NNTP-Posting-Host: ace.cs.rose-hulman.edu

I've checked all the ftp sites I can, and I've still come up short.
Does anyone have any numerical analysis routines laying around?  I'm
looking for matrix stuff (Gaussian elimination and the like),
numerical integration, etc.

I'd more than appreciate any clues or code anyone can give me.

--
Todd Eigenschink (eigenstr@CS.Rose-Hulman.Edu)
Rose-Hulman Institute of Technology, Terre Haute, IN
"I don't give a damn about the paradigm."  - Fred Sullivan