00:00:00 --- log: started forth/07.05.03
01:40:06 --- join: ecraven (i=nex@eutyche.swe.uni-linz.ac.at) joined #forth
02:20:35 --- join: brx (n=brx@p57A795B4.dip0.t-ipconnect.de) joined #forth
02:24:34 <JasonWoof> C is still useful
02:25:10 <JasonWoof> it executes many times faster than anything else on my machine that I'm aware of
02:25:34 <JasonWoof> ie it has a very effective optomizing compiler
02:29:15 --- quit: brx` (Read error: 110 (Connection timed out))
02:50:47 --- join: brx` (n=brx@p57A7A777.dip0.t-ipconnect.de) joined #forth
03:07:43 --- quit: brx (Read error: 110 (Connection timed out))
03:17:37 --- join: brx (n=brx@p57a78f48.dip0.t-ipconnect.de) joined #forth
03:19:20 --- join: brx`` (n=brx@p57a79d94.dip0.t-ipconnect.de) joined #forth
03:25:21 --- quit: brx` (Read error: 110 (Connection timed out))
03:28:29 --- join: brxz (n=brx@71.6.194.243) joined #forth
03:35:41 --- join: brx` (n=brx@p57a78839.dip0.t-ipconnect.de) joined #forth
03:36:33 --- quit: brx (Read error: 110 (Connection timed out))
03:42:54 --- quit: brx`` (Read error: 110 (Connection timed out))
04:41:50 --- join: brx (n=brx@p57a790c4.dip0.t-ipconnect.de) joined #forth
04:59:13 --- quit: brx` (Read error: 110 (Connection timed out))
05:35:30 <JasonWoof> neat, lisp has a MOD that gives the same sort of results for negative numbers
05:36:17 <Quartus> same sort?
05:43:43 <JasonWoof> if you take mod 3 of the sequence 10..-10
05:44:06 <JasonWoof> you get  1 0 2 1 0 2 1 0 2 1 0 2 1 0 etc
05:44:16 <JasonWoof> ie you don't get negative numbers
05:44:39 <JasonWoof> or any break in the pattern "0 2 1" when you hit zero
05:54:50 <Quartus> In Standard Forth there's fm/mod and sm/rem to give you whichever behaviour you require
05:58:26 <JasonWoof> cool
05:58:59 <Quartus> Actually thinking about it I think the mod you're describing is yet a third one.  It's not tough to synthesize at any rate.
05:59:30 <JasonWoof> here's how to two are described in lisp code:
05:59:31 <JasonWoof> (+ (* (floor    (/ x y)) y) (mod x y)) === x
05:59:31 <JasonWoof> (+ (* (truncate (/ x y)) y) (rem x y)) === x
06:00:04 <Quartus> Ok. You could translate that directly, using fm/mod and sm/rem as a base, if you required that functionality
06:01:12 <JasonWoof> I think it's happened a bunch of times in my programming that I wanted to "wrap" a value that changed slowly within certain bounds
06:01:20 <JasonWoof> and sometimes the lower bound is zero
06:01:52 <JasonWoof> I've done stuff like:  if(x < 0) x = (x + width) % width;
06:02:21 <JasonWoof> dup width > if width + width mod then
06:02:42 <JasonWoof> oops
06:03:02 <JasonWoof> dup 0 < if width + width mod then
06:03:32 <JasonWoof> which works so long as it isn't less than 0 by more than width
06:04:01 <JasonWoof> which has happened under weird circumstances
06:04:19 <JasonWoof> had a bug in vor where it would crash if it didn't get cpu time to do a frame in more that 4 seconds
06:05:13 <Quartus> wikipedia has a good article on mod: http://en.wikipedia.org/wiki/Modulo_operation
06:05:30 <JasonWoof> cool
06:06:15 <JasonWoof> man, I've gotta eather do another (paying) job or go to sleep
06:06:40 <Quartus> :)
06:07:06 --- join: Quartus__ (n=Quartus_@209.167.5.2) joined #forth
06:07:32 <JasonWoof> feel like if I don't do it now, I won't do it until monday
06:07:52 <Quartus> sleep? :)
06:07:59 <JasonWoof> not sure how I'm going to fix my sleep schedule though
06:08:14 <JasonWoof> yeah, that's that thing people do when they're bored.
06:11:14 <Quartus__> I mean, not going to sleep until monday? :)
06:11:33 <JasonWoof> oh
06:11:34 <JasonWoof> lol
06:11:49 <JasonWoof> I meant if I don't do my work now, I won't do that work until Monday
06:12:16 --- join: ygrek (i=user@gateway/tor/x-dee322ccddb1b08a) joined #forth
06:19:36 --- join: brx` (n=brx@p57a79494.dip0.t-ipconnect.de) joined #forth
06:26:29 --- quit: brx (Read error: 110 (Connection timed out))
06:27:21 <Quartus__> heh
06:31:29 --- quit: ecraven ("bbl")
06:40:05 --- quit: ygrek (Remote closed the connection)
06:59:01 --- quit: Quartus__ (Read error: 104 (Connection reset by peer))
07:01:33 --- join: gnomon (n=gnomon@CPE0050eb372bdb-CM001692f57b56.cpe.net.cable.rogers.com) joined #forth
07:03:45 --- part: vatic left #forth
07:45:32 --- join: ygrek (i=user@gateway/tor/x-45d7836a87d5f0c0) joined #forth
07:47:21 --- join: ygrek_ (i=user@gateway/tor/x-c674e4b7937147ae) joined #forth
07:47:22 --- quit: ygrek (Remote closed the connection)
08:01:01 <zirpu> i'm learning forth via gforth, and cannot find a word for searching for words.  the tutorial by bradley seems to be openboot sepecific. (ie. sifting)
08:01:01 --- quit: AndyArmstrong (Read error: 104 (Connection reset by peer))
08:01:25 --- join: AndyArmstrong (n=andy@82.152.157.85) joined #forth
08:02:20 <ygrek_> C" DUP" FIND
08:02:23 <ygrek_> S" DUP" SFIND
08:02:40 <ygrek_> sorry, SFIND seems to be SPF specific
08:02:50 <TreyB> Have you tried 'words'?
08:03:05 <zirpu> words just lists the words. trying find.
08:03:17 <TreyB> Some versions have a variant where they take a pattern/prefix after 'words'.
08:04:56 <zirpu> hm. sfind seems to work.
08:05:21 <AndyArmstrong> Jason: ObTesting: I've been doing some work on a little test suite that generates TAP (http://testanything.org). I haven't released it yet but I shall soon. I'm already finding it useful - if heretic - to automate my Forth tests using Perl's testing tools.
08:05:41 * zirpu covers his eyes!
08:05:50 <AndyArmstrong> Oh and it means I'm writing Forth for the first time in ~23 years :)
08:05:56 <zirpu> heh
08:05:56 <JasonWoof> what's TAP?
08:06:10 <zirpu> totally automated programming?
08:06:18 <AndyArmstrong> See the link - Test Anything Protocol. http://testanything.org/
08:06:32 <gnomon> Third Appendage, Prehensile.
08:06:45 <TreyB> With gforth, it helps to have 'info gforth' running somewhere.
08:06:49 <AndyArmstrong> Also http://en.wikipedia.org/wiki/Test_Anything_Protocol
08:06:58 <AndyArmstrong> I like Third Appendage :)
08:22:45 <JasonWoof> gnomon: good one :)
08:22:54 <gnomon> Heh  ;)
08:24:55 <JasonWoof> I'm quite happy with my gforth test suite
08:25:10 <JasonWoof> I don't have anything particularly nice set up for other languages though
08:26:08 <JasonWoof> I just put "<-test" after definitions
08:26:36 <JasonWoof> it prints out their name, calls them, then a green "passed" or a red "failed"
08:26:41 <JasonWoof> based on the flad returned
08:26:50 <JasonWoof> it keeps a runing total of passes and fails
08:26:59 <JasonWoof> oh, and it prints out the file names, and indents tests within
08:29:21 --- join: tgunr (n=davec@70-41-219-171.cust.wildblue.net) joined #forth
08:32:02 <AndyArmstrong> How do you express the actual tests?
08:32:17 <AndyArmstrong> In other words how do you decide whether it's passed or failed?
08:33:05 <JasonWoof> the test words return true/false
08:33:17 <JasonWoof> non-zero/zero to be precice
08:33:35 <JasonWoof> : <unknown>-returns-zero <unknown> 0= ; <-test
08:33:38 <JasonWoof> : <br>-returns-nonzero <br> ; <-test
08:33:41 <JasonWoof> : tag-find-<br> <br> s" br" tag-find = ; <-test
08:33:44 <JasonWoof> : tag-find-<var> <var> s" var" tag-find = ; <-test
08:33:51 <JasonWoof> : tag-find-<unknown> <unknown> s" unknown" tag-find = ; <-test
08:34:19 <JasonWoof> output looks like:
08:34:21 <JasonWoof> html-tags-tests.fs:
08:34:25 <JasonWoof>       <unknown>-returns-zero [passed]
08:34:29 <JasonWoof>       <br>-returns-nonzero [passed]
08:34:41 <JasonWoof>       tag-find-<br> [passed]
08:34:48 <JasonWoof>       tag-find-<var> [passed]
08:34:53 <JasonWoof>       tag-find-<unknown> [passed]
08:40:39 <AndyArmstrong> Oh cool - that looks good.
08:41:24 <AndyArmstrong> One of the advantages of TAP is that if you're working with multiple languages you can coordinate all your tests easily. It's useful for  distributed testing too.
08:42:15 <JasonWoof> ahh, I see
08:43:06 <JasonWoof> I'd rather not work on a project with a considerable amount of more than one language
08:43:06 <JasonWoof> I think I'll be able to avoid that one
08:43:23 <AndyArmstrong> Lucky :)
08:43:30 <AndyArmstrong> Here's what I've been playing with: http://hexten.net/downloads/gforth-tap-0.0.2.tar.gz
08:44:13 <JasonWoof> couldn't get a.net huh?
08:44:31 <JasonWoof> some canadian probably snagged it right away ;)
08:45:29 <AndyArmstrong> Hmm?
08:46:13 <JasonWoof> 0xa
08:46:14 <JasonWoof> hex ten
08:46:38 <AndyArmstrong> Oh - sorry - slow today :)
08:48:37 <JasonWoof> just making stupid jokes about your domain name
08:51:29 <AndyArmstrong> Well I should have got it. To be honest it's been my domain name for long enough that I forget that it means anything :)
08:52:56 <JasonWoof> having a protocol for testing seems like severe overkill for anything I'd be willing to work on
08:54:30 --- join: yumehito (n=yumehito@b-internet.87.103.254.70.snt.ru) joined #forth
08:54:49 <AndyArmstrong> Possibly so. The fact that it's pervasive in Perl world definitely has a beneficial effect on the quality of the code on CPAN and allows things like automatic testing of bleeding-edge Perl builds on hundreds of different platforms.
08:55:32 <AndyArmstrong> It's certainly not something I'm particularly advocating for Forth - I really wrote it just to get my Forth mojo up and running again after over two decades of neglect.
08:58:50 <AndyArmstrong> Anyway sorry for mentioning P*rl so much on a Forth channel. I'm off to walk the dog now :)
09:09:30 --- join: iano (n=iosgood@sub26-46.member.dsl-only.net) joined #forth
09:25:26 --- join: Quartus__ (n=Quartus_@209.167.5.1) joined #forth
09:27:52 --- join: yumehito_ (n=yumehito@b-internet.87.103.254.70.snt.ru) joined #forth
09:29:14 <Quartus__> did I miss anything?
09:29:39 --- quit: ygrek_ ()
09:35:27 <AndyArmstrong> I think I busted the mood by mentioning another programming language :)
09:38:48 --- quit: yumehito (Read error: 110 (Connection timed out))
09:42:50 --- quit: scope (Read error: 110 (Connection timed out))
09:44:26 <Quartus__> ah
09:52:21 <JasonWoof> I've been talking more about lisp than forth here lately
09:52:52 <JasonWoof> although lisp and forth are somehow more compatible
09:54:32 --- quit: tgunr ()
09:54:51 <AndyArmstrong> (oops here I go again) Perl has quite a few lispish idioms too - first class functions / closures, lists as first class types.
09:55:05 <AndyArmstrong> Doesn't have the same spooky powerful macros as Forth and Lisp though.
09:55:16 <segher> forth and perl are quite alike in some ways.  for example, many people hate either language, but for the wrong reasons
09:55:32 <AndyArmstrong> Spot on!
09:56:19 <segher> i have this forth system that requires perl to build it.  i like both languages :-)
09:56:49 <AndyArmstrong> That sounds interesting...
09:57:02 <segher> it's not, really
09:57:18 <AndyArmstrong> Oh :)
09:57:49 <segher> i didn't have a metacompiler yet, so i used perl+cpp to create an initial dictionary
09:58:18 <segher> i'm proud that it works at all, but i'm not exactly proud of it ;-)
09:58:27 <AndyArmstrong> Heh :)
09:59:07 <AndyArmstrong> The last Forth system I had anything to do with bootstrapping was on the 6502.
09:59:25 <segher> here, have a taster:
09:59:30 <segher> sub forth_to_c_name
09:59:31 <segher> {
09:59:31 <segher>         $_ = shift;
09:59:31 <segher>         s/([^a-zA-Z0-9])/sprintf("_X%02x_", ord($1))/ge;
09:59:31 <segher>         s/__/_/g;
09:59:31 <segher>         s/_$//;
09:59:33 <segher>         return $_;
09:59:35 <segher> }
10:00:50 <AndyArmstrong> Cool. For lispish bonus points you can then do 
10:01:09 <AndyArmstrong> my @c_names = map { forth_to_c_name($_) } @forth_names;
10:01:19 <segher> sure
10:01:30 <AndyArmstrong> Since we were speaking of lisp also...
10:01:33 <segher> except i never have a list of those names
10:01:39 <segher> single-pass compiler
10:01:56 <segher> have to go do groceries, back in a bit
10:02:01 <AndyArmstrong> I was just trying spuriously to complete the Lisp-Perl-Forth triangle :)
10:02:10 <segher> :-)
10:02:59 <segher> i use CREATE ... DOES> a lot, that's a bit like functional programming
10:03:12 <segher> or it _can_ be, anyway
10:03:22 <segher> a bit like closures, in other cases
10:08:28 <AndyArmstrong> Yup. Closures are necessarily quite different in Forth because you haven't got the same kind of dynamic context to close over.
10:08:55 <AndyArmstrong> I've been thinking about how (and whether) closures and continuations map to Forth quite a bit lately.
10:09:17 <AndyArmstrong> Which is not to say I've had any groundbreaking insight :)
10:10:41 --- join: ygrek (i=user@gateway/tor/x-46bc2238d559c5fd) joined #forth
10:18:04 <segher> you can (non-portably) do continuations by saving your return address, and plopping it back onto the retutn stack later
10:21:17 --- join: vatic (n=vatic@h-68-164-35-21.nycmny83.dynamic.covad.net) joined #forth
10:25:45 <JasonWoof> segher: I've written a forth in C and used awk to generate the initial dictionary
10:25:51 <JasonWoof> and C prototypes and constants
10:26:07 <JasonWoof> the forth isn't terribly good, but I'm quite happy with the awk script :)
10:27:29 <JasonWoof> I didn't do a fancy thing to convert forth-name/c-name
10:27:47 <JasonWoof> I just put a comment ofter the C functions which couldn't match the forth name
10:28:01 <JasonWoof> the awk script checks for the comment, and if found uses that to name the forth word
10:29:01 <JasonWoof> I might have finished that forth if I had an actual use for it
10:30:00 <JasonWoof> man, I've got way too many quarters
10:30:05 <JasonWoof> must have at least $20 here
10:32:35 <JasonWoof> nope, $15.25
10:33:49 --- join: tgunr (n=davec@70-41-219-171.cust.wildblue.net) joined #forth
10:34:44 <JasonWoof> oop nap time. bbl
10:40:41 <segher> jasonwoof: my perl script translates a restricted almost-forth language into CPP macros which form the initial dictionary :-)
10:42:25 <segher> here's an example:   col(HOLD PAD DUP @ 1- TUCK SWAP ! C!)
10:43:29 <I440r> i have a bourbon bottle that a quarter will drop into, ive got about $20 in quarters in there 
10:43:34 <I440r> its about 1/5 full
10:44:59 <segher> with coins or bourbon??
10:46:11 <I440r> bourbon is all drunk
10:46:15 <I440r> im not :)
10:46:21 <segher> heh
10:49:51 --- join: brx (n=brx@p57A7825D.dip0.t-ipconnect.de) joined #forth
10:54:53 <iano> http://c2.com/cgi/wiki?ForthVsLisp
11:02:20 --- join: edrx (n=Eduardo@fosforo.k8.com.br) joined #forth
11:07:37 --- quit: brx` (Connection timed out)
11:11:31 --- quit: edrx (Remote closed the connection)
11:12:06 --- join: edrx (n=Eduardo@fosforo.k8.com.br) joined #forth
11:25:49 --- quit: edrx (Remote closed the connection)
11:48:13 --- join: Shine (n=Frank_Bu@static-87-79-64-220.netcologne.de) joined #forth
11:50:38 --- quit: Quartus__ (Read error: 104 (Connection reset by peer))
11:55:27 --- quit: ygrek ()
11:59:56 <AndyArmstrong> iano: cool - reading it now thanks.
12:09:04 <AndyArmstrong> There's a lot of point-missing going on on that page. The aggregate effect is that it's just language wars tripe. I know that's what it's billed as but it just degenerates into "my brother's bigger than your brother".
12:09:38 --- quit: tgunr (Remote closed the connection)
12:46:17 --- join: tgunr (n=davec@70-41-219-171.cust.wildblue.net) joined #forth
12:47:32 --- join: yumehito (n=yumehito@b-internet.87.103.254.70.snt.ru) joined #forth
12:49:34 --- join: edrx (n=Eduardo@fosforo.k8.com.br) joined #forth
12:54:29 --- quit: yumehito_ (Read error: 60 (Operation timed out))
13:02:22 --- quit: edrx (Remote closed the connection)
13:08:54 --- quit: tgunr (Remote closed the connection)
13:10:37 --- join: tgunr (n=davec@70-41-219-171.cust.wildblue.net) joined #forth
13:22:22 <slava> AndyArmstrong: factor is a forth-like language with closures and continuations
13:57:57 --- join: baird (n=cbaird@brushtail.apana.org.au) joined #forth
13:59:56 --- join: segher_ (n=segher@dslb-084-056-160-179.pools.arcor-ip.net) joined #forth
14:09:41 --- quit: segher (Read error: 110 (Connection timed out))
14:21:32 --- join: vatic_ (n=vatic@pool-162-84-152-182.ny5030.east.verizon.net) joined #forth
14:23:39 --- join: kardinal (n=kvirc@e180172088.adsl.alicedsl.de) joined #forth
14:30:32 --- join: brx` (n=brx@p57a7c0dd.dip0.t-ipconnect.de) joined #forth
14:30:43 <kardinal> can I produce an real executable (statically or dinamically linked) using gforth?
14:35:12 --- join: brx`` (n=brx@p57a7a5f0.dip0.t-ipconnect.de) joined #forth
14:37:00 --- quit: vatic (Nick collision from services.)
14:37:49 --- nick: vatic_ -> vatic
14:38:25 --- quit: brx (Read error: 110 (Connection timed out))
14:40:05 <segher_> kardinal: yes it is possible.  read the manual -- "info gforth"
14:50:39 <kardinal> I was only able to find info on how to create a bytecode image of the dictionary
14:51:11 <kardinal> this is data starting with #!/usr/bin/gforth.....
14:51:26 <kardinal> this is not a stand alone binary
14:51:27 <slava> i would think generating executables is not as useful as distributing source
14:51:36 <slava> will you have executables for every CPU/OS combo?
14:52:00 --- join: skas_wk (n=skas@121.127.198.32) joined #forth
14:52:14 --- quit: brx` (Read error: 110 (Connection timed out))
14:52:26 <kardinal> no, just want to know if it possible to produce a stan alone binary
14:53:07 <slava> it might not be. gforth would have to understand executable formats on every OS where it runs to do that
14:53:17 <kardinal> like gcc -o hello hello.c
14:53:39 <kardinal> ok
14:54:43 <kardinal> there is a forth able to do this on linux?
14:56:57 --- join: Quartus__ (n=Quartus_@209.167.5.2) joined #forth
14:57:17 <Quartus__> so what's up tonight? Is it lisp, or c? :)
14:57:52 <kardinal> pythonsmileglasses 
14:58:19 <Quartus__> peanutmonkeymortgage
14:58:33 <slava> kardinal: isforth acn
14:58:35 <slava> can*
14:58:40 <slava> but it's not ANS.
14:59:20 <slava> hey Quartus__ 
14:59:29 <Quartus__> hey slava
15:00:55 <kardinal> slava: thanks, I'll give  it a trysmile 
15:00:59 <Quartus__> what's the news?
15:01:15 <Quartus__> is it me, or is the word 'smile' there?
15:01:23 <slava> yes it is there.
15:01:33 <slava> ...and then there's this: <kardinal> pythonsmileglasses
15:01:40 <Quartus__> that's surprisingly irritating.
15:03:25 <Quartus__> is it a 'feature' of Realia, whatever that is?
15:03:50 <slava> laugh out loud
15:04:06 <slava> winksmile
15:04:17 <Quartus__> I think you mean  outloudlaugh
15:06:31 <slava> both are shown as 'lol' in my client roll on floor laughing
15:13:39 <Quartus__> bah
15:13:49 <slava> no, not really.
15:15:55 <Quartus__> so what of forth? Passaniti keeps handing Doty his ass, but Doty doties on regardless. Any werties?
15:17:53 <slava> i'm adding a new optimization to my compiler -- omitting the prolog/epilog code that you need on powerpc to save/restore the link register in leaf words that don't call non-inlined words.
15:18:08 <slava> technically this isn't a new optimization, i implemented it a while ago, but then it got broken so i removed it
15:18:16 <Quartus__> good idea.
15:18:41 <Quartus__> I remember an ARM forth that did the same.
15:19:12 <slava> does quartus?
15:19:30 <slava> i used to be able to determine if prologs are needed ahead of time, but now i can't because i have optimizations whereby a word is conditionally open-coded as assembly
15:19:49 <slava> eg, a recent one was that for arrays with a compile-time constant size less than 20 elements, the allocation code was completely inlined
15:19:49 <Quartus__> it doesn't write arm, but doesn't use frame pointers under 68k either
15:20:17 <slava> 68k is like x86 in this respect, right?
15:20:22 <slava> you get instructions that do the call/return thing for you?
15:20:46 <Quartus__> yes, though there's also frame pointers under C on both
15:21:19 <slava> i'm just talking about saving/restoring the return addres.s
15:21:32 <slava> factor doesn't use fancy stack frames.
15:21:38 <Quartus__> Bsr/jsr under 68k
15:23:26 --- join: jacereda (n=jacereda@220.Red-80-59-211.staticIP.rima-tde.net) joined #forth
15:23:46 <jacereda> hi
15:24:11 <Quartus__> hi
15:27:42 <Quartus__> quartus doesn't use stack frames at all, in fact the usual pointer is otherwise employed
15:28:32 <jacereda> anyone wants to test a colorforth port to x86 macs?
15:28:54 <slava> i do lay out my return stack in the same was that C does, so that it is easier to call into C. but i don't store anything there except return addresses
15:30:02 <slava> jacereda: sorry i only have a ppc mac
15:33:22 <Quartus__> but I know you'd thrill at the chance otherwise, slava :)
15:33:40 <slava> most definitely
15:34:08 <Quartus__> or maybe a ppc port of lse64!
15:34:30 <slava> and i even have a 64-bit powerpc!
15:34:33 <slava> i'm giving up on factor now
15:34:39 <jacereda> lse64 should build out of the box on ppc
15:35:18 <Quartus__> only it should be left in the box, sealed securely, and buried in soft peat
15:35:35 <jacereda> well, I think it has some interesting ideas
15:35:43 <slava> Quartus__: you should know better than to bury radiactive waste in soft peat. it will permeate and poison future generations
15:35:51 <Quartus__> good point
15:36:43 <slava> http://jsnell.iki.fi/blog/archive/2007-05-03-code-coverage-tool-for-sbcl.html
15:37:08 <Quartus__> what's that? No linkage here
15:38:44 <jacereda> cool
15:41:07 <slava> Quartus__: i wonder if i'll ever be able to port factor to coldfire. teaching the compiler about data/address registers might be a pain
15:41:20 <slava> how do they differ anyway?
15:43:23 --- quit: jacereda (Remote closed the connection)
15:45:54 --- nick: brx`` -> brx
15:52:17 <iano> jacereda: I'd test colorforth on an Intel mac
16:02:03 <vatic> slava: what do you mean you're "giving up on Factor"?
16:03:13 <Quartus__> slava, addressing modes are specific to address registers, math largely to data, etc.
16:03:53 <Quartus__> vatic, he was making a joke about the supposed superiority of lse64
16:04:24 <vatic> Quartus__: I see now that I've read the context around his comment...
16:18:58 <vatic> Maybe add a number to the name? Like "Factor66"
16:21:12 --- join: tgunr_ (n=davec@70-41-217-20.cust.wildblue.net) joined #forth
16:23:14 --- quit: tgunr (Read error: 104 (Connection reset by peer))
16:38:15 --- part: kardinal left #forth
16:39:19 --- join: tgunr (n=davec@70-41-219-171.cust.wildblue.net) joined #forth
16:39:40 --- quit: baird (Remote closed the connection)
16:40:40 --- quit: tgunr_ (Read error: 104 (Connection reset by peer))
17:35:50 <AndyArmstrong> slava: thanks - that looks really interesting. 
18:06:22 --- join: brx` (n=brx@p57A7BF4B.dip0.t-ipconnect.de) joined #forth
18:14:49 --- quit: brx (Read error: 110 (Connection timed out))
18:29:22 --- part: brxz left #forth
18:39:11 --- quit: vatic (">poof<")
19:06:31 --- join: Aliyahh (n=info@124.29.253.234) joined #forth
19:20:01 --- join: brx (n=brx@p57A7A4B8.dip0.t-ipconnect.de) joined #forth
19:23:14 --- join: tathi (n=josh@pdpc/supporter/bronze/tathi) joined #forth
19:23:14 --- mode: ChanServ set +o tathi
19:24:39 --- quit: tathi (Client Quit)
19:31:58 --- quit: Aliyahh ()
19:36:23 --- quit: brx` (Read error: 110 (Connection timed out))
19:50:14 --- join: brx` (n=brx@p57A79FB6.dip0.t-ipconnect.de) joined #forth
19:57:17 --- quit: brx (Read error: 110 (Connection timed out))
19:59:16 --- join: edrx (n=Eduardo@201.5.14.87) joined #forth
20:06:52 --- join: brx (n=brx@p57A797C6.dip0.t-ipconnect.de) joined #forth
20:13:17 <slava> Quartus__: is ertl's forth code optimized at all?
20:24:35 --- quit: brx` (Read error: 110 (Connection timed out))
20:27:58 <Quartus__> ertl's? 
20:28:14 <Quartus__> which?
20:29:50 <slava> http://groups.google.com/group/comp.lang.forth/msg/5525e8d7f9013b77
20:36:08 --- quit: Quartus__ ("used jmIrc")
20:36:21 --- join: Quartus__ (n=Quartus_@209.167.5.1) joined #forth
20:36:47 <Quartus__> might have missed something
20:38:08 <slava> i twiddled his factor code and got it to run 3 times faster.
20:38:14 <slava> i'm wondering if the same could be done to the forth code ;)
20:38:21 <slava> you don't need to pass the xt around, after all.
20:38:35 <slava> the factor compiler expands 'reduce' and turns it into a loop, essentually. the code block is inlined
20:38:49 <slava> but gforth performs no such optimization for words that take xts.
20:38:51 <Quartus__> his code doesn't look too bad to me, as a rule
20:38:58 <slava> you'd want to use an immediate word, to set up the loop, i think.
20:39:14 <slava> map-array: +
20:39:24 <slava> instead of ['] + map-array
20:39:26 <slava> how would you do it?
20:39:51 <slava> http://groups.google.com/group/comp.lang.forth/msg/9a811d29913b526f
20:40:06 <slava> also i should note his USAGES: statement is mostly redundant
20:40:14 <Quartus__> have to wait till I'm non-mobile for that link
20:40:27 <slava> USING: math kernel sequences ; is enough.
20:42:32 <Quartus__> I know very little about how you go about things in Factor, at any rate
20:42:40 <slava> i was asking about the forth
20:43:17 <Quartus__> Based on some original factor code?
20:43:33 <slava> no, he wrote it concurrently in forth, postscript and factor
20:43:41 <Quartus__> ah
20:43:43 <slava> a simple loop benchmark.
20:43:47 <slava> but the forth code is not idiomatic.
20:44:18 <slava> i guess he thought passing an xt would make it comparing apples to apples, except in factor's case no xt is passed around once everything is inlined and compiled.
20:44:18 <Quartus__> I don't think of Ertl as the ideal Forth coder.
20:44:28 <slava> really? gforth is quite an achievement
20:44:50 <Quartus__> hmm, maybe. 
20:45:07 <slava> well, it's the most solid free ANS forth for linux, I would think. unless you know of another one
20:45:32 <Quartus__> gforth is a good forth, but that doesn't mean he's the best Forth coder. Not the same skillset, really.
20:45:38 <slava> true.
20:46:00 <slava> does he write libraries for gforth or just maintain the compiler?
20:46:45 <Quartus__> ii'm sure some of the library code is his.  A lot is Bernd's.
20:56:35 <Quartus> my 'hmm maybe' was in regard to your guess about passing an xt
20:58:06 <Quartus> He may also consider the last speedup of ~2x to be unimportant, as I often do
21:03:36 --- quit: edrx (Read error: 60 (Operation timed out))
21:03:55 --- quit: skas_wk ("Leaving")
21:07:57 --- join: skas_wk (n=skas@121.127.198.32) joined #forth
21:43:51 --- join: nighty^ (n=nighty@sushi.rural-networks.com) joined #forth
21:47:47 --- part: skas_wk left #forth
21:57:38 --- join: brx` (n=brx@p57A781E2.dip0.t-ipconnect.de) joined #forth
21:59:19 --- join: brx`` (n=brx@p57A78016.dip0.t-ipconnect.de) joined #forth
22:07:27 --- quit: brx (Read error: 110 (Connection timed out))
22:10:24 --- quit: nighty^ ("Disappears in a puff of smoke")
22:12:37 --- join: brx (n=brx@p57A7C2ED.dip0.t-ipconnect.de) joined #forth
22:16:05 --- quit: brx` (Read error: 110 (Connection timed out))
22:19:51 --- quit: brx`` (Read error: 110 (Connection timed out))
22:30:49 --- join: brx` (n=brx@p57A7ADAB.dip0.t-ipconnect.de) joined #forth
22:43:41 --- join: brx`` (n=brx@p57A7BCD4.dip0.t-ipconnect.de) joined #forth
22:47:28 --- quit: brx (Connection timed out)
22:51:51 --- quit: brx` (Connection timed out)
22:53:47 --- quit: iano ()
23:09:01 --- join: ygrek (i=user@gateway/tor/x-55e2cc06cc0afa41) joined #forth
23:34:18 --- join: ecraven (i=nex@eutyche.swe.uni-linz.ac.at) joined #forth
23:42:21 --- join: brx (n=brx@p57a7ae73.dip0.t-ipconnect.de) joined #forth
23:59:05 --- quit: brx`` (Read error: 110 (Connection timed out))
23:59:59 --- log: ended forth/07.05.03