00:00:00 --- log: started forth/04.01.21
00:01:41 --- quit: Serg ()
02:18:45 --- join: qFox (C00K13S@cp12172-a.roose1.nb.home.nl) joined #forth
03:17:05 <warpzero> madgarden: you might be right
05:15:49 --- join: fridge (~hovil@CommSecureAustPtyLtd.sb1.optus.net.au) joined #forth
05:17:00 <fridge> Gong hee fot choy!
05:19:19 <warpzero> What.
05:19:42 <fridge> happy chinese new year!
05:19:51 <warpzero> Oh okay.
05:27:51 --- quit: qFox ("if at first you dont succeed, quit again")
05:35:29 <I440r> fridge speaks chinese ?
05:35:30 <I440r> heh
05:36:58 --- quit: I440r ("Leaving")
05:37:14 <warpzero> What.
05:37:21 <warpzero> Don't quit I440r
05:41:17 --- join: qFox (C00K13S@cp12172-a.roose1.nb.home.nl) joined #forth
06:14:38 <mmanning> heh im here
06:14:53 <mmanning> hadzta go to werk
06:16:15 <warpzero> yay
06:16:18 * warpzero hugs mmanning
06:16:51 <warpzero> I still can't decicde wether to use bit-packed or fully byte-aligned bytecode.
06:54:38 <mmanning> hrm try both
06:54:40 <mmanning> then decide
06:54:59 <mmanning> lol no hugging unless ur a cutensexy single chixybabe :P
06:55:17 <warpzero> yes. hugging.
07:22:16 --- quit: qFox (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: fridge (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: ayrnieu (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: scope (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: cmeme (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: madgarden (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: mmanning (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: skylan (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: ianp (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: chandler (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: Robert (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: TreyB (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: warpzero (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: ooo_ (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: ChanServ (brunner.freenode.net irc.freenode.net)
07:22:16 --- quit: mur (Remote closed the connection)
07:22:39 --- join: ChanServ (ChanServ@services.) joined #forth
07:22:39 --- join: mur (~mur@smtp.uiah.fi) joined #forth
07:22:39 --- join: qFox (C00K13S@cp12172-a.roose1.nb.home.nl) joined #forth
07:22:39 --- join: fridge (~hovil@CommSecureAustPtyLtd.sb1.optus.net.au) joined #forth
07:22:39 --- join: ayrnieu (~julian@206.61.132.55) joined #forth
07:22:39 --- join: chandler (~chandler@d-84-77.dhcp-149-159.indiana.edu) joined #forth
07:22:39 --- join: scope (~junk@njd.paradise.net.nz) joined #forth
07:22:39 --- join: madgarden (~madgarden@Kitchener-HSE-ppp3576567.sympatico.ca) joined #forth
07:22:39 --- join: mmanning (~mmanning@saturn.vcsd.com) joined #forth
07:22:39 --- join: cmeme (~cmeme@216.184.11.30.unused.swcp.com) joined #forth
07:22:39 --- join: Robert (~snofs@c-9d5a71d5.17-1-64736c10.cust.bredbandsbolaget.se) joined #forth
07:22:39 --- join: skylan (~sjh@vickesh01-4878.tbaytel.net) joined #forth
07:22:39 --- join: ianp (ian@inpuj.net) joined #forth
07:22:39 --- join: ooo_ (o@virgo.bombsquad.org) joined #forth
07:22:39 --- join: warpzero (~warpzero@dsl.142.mt.onewest.net) joined #forth
07:22:39 --- join: TreyB (~trey@cpe-66-87-192-27.tx.sprintbbd.net) joined #forth
07:22:39 --- mode: brunner.freenode.net set +o ChanServ
07:34:58 <madgarden> warpzero: Is code size a big issue?
07:35:22 <warpzero> maybe.
07:35:33 <warpzero> it will be used as a network protocol too
08:22:30 <chandler> eh, I wouldn't deal with bit-packed for network
08:27:12 <warpzero> The thing is codes need like 2-3 bits.
08:27:47 <chandler> nibble aligned then? :-)
08:28:00 <warpzero> ?
08:28:02 <warpzero> Whats that?
08:28:32 <chandler> nibble is four bits
08:28:52 <chandler> so two instructions per byte
08:29:09 <warpzero> Its more markup-type stuff than instructions.
08:29:14 <chandler> oh
08:32:35 <warpzero> in 2/3 contexts it need a whole two bits
08:36:11 <warpzero> Yah nibble aligned sounds damn good.
08:42:20 <warpzero> chandler: thanks for the idea man
09:33:19 <mmanning> wisconsin supremem court is hearing final arguements on the permanant injunction to the concealed carry law today.  the hope is that they will lift the injunction (they should and the judge that made it should be impeaced).
09:34:13 <mmanning> missouri will be having a vote today to override the gov's veto of THEIR concealed carry law - they might override it (fingers crossed that they do)
09:34:23 <Robert> Hehe
09:34:38 <mmanning> impeached grr i cant type
09:34:43 <mmanning> supreme  grrr
09:34:48 <Robert> More guns for the mental patients!
09:34:53 <mmanning> yes!
09:34:58 <mmanning> specialy the sane ones
09:35:02 <Robert> :D
09:35:06 <mmanning> like me
09:35:09 <mmanning> *twitch*
09:35:12 <Robert> Exactly
09:35:15 <mmanning> !
09:35:20 * Robert ported his VM from one microcontroller to another
09:35:53 <Robert> And found the PIC is pretty efficient after all. About 50% of an AVR running at the same clock frequency
09:36:02 <Robert> For a Forth VM with a simple benchmark program :)
11:12:46 --- join: kc5tja (~kc5tja@66-91-231-74.san.rr.com) joined #forth
11:12:47 --- mode: ChanServ set +o kc5tja
11:13:13 <kc5tja> Well, I recoded that stupid performance test such that J always had a vector of 32-bit integers.
11:14:04 <kc5tja> I didn't realize previously that J resized vectors as appropriate, and a vector of all 0's occupied only 4KB of memory, 32KB once an element exceeded 255.
11:14:14 <mur> Technician: "What a bad day! The PC is not working well,         the phone is out of order, and I wounded my fingers when trimming         the network plug with a knife to fit the PC hole." 
11:14:16 <kc5tja> Re-running the test, I found J took 55 minutes to complete the test.
11:14:33 <kc5tja> I then fixed my FS/Forth source code (NO modifications to the compiler itself) for the same test.
11:14:42 <kc5tja> I eliminated one loop and, hence, one conditional.
11:14:46 <kc5tja> The test ran in 33 minutes!
11:14:54 <kc5tja> FS/Forth wiped the floor with J!  w00t!
11:15:24 <kc5tja> 4x performance improvement in Forth code, and twice the performance of J, by re-arranging code to eliminate one conditional and one loop.
11:16:10 <kc5tja> There is hope for FS/Forth yet.
11:16:49 <mmanning> kc5 can i have the source for that test? - would it compile under isforth ?
11:17:02 <mmanning> if isforth is faster than j then j sux heh
11:17:20 <mmanning> isforth is by NOOOO means what so ever a "fast" forth
11:18:28 <warpzero> kc5tja: Can I get the general form of that test? C will do.
11:22:53 <chandler> kc5tja: where can you get a j implementation?
11:23:26 <chandler> also, what benchmark are you using?
11:24:18 <kc5tja> |: v vector [ 16384 allot                                        |
11:24:18 <kc5tja> |: v+ 1 over +! 4 + ;                                            |
11:24:18 <kc5tja> |: +1 v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ ;          |
11:24:18 <kc5tja> |: +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 ;          |
11:24:18 <kc5tja> |: +3 v +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 drop ;   |
11:24:19 <kc5tja> |: t' ? if +3 1- t' ;; then drop ;                               |
11:24:22 <kc5tja> |: t [entry-point] 16777216 t' bye ;                             |
11:24:30 <kc5tja> Oops, it skipped the top line.
11:24:33 <kc5tja> : vector r> ;
11:24:35 <chandler> yipes
11:25:29 <kc5tja> chandler: The benchmark is my own, based on a specific project-related need for one of my clients (I think it's a sure bet at this point that he'll rely on my software development services.  *YES!*)
11:25:45 <kc5tja> chandler: http://www.jsoftware.com
11:25:54 <mmanning> kc can i have a job ??? :)
11:25:55 <mmanning> heh
11:26:36 <kc5tja> mmanning: Not at this time.  There's no way this job will even supplant my In-N-Out income.  Only if word-of-mouth and repeat business happens will I be able to ditch that job.
11:27:20 <mmanning> i wasnt serious, im good here for now - at least till the end of the month
11:27:24 <chandler> do you have a web site for your professional services?
11:27:37 <kc5tja> chandler: A *slightly* out of date version is http://www.falvotech.com
11:27:44 * kc5tja really has to go through and update the site.
11:27:58 <chandler> cool
11:29:52 <kc5tja> I'm going to target custom software development for Linux boxes, especially embedded applications.
11:30:18 <kc5tja> And you can bet that FS/Forth will be a prominent/prominant/(however you spell it) player in my strategy.
11:30:46 <warpzero> Heh.
11:31:05 <kc5tja> My current project has to be written in C++, unfortunately.
11:31:06 <warpzero> When I get AF into orbit you will bet I will do the same thing.
11:32:35 <warpzero> kc5tja: We come from the opposite ends though... FS/Forth is meant to be tiny for embedded applicatoins, and AF is meant to scale infinitely.
11:32:52 <kc5tja> I intend on writing world-class desktop applications in FS/Forth too.
11:33:07 <warpzero> Even so.
11:33:43 <warpzero> I mean I will be happy if the AF bytecode interpereter goes faster than Java.
11:34:18 <mmanning> i dont understand the definition for v or vector. - why isnt v defined as |: v r> [ 16384 allot   - and what happens when v is executed ?
11:34:32 <mmanning> ooh
11:34:51 <mmanning> vector just prevents v from actually running !
11:34:57 <kc5tja> Because r> will pop the return address, and then will promptly start executing "instructions" in the alloted buffer.
11:34:59 <mmanning> so the r> HAS to be in a call
11:35:24 <mmanning> why cant v be create x allot ?
11:35:46 <kc5tja> Because (a) I don't have create, and (b) it produces *exactly* the same run-time code anyway.  So I'm going to stick with what I have now.
11:36:46 <kc5tja> I will probably implement CREATE later on in FS/Forth's development.
11:36:50 <mmanning> ok
11:36:51 <kc5tja> But for the time being, I have to do it by hand.
11:37:11 <warpzero> kc5tja: So I decided on nibble-aligned bytecode.
11:37:15 <mmanning> thats clever actually, you could make some really obfuscated forth doing this hehe
11:37:26 <kc5tja> mmanning: It's plain as day to be.
11:37:31 <kc5tja> ColorForth uses this technique all over the place.
11:37:58 <mmanning> kc5 no im not calling the above obfuscated, im saying you COULD use the technique to create some obfuscated forth :)
11:38:01 <kc5tja> In this case, I'm defining (:) v to be a vector, with 16384 bytes.
11:38:11 <mmanning> what is [entry-point] ?
11:38:15 <warpzero> kc5tja: Can you DCC me the .c?
11:38:22 <kc5tja> warpzero: What .c?
11:38:39 <warpzero> kc5tja: You said you benchmarked this in C...
11:38:44 <kc5tja> [entry-point] is a word that (a) sets the ELF entry-point address, and (b) inlines code to configure the data and return stacks.
11:38:51 <mmanning> aha got it
11:39:16 <kc5tja> warpzero: I already posted the C sources yesterday.  Check the IRC logs.
11:39:27 <kc5tja> It's only 21 lines long.
11:40:00 <kc5tja> Man, I just can't believe that making that slight change caused FS/Forth's performance to quadruple.
11:40:13 <kc5tja> Suddenly, Jeff Fox's claims of 10x this and 10x that has a lot of validity.  :D
11:40:20 <mmanning> 16777216  <-- this is some address ?
11:40:26 <kc5tja> mmanning: No.  It's a loop counter.
11:40:42 <mmanning> whats ? then ?
11:40:54 <kc5tja> ? compiles an OR EAX,EAX instruction to make sure the flags are set.
11:41:17 <mmanning> words can just refer to self ?
11:41:20 <kc5tja> Yes.
11:41:23 <mmanning> ok
11:41:29 <kc5tja> Both ; and ;; do proper tail-call optimization.
11:41:56 <mmanning> that definition confuses me, i cant figure out what ;; does either heh
11:41:57 <chandler> don't let the schemers infest your vocabulary
11:42:02 <chandler> say "space-safe tail-calls"
11:42:04 <mmanning> ive no idea how to convert that to isforth
11:42:08 <kc5tja> : ;; POSTPONE EXIT ; IMMEDIATE
11:42:22 <mmanning> aha
11:42:29 <mmanning> why not just use "exit"
11:42:37 <mmanning> why have a special word to compile in an exit for you ?
11:42:48 <kc5tja> Too wordy, hard to type compared to just ;;, and I use it so often that it deserves a shorter name.
11:43:01 <mmanning> i can accept that :)
11:43:02 <kc5tja> mmanning: Because it does the job of ; without actually terminating the definition.
11:43:20 <mmanning> yes - i got that part, the definition isnt "terminated" just teh execution of the definition
11:43:26 <kc5tja> Frankly, I'm rather surprised that EXIT hasn't had its own shorthand a long time ago.
11:43:52 <mmanning> like "and" "or" "xor" renames im thinking of implementing for isforth
11:44:01 <mmanning> & | ^ etc
11:44:02 <kc5tja> & | and ^?
11:44:05 * kc5tja nods
11:44:07 <mmanning> yes
11:44:24 <mmanning> isforth.clss.net details it a little - im not FULLY decided to do this yet
11:44:37 <kc5tja> Apparently, the APL community, even those who regularly use J and K, appear to prefer explicit symbols for all the major keywords, verbs, adverbs, etc.
11:44:47 <mmanning> what flags is "?" checking ?
11:44:59 <kc5tja> mmanning: See OR EAX,EAX to find out what it does.  :)
11:45:04 <mmanning> oh lol
11:45:10 <mmanning> eax is top of stack ?
11:45:17 <kc5tja> IF compiles a JZ instruction, and -IF compiles a JNS instruction.
11:45:20 <kc5tja> Yes
11:45:23 <mmanning> ok
11:45:50 <mmanning> ok, i think ive converted this to isforth
11:45:51 <kc5tja> And I don't know what is wrong with Chuck Moore, but he claims he rarely, if ever, uses -IF.  
11:45:56 <mmanning> how long does it take in j ?
11:45:59 <kc5tja> I, however, use it a good 3* as much as IF!
11:46:26 <mmanning> xxxxx not if .....then   <-- very common
11:46:36 <kc5tja> If I set a=:4096#0, it takes about 25 minutes.  But if I set a=:4096#65536, it takes 55 minutes.
11:46:45 <kc5tja> mmanning: I just reverse the IF/ELSE clauses in that case.
11:46:53 <kc5tja> Tail-call optimization makes it easier to do productively.
11:46:59 <mmanning> assuming there is an else
11:47:10 <mmanning> i do the same unless it affects readablilty
11:47:30 <kc5tja> mmanning: I just document the implementation detail in the shadow comments.
11:47:50 <kc5tja> The original FS/Forth code took 126 minutes to complete the test.
11:47:52 <kc5tja> (!!)
11:48:05 <kc5tja> The new FS/Forth code takes 31:56 (minutes:Seconds).
11:48:06 <warpzero> kc5tja: So you say you are going to make powerful desktop apps with FS/forth, how are you planning on doing IO networking etc etc.
11:48:23 <kc5tja> warpzero: I'm going to hook into C libraries as needed.
11:48:24 <mmanning> well i think it just ran in a few seconds on isforth
11:48:28 <mmanning> i cant believe that
11:48:33 <mmanning> musta did sumthing wrong
11:48:39 <kc5tja> mmanning: What is your processor speed?
11:49:02 <mmanning> ohhh yea lol - im running it on a dual processor on the server at work lol
11:49:03 <kc5tja> phone...
11:49:42 <mmanning> no - i didnt run it in a few seconds
11:49:51 <mmanning> it ran for a few seconds and then segfaulted lol
11:49:54 <mmanning> theres a difference :P
11:50:00 <warpzero> LOL
11:51:11 <mmanning> that 4+ is making my code run beyond the end of the allocated buffer for sure
11:51:56 <mmanning> either that or im getting a return stack overflow
11:52:07 <warpzero> kc5tja: What was your speed for C?
11:52:34 <mmanning> im certain its a return stack overflow, i dont have a 16777216 cell return stack
11:54:09 <kc5tja> warpzero: I have an 800MHz Athlon, so I have two timings.  One without CPU-specific optimizations, 18 minutes.  One with optimization (-march=athlon -O3 -fomit-frame-pointer), 3 minutes.
11:54:32 <kc5tja> The K language took 9 minutes, but I set a:4096#0.  I'm trying it again with 4096#65536, just to make its comparison match that of J's.
11:54:36 <warpzero> Thats uh... alot faster than J.
11:54:57 <kc5tja> warpzero: Remember: the J I downloaded is a binary, and is not at all compiled for my box.
11:55:11 <kc5tja> In fact, the 'free versions' of J, I'm pretty sure, are deliberately speed-wise crippled.
11:55:25 <mmanning> how big is your return stack kc ?
11:55:26 <kc5tja> You have to pay $450 at least for a commercial version of J, and even then, it's ONLY for Windows or PocketPC.
11:55:30 <kc5tja> mmanning: 4KB.
11:55:51 <mmanning> then how can you have t' recurs that many times
11:55:58 <mmanning> 16777216  <--
11:56:05 <kc5tja> mmanning: Are you attempting to use recursion??  Good lord, don't; my Forth is built specifically to handle looping by recursion.  For you, you will want to use BEGIN/WHILE/REPEAT or BEGIN/AGAIN.
11:56:18 <mmanning> ok lol
11:56:18 <kc5tja> mmanning: You DO know what tail-call optimization is, right?
11:56:24 <mmanning> i was attempting to not overly modify your code
11:56:29 <mmanning> lol yes
11:56:32 <kc5tja> :)
11:56:34 <kc5tja> Just making sure.  :D
11:56:38 <warpzero> How high do these numbers go?
11:56:50 <kc5tja> warpzero: I don't care about wrap-around.
11:56:50 <warpzero> Like I'm getting a count of somesort on my screen...
11:57:05 <kc5tja> warpzero: Oh, the progress indicator goes to 4096.
11:57:07 <warpzero> kc5tja: No I'm running the C one.
11:57:27 <warpzero> i should probably run it with time eh
11:57:29 <mmanning> : t' begin +3 1- until drop ;
11:57:29 <mmanning> : t' begin +3 1- until drop ;
11:57:29 <mmanning> : t' begin +3 1- until drop ;
11:57:29 <mmanning> : t' begin +3 1- until drop ;   <-- ?
11:57:37 <mmanning> argh why did that past 4 times
11:57:50 <mmanning> no thats definatly wrong lol
11:57:55 <kc5tja> mmanning: Because you're corrupting the stack.  :)  until consumes the argument.
11:58:13 <kc5tja> : t' begin dup while +3 1- repeat drop ;
11:58:38 <kc5tja> Or, more closely to what I have,
11:59:06 <kc5tja> : t' begin dup 0= if exit then +3 1- again ;
11:59:13 <mmanning> ill use that one
11:59:54 <mmanning> running - hope nobody notices the 100% cpu on the server heh
12:00:01 <kc5tja> Maybe I'll introduce another primitive ~if and +if, which are logically negated forms of if and -if.
12:00:12 <kc5tja> mmanning: Are you running it with 'time'?
12:00:25 <mmanning> timer-reset t .elapsed
12:00:33 <kc5tja> Awesome.
12:00:33 <mmanning> its not turnkeyed
12:00:42 * kc5tja will probably have to rip your code for that, because I want that facility in FS/Forth too.
12:00:52 <mmanning> this is with isforth on an "i dont know how fast" dual something or other
12:01:08 <kc5tja> You use direct threading, right?
12:01:13 <mmanning> yes
12:01:16 <chandler> mmanning: what kind of server?
12:01:20 <chandler> what proc that is
12:01:20 <kc5tja> GForth took 47 minutes on my 800MHz Athlon.
12:01:36 <mmanning> you hereby have full permission to rip any pieces parts of isforth that you think you might want lol
12:01:54 <kc5tja> (which surprises me in retrospect; GForth is *fast* for a direct-threaded Forth.  It beat J's second test run.)
12:02:01 <kc5tja> HAHAH!
12:02:05 <mmanning> erm i cant run this at 100% cpu for an hour NOW!! ill have to kill it till later
12:02:17 <kc5tja> When I changed K's test to ensure a maximally wide vector, K actually ran faster than it did before.
12:02:18 <mmanning> ill run it on my laptop
12:02:22 <mmanning> 1800 mhz athlon
12:02:23 <kc5tja> 8 minutes.
12:02:54 <warpzero> FS/Forth?
12:03:02 <chandler> can you paste the non-fsforth version (gforth maybe) at http://www.common-lisp.net/paste/new - select the channel "#ifdef"
12:03:05 <kc5tja> warpzero: No, K.
12:03:09 <warpzero> Ah.
12:03:20 <mmanning> create v 16384 allot
12:03:20 <mmanning> : v+ 1 over +! 4 + ;
12:03:20 <mmanning> : +1 v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ v+ ;
12:03:20 <mmanning> : +2 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 ;
12:03:20 <mmanning> : +3 v +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 +2 drop ;
12:03:21 <mmanning> : t' begin dup 0= if exit then +3 1- again ;
12:03:23 <mmanning> : t 16777216 t' ;
12:03:25 <chandler> eh, ok
12:03:27 <warpzero> I'm only up to 2500/4096
12:03:28 <mmanning> thats what ill be using in isforth
12:04:41 <kc5tja> I haven't updated GForth's code to the new explicit looping code yet.
12:04:45 <kc5tja> Do you want the old code, or the new code?
12:05:22 <chandler> mmanning's version works
12:05:27 <chandler> dunno how to do timed execution in mops
12:05:43 <warpzero> Stop watch?
12:05:57 <warpzero> kc5tja: Why is this thing accelerating as it goes?
12:07:04 --- join: Nutssh (~Foo@gh-1177.gh.rice.edu) joined #forth
12:07:11 <kc5tja> warpzero: It runs constant speed in my system.
12:07:21 <kc5tja> I suspect it's because your environment manages yoru cache or virtual memory differently.
12:07:26 <warpzero> real    9m28.149s
12:07:26 <warpzero> user    8m1.237s
12:07:26 <warpzero> sys     0m0.181s
12:07:40 <warpzero> Thats unoptimized.
12:07:54 <kc5tja> You have a 1.4GHz box, right?
12:09:00 <mmanning> my 1800 mhz athlon is now running it in isforth
12:09:03 <kc5tja> I'm retesting on gforth now.
12:09:20 <kc5tja> mmanning: Cool.
12:09:45 <mmanning> i dont know what processor it uses heh
12:09:46 <kc5tja> I already got the numbers I needed to fill out my proposal to the client, so now this stupid benchmark (and it is stupid), is just plain fun to toy with.
12:09:51 <mmanning> the server i mean
12:10:33 <warpzero> kc5tja: No Its a 1.7 but its competing with lots of stuff on here.
12:10:48 <kc5tja> Yeah, I ran my tests while IRCing last night, and playing CDs.  :)
12:10:57 <mmanning> lol
12:11:03 <warpzero> optimized in 1:50
12:11:12 <mmanning> fs will be faster than isforth - i can guarantee it
12:11:16 <mmanning> so will gforth probably
12:11:20 <kc5tja> mmanning: That was deliberate.  I *should* have also included playing four or five MPEGs while it was running too, but I don't have any MPEGs that last that long.
12:11:27 <mmanning> if j is slower ill be very supprised heh
12:11:38 <kc5tja> I wouldn't be.
12:11:41 <mmanning> kc5 i do :)
12:11:44 <mmanning> no - not pr0n
12:12:09 <kc5tja> If only I had a DVD drive, then I could rip a movie, then attempt to play one off the DVD, and the other off the harddrive.
12:12:20 <mmanning> lol
12:12:26 <kc5tja> Serious.
12:12:33 <mmanning> it segfaulted :/
12:12:48 <kc5tja> I can't go into details about the project, but let's just say it requires a lot of data movement between different things.
12:13:11 <kc5tja> mmanning: ??
12:13:16 <mmanning> yup. kaboom
12:13:29 <kc5tja> There's nothing to cause a segfault in the program.  :(
12:13:32 <mmanning> neway - back to werk
12:13:36 <kc5tja> How big is your return stack?
12:13:52 <mmanning> thers no recurson in there so thats not the issue
12:14:03 <mmanning> le me check size
12:14:10 <kc5tja> Yeah, I just wanted to make sure it's not something like 16 bytes.  :)
12:14:18 <kc5tja> 1K ought to be *plenty* for this.
12:14:21 <kc5tja> Way overkill in fact.
12:14:29 <chandler>  PowerMops  260.63s user 0.71s system 82% cpu 5:16.61 total
12:14:33 <warpzero> whoa
12:14:40 <warpzero> user    0m48.701s
12:14:43 <chandler> but that number's probably high
12:15:03 <mmanning> $4000 bytes
12:15:06 <kc5tja> 5 minutes on a PowerPC.  What speed PPC?
12:15:14 <warpzero> OH hey!
12:15:15 <chandler> 2Ghz G5 :-)
12:15:20 * warpzero gets out his G3
12:15:47 <warpzero> kc5tja: I went from 1:50 to :48
12:15:50 <mmanning> $1000 cells 
12:16:07 <kc5tja> chandler: Do you know if MOPS is direct-threaded or native code compiling?
12:16:10 <kc5tja> mmanning: Plenty.
12:16:22 <chandler> native code compiling
12:16:34 <kc5tja> chandler: Hmm...that's not nearly as good as I would have expected then.
12:16:43 <chandler> ok, just letting it sits there racks up about 2s in user runtime. I'm going to try it loading from a file
12:17:25 <warpzero> kc5tja: one g3 700Mhz benchmark coming up
12:17:27 <kc5tja> You know, I should implement that nefarious "A" register in  FS/Forth and rerun the test with THAT.  :D
12:17:38 <warpzero> A?
12:17:53 <kc5tja> warpzero: The address register in Chuck's MISC chips and MachineForth implementations.
12:18:05 <warpzero> ah
12:18:26 <warpzero> kc5tja: Rerun the C one on your system with -march -O3 -funroll-loops
12:18:38 <kc5tja> Many people have major issues with it because it represents a global variable in an otherwise stack-based architecture.
12:18:59 <kc5tja> warpzero: Later; gforth is still churning on the program.  :)
12:20:41 --- quit: Nutssh (Read error: 104 (Connection reset by peer))
12:21:07 <mmanning> is it ONLY for addresses ?
12:21:15 <mmanning> or can it be general purpose
12:21:38 <chandler>  PowerMops  258.73s user 0.99s system 95% cpu 4:32.45 total
12:21:41 <chandler> ok, so same deal
12:21:49 <chandler> 4 mins 20 seconds
12:22:11 <chandler> what kind of times are you getting on what speed proc?
12:23:43 --- join: Nutssh (~Foo@gh-1177.gh.rice.edu) joined #forth
12:24:50 * mmanning had the drop missing on the end of +3
12:24:52 <mmanning> running again
12:26:54 <kc5tja> chandler: I'm getting 33 minutes on an 800MHz AMD Athlon with subroutine threading with inlined primitives.  No compiler optimization at all, except for tail-call optimization (required to do the loops).
12:28:41 <mmanning> kc you should publish the benchmark on clf :)
12:31:25 <kc5tja> mmanning: Heh
12:31:30 <kc5tja> It's not a terribly useful benchmark.
12:31:37 <kc5tja> Others are substantially more interesting and useful.
12:32:02 <warpzero> WTF
12:32:11 <warpzero> Fucking computers
12:32:15 --- quit: Nutssh ("Client exiting")
12:32:46 <mmanning> kc5 bullshit - there isnt a SINGLE benchmark out there that acutlly serves any usefull purpose except for fun :)
12:33:04 <mmanning> well not quite true
12:33:48 <mmanning> isforth has two versions of teh same benchmark - one using variables, the other using vars - it simply benchmarks the difference between the to WITHIN isforth
12:34:01 <kc5tja> Of course.  All benchmarks have a context.
12:34:32 <kc5tja> In my case, I'm attempting to compare vector operation performance.
12:34:37 <kc5tja> Forth is failing miserably.  :D
12:34:42 <mmanning> run benchmark x on different computers or under different compilers and it tells you next to nothing about either :P
12:34:54 <mmanning> shhh!
12:35:38 <kc5tja> shhh my butt.  J, FS/Forth, ColorForth, K, and C, in that order.
12:35:40 --- join: Nutssh (~Foo@gh-1177.gh.rice.edu) joined #forth
12:35:47 <kc5tja> ColorForth ran in 13 minutes on my box.
12:37:09 <mmanning> how long did it take J ?
12:37:15 <chandler> kc5tja: can you paste the j version?
12:37:23 <kc5tja> 25 minutes best case, 55 minutes worst case.  But remember that the J binary isn't optimized.
12:37:31 <kc5tja> chandler: Yep.  Gimme a second.
12:37:34 <mmanning> neither is isforth lol
12:37:38 <Nutssh> What're you testing? 
12:38:21 <kc5tja> a=:4096#65536
12:38:21 <kc5tja> inc=:3 : 'a=:a+1'
12:38:21 <kc5tja> (inc^:16777216)''
12:38:21 <kc5tja> (2!:55)0
12:39:09 <kc5tja> Nutssh: Just a stupid benchmark, that is yielding interesting comparisons between languages.
12:39:25 <mmanning> and implementations thereof heheh
12:39:45 <kc5tja> mmanning: That *sucks* that your code crashed....I really want to see the timings.
12:40:14 <mmanning> its not crashed since inserting teh missing drop in +3
12:40:16 <mmanning> its still running
12:40:36 <mmanning> kc ill bet you $948562986592 that your forth is faster than mine :)
12:40:36 <kc5tja> mmanning: Oh.
12:40:50 <kc5tja> You're on.  Pay up, buddy.  :D
12:40:57 <mmanning> its like Howlin Wolfs song... built for comforth not for speed :)
12:41:08 <kc5tja> mmanning: Ditto for me.
12:41:12 * mmanning injects some extra loops here and there.....
12:41:17 <mmanning> *snicker*
12:41:18 <kc5tja> I'm expecting to get higher throughput/performance by exploiting vectors.
12:41:36 <kc5tja> But I won't do that until I actually have a real assembler for it.
12:41:51 <kc5tja> I sure as hell am not going to hand-code machine language to deal with vectors.  :D
12:41:55 <warpzero> kc5tja: How do you mean?
12:42:04 <mmanning> whats wrong with that assembler you wrote a while ago ?
12:42:14 <kc5tja> mmanning: Nothing, except that it was a 16-bit assembler.
12:42:19 <mmanning> oh yea
12:42:20 <mmanning> lol
12:42:22 <kc5tja> I'm going to start over from scratch for the 32-bit version.
12:42:33 <mmanning> me 2 :P
12:42:35 <mmanning> some day
12:42:44 <warpzero> Why not just use nasm/gas?
12:42:51 <mmanning> err no thanx
12:43:02 <kc5tja> warpzero: The assembler is for coding Forth primitives.
12:43:12 <kc5tja> warpzero: My Forth is written in Forth itself.
12:43:18 <kc5tja> warpzero: Ergo, nasm/gas won't work.  :)
12:43:30 <warpzero> Meh.
12:43:45 <warpzero> Is there a forth that just acts as a gcc/binutils frontend?
12:44:14 <kc5tja> No, because then it wouldn't be Forth (one of Forth's traits is that it is an interactive development environment; gcc is anything but interactive.)
12:44:36 <warpzero> And FS/Forth is?!?
12:46:31 <mmanning> kc5 - yes gcc is interactive, it has 29486592386598274 pieces parts all interacting with each other through pipes during compile!!!!
12:46:34 <mmanning> does that count ?
12:46:35 <mmanning> hehe
12:48:41 <warpzero> lol
12:51:51 <chandler> kc5tja: heh, no, it could call out to gcc for every colon definition
12:53:20 <warpzero> Okay folks anyone want to give me some feedback on my bytecode specification?
12:55:10 <kc5tja> OK, gforth is going on 45 minutes, so the change in code didn't make GForth go any faster at all.
12:55:25 <kc5tja> Anyway, I need to get out of here.  I have to get my hair cut again, and then I need to meet someone for lunch.
12:55:38 <warpzero> kc5tja: G3 results are pending hold on a sec.
12:56:21 <warpzero> kc5tja: Optimized: 3:33
12:56:30 <chandler> warpzero: what forth?
12:56:39 <warpzero> chandler: gcc?
12:57:00 <mmanning> isforth still running test
12:57:16 <warpzero> mmanning: how far is it?
12:57:45 <mmanning> i got no idea how far it is hehe
12:57:55 <mmanning> ill tell you how far it is when its finished :P
12:58:01 <warpzero> Oh. The C version prints out how far it is.
12:58:19 <mmanning> which will skew the c results
12:58:28 <warpzero> Uh
12:58:38 <warpzero> system time is .163 seconds i dont think so
12:58:46 <mmanning> lol
12:58:59 <kc5tja> Yes, .163 seconds versus *minutes* is more than two orders of magnitude.  It's noise.
12:59:24 <warpzero> kc5tja: So colorforth is winning the forth battle?
12:59:32 <kc5tja> I used to have it in Forth too, but then I took it out because you can't redirect stdout when running with bash's time.
12:59:37 <kc5tja> warpzero: Yes.
12:59:55 <kc5tja> And I did *not* use the A register to implement the vector walk either.
13:00:01 <kc5tja> I wonder how long it'd take using the A register.
13:00:27 <warpzero> kc5tja: Where do I get colorforth?
13:00:37 <kc5tja> I use XcolorForth.
13:00:50 <kc5tja> You can google for XcolorForth and that should give you Mark Slicker's website.
13:01:05 <warpzero> Er uh well nevermind.
13:01:11 <kc5tja> Otherwise, you can get Chuck's original copy at http://www.colorforth.com
13:01:23 <warpzero> When will FS run on PPC?
13:01:33 <kc5tja> However, note that Chuck's version doesn't boot on 99% of the computers out there, so . . . :)
13:01:49 <kc5tja> warpzero: When someone donates a PowerPC for my use.  :)
13:02:01 <kc5tja> (or when I can afford to purchase a PowerPC box on my own)
13:02:01 <warpzero> kc5tja: Is shell fine?
13:02:37 <kc5tja> Sure, but it'll take some time to finish.
13:02:59 <kc5tja> Besides, I'd like to actually finish FS/Forth for x86 first.
13:03:10 <warpzero> >:(
13:03:17 <warpzero> I'm going to develop AF in tandem on both.
13:04:04 <kc5tja> Well, there are very real differences between the PPC architecture and x86, which means I would need to spend some time learning all about them.
13:04:13 <kc5tja> Some things may be incompatible with how I have FS/Forth now.
13:04:43 <warpzero> PPC isn't a whole lot different from other big-endian 32-bit RISC instruction sets like MIPS or whatever.
13:06:07 <kc5tja> True, but I'd like the opportunity to start fresh with a new port.
13:06:23 <kc5tja> I've learned many things which would make writing FS/Forth easier if I were to start over from scratch.
13:07:18 --- quit: fridge ("Leaving")
13:07:56 <warpzero> I think its time that I write a utility that will take AF code and transform it into bytecode, and a utility that will do the opposite.
13:08:21 <kc5tja> warpzero: Maybe.  We'll definitely see.  Both yourself and Herkamire has expressed interest in a PowerPC port of FS/Forth, so a port is definitely probably in order.  :)
13:08:38 <kc5tja> Anyway, I need to get in the shower.  Back in about an hour or so.
13:08:41 * kc5tja is away: errands.
13:08:42 <warpzero> kc5tja: I can give you a shell on a G3.
13:08:46 <warpzero> If you need.
13:16:24 <mmanning> 50 minutes and 17 seconds
13:16:34 <mmanning> thats isforths time
13:16:45 <warpzero> mmanning: You don't win the race.
13:16:55 <mmanning> but i win my bet :)
13:17:04 <warpzero> You beat out gforth tho.
13:17:12 <mmanning> that supprises me
13:17:22 <mmanning> did i beat j ?
13:17:28 <mmanning> i forget j's time
13:20:28 <warpzero> Shit! I just realized I forgot something in my bytecode.
13:21:52 <warpzero> Good thing I left plenty of space!
13:23:05 <kc5tja> mmanning: By five minutes, you beat out J's later generation code.
13:23:22 <kc5tja> But remember, this is on MY box.
13:23:25 <kc5tja> An 800MHz box.
13:23:39 <kc5tja> So 50 minutes on a 1.4GHz box -- not good.  :)
13:23:45 <kc5tja> Compared to 55 minutes on an 800MHz box.  :D
13:23:51 <mmanning> no a 1800 mhz
13:24:00 <kc5tja> Oh, that's even worse.  :D
13:24:01 <warpzero> Not good.
13:24:01 <mmanning> so its WORSE
13:24:11 <mmanning> i TOLD you
13:24:17 <mmanning> built for comfort :)
13:24:29 <kc5tja> And it looks like you're slower than GForth too: the second test took longer: 65 minutes on an 800MHz box.  :D
13:24:59 <kc5tja> Which means that GForth has *crappy* subroutine-call overhead.  :(
13:25:07 <mmanning> some folks are built like this, some folks are built like that but you see me baby now dont you call me fat cuz im built for comfort, i aint built for speed.  but i got everything all the good girls need...
13:25:11 <mmanning> Howlin Wolf :)
13:25:14 <warpzero> GForth says its fast. But it lies.
13:25:37 <warpzero> kc5tja: Could you inline it?
13:25:48 <kc5tja> warpzero: Not easily, but it is possible.
13:25:53 <kc5tja> Lots of immediate words.  :)
13:25:58 <kc5tja> And text-expansion macros.
13:26:27 <kc5tja> But I have to get going and get my hair cut and other things.  I'll consider re-doing it later.
13:26:30 <mmanning> hrm lets see what it does if i make them m: definitions :)
13:26:38 <warpzero> ttyl kc5tja
13:28:53 <warpzero> is a unsigend long long 64 bits?
13:39:50 <Nutssh> I believe that is a gcc extension. 
13:40:08 <warpzero> Really?
13:40:46 <warpzero> I just made a program to check and its not giving me anything with -ansi
13:40:47 <Nutssh> There's standard C, but a lot of compilers have extra features beyond it. Some features work on more than one compiler too.
13:41:23 <Nutssh>            The -ansi option does not cause non-ISO programs to be rejected
13:41:23 <Nutssh>            gratuitously.  For that, -pedantic is required in addition to
13:41:23 <Nutssh>            -ansi.
13:41:44 <warpzero> longcheck.c:3: warning: ISO C90 does not support `long long'
13:41:55 <Nutssh> :)
13:42:09 <Nutssh> see  Options Controlling C Dialect  in the gcc manpage
13:42:34 <warpzero> So then how am I gunna support 64-bit unsigned big-endian integers.
13:42:45 <warpzero> er ?
13:43:28 <Nutssh> It may not be possible to *portably* support them. That doesnt' mean that they don't exist on many/most platforms.
13:44:03 <warpzero> Well if it needs to be ported with #ifdef or whatever thats fine. I guess.
13:44:12 <warpzero> I'm not happy about it though.
13:44:33 <Nutssh> Its outside the official  ISO C90 standard is all. 
13:44:39 <Nutssh>        -ansi
13:44:39 <Nutssh>            In C mode, support all ISO C90 programs.  In C++ mode, remove GNU
13:44:39 <Nutssh>            extensions that conflict with ISO C++.
13:45:11 <warpzero> Well I'm not really expecting anyone to use anything but gcc.
13:45:19 <warpzero> Maybe sun's or ibm's CC.
13:45:33 <warpzero> Edit: screw sparc
13:45:50 <Nutssh> Pedantically, what you want may not be possible. Practically, it is.  Also, there are newere dialects of C that can be checked for. See the manpage.
13:46:50 <warpzero> Wait a sec, the preprocessor isnt ansi?
13:47:49 <Nutssh> I don't think that C90 defines variable argument macro's even though GCC supports them.
13:50:35 <Nutssh> See also:
13:50:37 <Nutssh>        Options to Request or Suppress Warnings
13:52:31 <warpzero> Yeah I used -Wall
13:52:51 <Nutssh> See also:
13:52:53 <Nutssh>        -Wlong-long
13:52:53 <Nutssh>            Warn if long long type is used.  This is default.  To inhibit the
13:52:53 <Nutssh>            warning messages, use -Wno-long-long.  Flags -Wlong-long and
13:52:53 <Nutssh>            -Wno-long-long are taken into account only when -pedantic flag is
13:52:53 <Nutssh>            used.
13:53:19 <Nutssh> (And welcome to the world of C standards. :)
13:53:45 <warpzero> Please shot me.
13:54:16 <Nutssh> I give you a dvorak keyboard and a scheme shell, and no way to change. :)
13:54:48 <warpzero> The Dvorak keyboard I am cool with.
13:54:57 <warpzero> I have no idea how to use scheme.
13:55:35 <Nutssh> Anyways, I have to go for a bit. And I advise just using 'long long' and not worrying about the non-isoisms too much. 
13:55:55 <warpzero> Worry about portability later lol.
13:55:58 --- quit: Nutssh ("Client exiting")
13:59:50 <mmanning> well by inlining some of the definitions it now runs in 14 minutes :)
14:00:06 <warpzero> is or g?
14:00:25 <mmanning> isforth
14:00:43 <warpzero> well make your function call overhead less then
14:01:07 <mmanning> cant
14:01:11 <warpzero> y not
14:01:18 <mmanning> how would i :P
14:01:35 <mmanning> you look at source for isforth and tell me how to without modifying the internal structure
14:01:41 <mmanning> which i dont want modified hehe
14:01:44 <warpzero> i dont know its YOUR forth
14:01:51 <mmanning> lol
14:03:50 <mmanning> lol the definition for +3 is almost 8k in size lol
14:04:11 <warpzero> what does +3 do?
14:04:22 <mmanning> its the +3 in kc's benchmark
14:04:31 <warpzero> oh right
14:05:05 <mmanning> +3 has +2 inlined - 2+ has +1 inlined and +1 has v+ inlined
14:10:15 <warpzero> screen scares the shit out of me
14:13:23 <warpzero>  you could write an auto-inlining thing for your isforth?
14:15:14 <mmanning> no. not auto
14:15:29 <warpzero> or a hey inline this biaaatch word?
14:15:56 <mmanning> lol no - im not making the compiler smart enough to check your soruces to see what could/should be inlined
14:16:02 <mmanning> THAT is up to you :P
14:20:43 <warpzero> well i mean like
14:20:56 <warpzero> you could have an "inline" word? just like C?
14:21:38 <mmanning> i have m: and ;m to start and end a macro colon definition. this definition is inlined anywhere its used
14:21:47 <mmanning> so in a way... yes
14:23:47 <warpzero> oh well
14:23:50 <warpzero> there you go
14:24:00 <warpzero> what happens if you make those all m:?
14:24:54 <mmanning> i allow up to 8k of macro definitions - that inclueds both code and headers for macros - you can increase that if you like but +3 above almost fills 8k heh
14:25:14 <warpzero> So just change that limit real quick.
14:25:28 <mmanning> <-- at work "hardly working" :)
14:26:48 <warpzero> I'm sure that just like a hardcoded number
14:26:59 <mmanning> it is
14:27:03 <warpzero> so change it
14:27:06 <warpzero> and run it all m:
14:27:13 <mmanning> but it would mean edit, assemble, extend.... hehe
14:27:25 <mmanning> ill do it when i get home - i leave in half an hour or so
14:27:34 <mmanning> but i doubt it will be MUCH faster
14:27:37 <warpzero> ok
14:28:01 <mmanning> ill give 64k of macro hehe
14:28:44 <warpzero> so isforth is written in asm?
14:28:50 <mmanning> the kernel is
14:29:01 <warpzero> and the rest?
14:29:02 <mmanning> using nasm macros to create word headers etc
14:29:23 <mmanning> the extensions are written in isforth :)
14:29:57 <warpzero> whats the difference between nasm and gas?
14:30:46 <mmanning> gas is evil
14:31:26 <warpzero> how so
14:31:27 <Robert> Haha, amen.
14:31:34 <Robert> It's not even made for humans
14:31:45 <Robert> Just as a backend to gcc... so its syntax is evil
14:31:56 <warpzero> I've only ever done asm in __asm__ macros.
14:31:58 <Robert> And the error checking is said to be buggy
14:32:02 <warpzero> So I think thats gas.
14:33:58 <warpzero> Will nasm work as a backend for gcc?
14:34:03 <Robert> Nah.
14:34:10 <warpzero> I mean can you gcc -whatever it is that outputs asm and then nasm it?
14:34:11 <Robert> But you can link it with gcc programs.
14:34:21 <Robert> No.
14:34:31 <Robert> But yuriz in #nasm modified LCC to output NASM code.
14:34:37 <warpzero> why the hell not
14:34:42 <warpzero> i mean its all just assembly
14:34:46 <Robert> No.
14:34:50 <Robert> There is no standard.
14:35:00 <Robert> So gas and NASM syntax is pretty different.
14:35:07 <Robert> For example, everything is backwards.
14:35:20 <warpzero> oh gr8
14:35:26 <Robert> Destination operands are LAST in gas, but FIRST in NASM.
14:35:28 <Robert> No big deal
14:35:34 <Robert> Just use NASM and you'll be fine :)
14:36:11 <warpzero> Does nasm work for PPC?
14:36:26 <Robert> No
14:36:31 <warpzero> Well then wtf.
14:36:33 <Robert> It's an x86 assembler.
14:36:41 <warpzero> ITS USELESS TO ME THEN
14:36:42 <Robert> You'd have to rewrite the asm code anyway.
14:36:49 <Robert> Hehe :)
14:36:52 <warpzero> Yeah i know.
14:37:01 <Robert> Why didn't you tell me you're not using x86? ;)
14:37:11 <warpzero> I am just not all of the time.
14:37:29 <warpzero> Right now, I am on x86 but I also have PPC computers.
14:37:50 <mmanning> warp x86 Linux box ?
14:37:55 <mmanning> install isforth :P
14:38:13 <warpzero> not with your 8k macro BS!
14:38:30 <warpzero> mmanning: I don't really know forth :(*
14:38:34 <mmanning> 8k is plenty
14:38:44 <mmanning> grab isforth and learn forth :)
14:39:33 <warpzero> im gunna grab your package here if you dont watch it
14:39:36 <warpzero> where do i get isforth
14:39:46 <mmanning> isforth.clss.net
14:40:09 <warpzero> 8051?
14:40:40 <warpzero> mmanning: What linux do you use?
14:40:43 <mmanning> :)
14:40:48 <mmanning> gentoo now
14:40:57 <mmanning> i also have an unpublished 8051 assembler
14:41:10 <warpzero> oh do you want me to stick isforth in der portage tree
14:41:33 <mmanning> not yet, there are issues with where it should install too that i have to figure out
14:41:37 <mmanning> are you a gentoo developer ?
14:41:45 <warpzero> whois me
14:42:13 <mmanning> lol 
14:42:34 <mmanning> when i get home maybe we can discuss how/where isforth would install
14:42:50 <Robert> /bin/sh :P
14:42:52 <mmanning> i WANT it in portage but there are issues to resolve first
14:42:55 <mmanning> no
14:42:57 <mmanning> lol
14:43:07 <mmanning> probably /opt/isforth
14:43:15 <warpzero> thats coolies
14:43:19 * Robert doesn't even use /opt :)
14:43:23 <mmanning> and local copies in ~/bin
14:43:34 <warpzero> thats no go
14:43:35 <mmanning> the source would need to be in /usr/src/isforth or something
14:43:48 <mmanning> whats no go ?
14:44:10 <warpzero> there is no installing to ~
14:44:14 * mmanning will write a GO game in isforth
14:44:23 <warpzero> are you serious?
14:44:41 <mmanning> nonono hehe - the user could make a totally new version of the isforth kernel for his own projects
14:44:42 <warpzero> /join #go
14:45:01 <mmanning> he CANT overwrite the one in /opt/isforth however
14:45:11 <warpzero> oh okay
14:45:12 <mmanning> will join #go at home
14:45:15 <warpzero> but if we do /opt
14:45:26 <warpzero> then it will more likely be /opt/isforth/src
14:45:56 <mmanning> no /opt/isforth/bin and /usr/src and maybe ~/isforth/bin
14:46:03 <mmanning> i cant decide - its a complex issue
14:46:13 <warpzero> well i hate to inform you this
14:46:18 <warpzero> but its more my decision
14:46:46 <warpzero> i will try and follow what you want but i have rules
14:46:47 <warpzero> :)
14:46:51 <mmanning> lol i know - but you have to have some background on forth before you make that decision or it will be the "correct linux" decision but the "incorrect forth"
14:47:50 <mmanning> how about the binaries in /opt/isforth and the sources in /usr/lib ?
14:48:05 <warpzero> that doesn't make any sense
14:48:18 <mmanning> it does when you realise that the extensions ARE libs
14:48:28 <mmanning> they are just not binary form
14:48:39 <warpzero> how about the binaries in /usr/bin
14:48:45 <warpzero> and the soruces in /usr/src
14:49:10 <mmanning> well ok - but theres two different source trees for isforth - theres the kernel sources and theres the extensions
14:49:25 <warpzero> how about just sticking it all in /opt/isforth
14:49:42 <mmanning> and the extensions would be broken down into assembler, debugger, editor, blah. foo, this, that, the-other....
14:49:57 <mmanning> well. heres the issue
14:50:30 <mmanning> there needs to be a global version of the extended isforth but there doesnt need to be a globally visible version of the kernel itself
14:50:41 <warpzero> what
14:50:42 <mmanning> who extends the kenel - and where is the result placed
14:51:11 <mmanning> if root does the extend should the isforth executable go in ~/isforth or in /where/ever/we/install/to
14:51:27 <mmanning> theres just too many variables heh
14:51:46 <mmanning> i might have 10 different projects. each one uses a slightly different version of teh kernel
14:51:59 <warpzero> then how about you make a website
14:52:10 <warpzero> and if someone wants it they can download it from ther
14:52:12 <mmanning> i have a web site - its just empty(ish) lol
14:52:25 <mmanning> isforth.clss.net
14:52:42 <mmanning> lets say im making a commercial web browser in isforth
14:52:48 <mmanning> i create a custom version of kernel.com
14:53:13 <warpzero> okay
14:53:15 <mmanning> i use THIS to compile my web browser and do a turnkey. the resultant executable is released
14:53:30 <mmanning> but my other projects use different versions of kernel.com etc etc
14:54:03 <mmanning> i must be able to build my applicatioins on top of my own kernel - and NO - isforth projects will NEVER use gnu make
14:54:10 <mmanning> fuck make - its a fucking abomination
14:54:17 <warpzero> tell me about it
14:54:28 <warpzero> im going to write a perl script or something to make af
14:54:46 <mmanning> the way i see it working is i have a file similar to isforth.f (see sources) which lists all sources for my application
14:55:29 <mmanning> i would have the custom kernel fload that file - which would compile my application
14:55:30 <mmanning> OR
14:55:39 <mmanning> i could have my sources released AS SOURCES
14:56:09 <mmanning> to be installed into /usr/lib/application-dir
14:56:49 <mmanning> then i would have a +x forth source in /usr/bin which when executed would run /opt/isforth/bin/isforth -fload /usr/lib/application/soruce.f
14:57:13 <warpzero> #!isforth -fload
14:57:15 <mmanning> i.e. when you run the application it launches isforth and compiles itself onto it
14:57:16 <mmanning> yes
14:57:21 <mmanning> shebang
14:57:33 --- join: fridge (~fridge@dsl-203-33-164-15.NSW.netspace.net.au) joined #forth
14:57:41 <mmanning> but in a shebang you use #! /path/to/isforth -sfload 
14:57:50 <mmanning> -sfload as opposed to -fload
14:57:56 <warpzero> orite
14:58:34 <mmanning> i dont think it would take long to put isforth in portage - would you need permission to actually add it to the main tree ?
14:58:41 <mmanning> or could you simply DO SO
14:59:01 <warpzero> no i can just add shit
14:59:06 <mmanning> cool hehe
14:59:12 <warpzero> i can get in trouble for it
14:59:25 <mmanning> how in trouble ?
14:59:27 <mmanning> can or cant ?
14:59:45 <warpzero> well if i put something in that breaks gentoo
14:59:51 <warpzero> i will get in trouble
14:59:54 <mmanning> lol
15:00:02 <warpzero> or if i do something legaly wrong
15:00:17 <mmanning> well considering theres NOTHING in gentoo that isforth uses and theres nothing in gentoo that uses isforth....
15:00:17 <warpzero> but other than that i just have at it
15:00:20 <mmanning> oh
15:00:30 <mmanning> you MIGHT want to examine my license
15:00:44 <warpzero> i have r/w to the portage cvs tree
15:00:45 <Robert> Which is now called "license" :P
15:00:48 <mmanning> its a MODIFIED lgpl
15:01:01 <warpzero> well penis
15:01:03 <mmanning> i know. i cant spell for shit :P
15:01:07 <warpzero> I am going to have to look up how to do that.
15:01:26 <mmanning> warp - the modification wouldnt make it unaceptable to gentoo im sure
15:01:27 <Robert> mmanning: I have to crack down on SOMETHING, and I can't find anything in Isforth itself to complain about ;)
15:01:36 <mmanning> lol
15:01:55 <mmanning> im goin home...
15:01:59 <Robert> OK, see you
15:01:59 <warpzero> mmanning: Well any licenense can be put in -- i mean we have pay per stuff like vmware
15:03:38 <warpzero> hey Roberto
15:03:50 <warpzero> You should examine my bytecode specification for fuckups.
15:04:09 <mmanning> warp be here when i get home so we can chat about a "real" release of isforth lol
15:04:22 <warpzero> yeah okay if i dont fall asleep first
15:04:25 <mmanning> see me as I440r when i log in
15:04:31 <mmanning> where are you located ?
15:04:33 <warpzero> YEAH I KNOW THAT
15:04:41 <warpzero> Montana, US
15:04:45 <mmanning> ok lol
15:04:48 <mmanning> stay awake :P
15:04:50 <warpzero> GMT-9
15:05:39 <Robert> So it's 1400 there?
15:05:52 <warpzero> 1600
15:05:58 <Robert> Er...
15:06:01 <chandler> that's GMT-7
15:06:03 <Robert> It's 2300 GMT
15:06:08 <Robert> Oh.. :)
15:06:22 <chandler> GMT-9 is Alaska right now I think
15:06:27 <Robert> Yeah...
15:06:28 <warpzero> wait
15:06:30 <chandler> silly
15:06:31 <warpzero> maybe im wrong
15:06:35 <chandler> you are wrong
15:06:38 <warpzero> what is MST?
15:06:41 <Robert> :)
15:06:44 <chandler> Mountain Standard Time
15:06:45 <warpzero> edit
15:06:48 <warpzero> what is MDT
15:06:55 <chandler> mountain daylight time
15:06:58 <warpzero> yeah i know
15:07:01 <warpzero> what gmt- is it
15:07:02 <chandler> you should be on MST right now
15:07:11 <chandler> MDT is GMT-8 I think
15:07:18 <chandler> er, GMT-6
15:07:19 <chandler> wrong direction
15:07:53 <chandler> MST is GMT-7, MDT is GMT-6, CST is GMT-6, CDT is GMT-5, EST is GMT-5, EDT is GMT-4
15:07:59 <chandler> I'm in EST all year round
15:08:02 <warpzero> -7
15:08:03 <warpzero> okay
15:08:39 <warpzero> 2300 1600 - . 700  ok
15:08:53 <warpzero> eya
15:09:09 <Robert> Heh.
15:09:25 <warpzero> I told you I use gforth as a calculator.
15:09:59 <chandler> heh, I use sbcl as a calculator
15:10:01 <Robert> I use my head for stuff like that though
15:10:41 <warpzero> what is sbcl?
15:13:05 <chandler> Steel Bank Common Lisp
15:14:10 <warpzero> (Lisp(is(a(pain(in(the(ass)))))))
15:15:15 <warpzero> Robert: plz?
15:15:23 <chandler> oh, bah
15:15:25 <Robert> What?
15:15:29 <chandler> that's gotta be the weakest argument I've heard
15:15:42 <warpzero> Robert: [16:03:49] <warpzero> You should examine my bytecode specification for fuckups.
15:15:57 <warpzero> chandler: well I haven't actually used it. I just have things against that many parents
15:15:58 <chandler> like "forth sucks backwards syntax of because"
15:16:04 <chandler> heh
15:16:06 <Robert> warpzero: Oh... I'm tired now, going to bed in a few minutes.
15:16:07 <chandler> the parens are a non-issue
15:16:14 <warpzero> they are tho
15:16:24 <warpzero> i thought it was a RPN langauge
15:16:25 <chandler> bah. write me forth code to sum 10 constant numbers
15:16:38 <warpzero> then i find out its just alot of parens
15:16:39 <chandler> lisp? lisp is prefix
15:16:49 <chandler> damn you are being obtuse about this
15:16:51 <warpzero> THEN WHY DOES IT HAVE SO MANY PARENS
15:17:13 <chandler> BECAUSE IN FORTH TO SUM 10 CONSTANTS YOU WRITE 1 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 +
15:17:23 <chandler> AND IN LISP IT'S (+ 1 2 3 4 5 6 7 8 9 10)
15:17:27 <warpzero> its not an infix language for the love of god wtf
15:17:32 <Robert> Nobody sums 10 constants anyway
15:17:42 <chandler> point is, in lisp you can do variable argument lists
15:18:03 <chandler> anyway, the /reason/ for the parens is because of the structure of the code as data, not text
15:19:36 <warpzero> i do it in forth like 1 2 3 4 5 6 7 8 9 10 + + + + + + + + + +
15:20:25 <warpzero> what do you mean the code as data
15:21:20 <chandler> brb, on phone (sorry)
15:22:53 <fridge> the parens are an issue
15:23:38 <warpzero> fridge(do(you(really(think(so(?))))))
15:24:54 <Robert> Well, that's why you don't write lisp one-liners...
15:26:57 <chandler> for god's sakes you don't put parens around everything
15:27:05 <warpzero> you do
15:27:07 <warpzero> i have seen it
15:27:11 <warpzero> WITH MY OWN EYES
15:27:12 <chandler> heh, no, not every word
15:27:17 <chandler> every function call
15:27:18 <fridge> it is still an issue
15:27:25 <chandler> fridge: in what context? for what reason?
15:27:30 <fridge> it looks shit
15:27:32 <warpzero> every word is a function call
15:27:36 * fridge rests his case
15:27:53 <chandler> heh. I won't argue with that argument. it's infallable!
15:28:06 <chandler> warpzero: what are you talking about? lisp doesn't have "words"
15:28:08 <chandler> lisp is not forth
15:28:14 <warpzero> [16:27:11] <chandler> heh, no, not every word
15:28:22 <chandler> uh
15:28:22 <warpzero> you say word i say word
15:28:28 <chandler> you were writing in englihs
15:28:32 <chandler> that's what I was referring to
15:28:46 <warpzero> oh
15:28:49 <warpzero> its still an issue
15:28:52 <chandler> why?
15:29:05 <chandler> first of all, there is a big benefit
15:29:08 <chandler> lisp has uniform syntax
15:29:22 <chandler> rather than dealing with special groups of punctuation with meaning you deal with lists of symbols
15:29:36 <chandler> this means writing code-writing code is easy
15:30:02 <chandler> in fact what you're looking at is just the textual representation of lisp
15:30:15 <chandler> the lisp language is defined not on text, but on lists of symbols aka data
15:30:38 <chandler> and the reader and printer just translate from and to printed representation
15:30:38 <warpzero> so is af
15:30:42 <chandler> af?
15:30:50 <warpzero> mine language
15:30:58 <warpzero> http://wza.us/af/
15:31:21 <chandler> uh, show me some code in it
15:31:49 <warpzero> < $ af has % other kinds [ of brackets ] ? too >
15:32:08 <warpzero> wow thats wrong
15:32:13 <warpzero> < $ af has % other kinds [ of brackets ? too ] >
15:32:22 <chandler> < do [ they ] have < special > random [ meanings ] > ?
15:32:38 --- join: I440r (~mark4@12-160.lctv-a5.cablelynx.com) joined #forth
15:33:09 <warpzero> yeah
15:33:14 <warpzero> thats wrong btw
15:35:07 <chandler> well (a) you can define reader macros in lisp to do all sorts of crappy syntax if you want, and (b) that's what lisp really the opposite of
15:35:07 <warpzero> hmm i wonder on adding 10 constants
15:35:34 <chandler> and I still don't see what the issue is with the parens; I don't think you've explained
15:35:41 <chandler> you're expecting me to accept "parens are an issue"
15:36:46 <warpzero> holy shit
15:36:54 <warpzero> adding 10 numbers in af is a bitch and a half
15:37:09 <chandler> really?
15:37:12 <warpzero> yea
15:37:52 <warpzero> im not sure if its possible
15:38:16 <chandler> ?
15:38:54 <warpzero> er well
15:39:43 <warpzero> yeaaaa
15:40:10 <chandler> ...
15:40:42 <warpzero> not possible
15:40:58 <chandler> uh. you can't add ten numbers at all?
15:41:51 <warpzero> yea
15:41:59 <warpzero> no binary operators
15:42:23 <chandler> doh
15:42:28 <warpzero> wait
15:42:35 <warpzero> im just not thinking about this right
15:43:40 --- quit: skylan (Read error: 54 (Connection reset by peer))
15:43:47 <chandler> sounds like your language isn't exactly complete :-)
15:48:14 <warpzero> right
15:48:19 <warpzero> okay time to implement binary operators
15:50:28 <chandler> anyway consider coming up with a better objection to lisp than the parens... it sounds very illiterate
15:50:45 <warpzero> its used by a bunch of ai schmucks?
15:51:18 <I440r> the parens is enough of a reason not to like lisp
15:51:24 <I440r> ((((( )(0(()())()())((((())))
15:51:26 <I440r> worse than brainfuck lol
15:51:38 <warpzero> what does that do
15:51:42 <chandler> it's an idiotic objection... if you're thinking about your code's structure the parens are natural
15:51:53 <chandler> uh, I440r 's mass of parens does nothing
15:51:56 <chandler> it's all structure
15:51:57 <chandler> no data
15:52:02 <fridge> uh, no one cares
15:53:21 <warpzero> chandler: uh i can't make my language have binary operators
15:53:53 <chandler> why not?
15:54:04 <warpzero> because it doesn't work that way?
15:54:12 <chandler> then how do you add two numbers?
15:55:18 <fridge> I've only used elisp, theres nothing wrong with it really, I just find something aesthetically wrong with having so many parens
15:55:36 <chandler> gagh, elisp is not a good lisp
15:55:55 <chandler> but if you're hung up on syntax I guess it's the same as any other lisp
15:56:54 <I440r> any language with syntax (or with no user defineable syntax) is nice
15:57:04 <I440r> i find the braces in c to be fuggly
15:57:20 <warpzero> ( <> <> *int < $ *int a $ *int b [ ^ ^ [ *a ^ ] [ *b ^ ] [ 1 *a ] [ 2 *b ] > add \ )
15:57:25 <warpzero> that adds 1 and 2
15:57:49 <chandler> ugh, I /hate/ syntax
15:58:34 <warpzero> how cool is that
15:58:46 <warpzero> thats the biggest version of add 1 and 2 i have ever seen in my life
15:59:04 <chandler> heh, the lambda calculus version is bigger (because it has no numbers)
15:59:14 <warpzero> this almost has no number
15:59:15 <warpzero> s
15:59:18 <warpzero> thats the problem
16:00:21 <warpzero> er
16:00:23 <warpzero> thats wrong
16:00:31 <warpzero> there should be a * in front of add
16:03:21 <warpzero> ( <> <> *int < $ 1 a $ 2 b [ ^ ^ [ *a ^ ] [ *b ^ ] ] > *add \ )
16:03:25 <warpzero> thats shorter
16:03:43 <warpzero> and correct
16:06:52 <warpzero> ( <> <> *int < [ ^ ^ [ 1 ^ ] [ 2 ^ ] ] > *add \ )
16:06:55 <warpzero> shorter
16:07:39 <warpzero> (  < [ ^ ^ [ 1 ^ ] [ 2 ^ ] ] > *add \ )
16:08:01 <warpzero> thats as short as it gets
16:16:15 <warpzero> I just killed the channel, including I440r
16:16:57 * kc5tja is back (gone 03:08:14)
16:17:49 <I440r> ?
16:17:59 * I440r checks
16:18:04 <I440r> erm nopte
16:18:10 <I440r> im still alive
16:19:18 <warpzero> kc5tja: check out the above awsome syntax for adding 2 numbers -_-;;
16:19:26 <kc5tja> I can see it.
16:20:03 <I440r> kc i ran the test again with v+ +1 +2 and +3 inlined and it did it in 14 minutes
16:20:13 <I440r> but the definition for +3 was about 8k in size heheh
16:20:18 <kc5tja> I440r: 14 minutes on a 1.8GHz box?
16:20:22 <I440r> yes
16:20:24 <kc5tja> I440r: :)
16:20:39 <I440r> so MOST of my speed issues are related to nest/unnest
16:20:42 <kc5tja> I440r: That's about as fast as my (non-inlined) FS/Forth performance on my box.
16:20:50 <I440r> yup
16:20:57 <I440r> so i still win our bet :P
16:20:58 <kc5tja> Yeah, I figured as such.  LIterally, that is THE issue with direct threading.
16:21:01 <kc5tja> That's why I didn't go with it.
16:21:08 <kc5tja> I440r: How so?
16:21:14 <kc5tja> I haven't inlined FS/Forth yet.  >:D
16:22:10 <I440r> the bet was that isforth is slower than yours :P
16:22:10 <I440r> i win :P
16:22:28 <kc5tja> Ahh
16:22:37 <kc5tja> I read your bet as being the reverse for some reason.
16:22:40 <I440r> i doubt my inlining words will work in fs/forth
16:22:45 <I440r> lol
16:23:00 <kc5tja> I440r: Since FS/Forth exists purely in GForth at the moment, I can inline very easily.
16:24:01 <I440r> lol
16:25:34 <kc5tja> But I won't.
16:26:08 <kc5tja> OK, now I'm off to work.
16:26:11 <kc5tja> Back in about four hours.
16:26:13 <kc5tja> (half-day today)
16:26:15 * kc5tja is away: work
16:38:56 --- join: matt__ (1000@adsl-66-124-255-151.dsl.snfc21.pacbell.net) joined #forth
16:38:59 --- nick: matt__ -> Sonarman
16:51:12 --- quit: qFox ("if at first you dont succeed, quit again")
17:14:40 --- join: Nutssh (~Foo@gh-1029.gh.rice.edu) joined #forth
17:56:48 * warpzero is away: Can you feel it? Can you feel the rythm?
18:19:55 --- quit: Nutssh ("Client exiting")
19:42:35 --- join: skylan (~sjh@nwc57-123.nwconx.net) joined #forth
19:47:44 --- join: Nutssh (~Foo@gh-1177.gh.rice.edu) joined #forth
21:28:56 --- quit: I440r (Excess Flood)
21:37:50 --- join: I440r (~mark4@12-160.lctv-a5.cablelynx.com) joined #forth
21:38:09 * kc5tja is back (gone 05:11:53)
21:39:20 <I440r> wb
21:41:25 <Nutssh> Hi.
21:41:51 <kc5tja> Howdy
22:04:05 <I440r> kc5 see pm ?
22:30:49 --- quit: Sonarman ("leaving")
23:59:59 --- log: ended forth/04.01.21