00:00:00 --- log: started forth/04.01.26
00:32:03 --- join: schihei (~schihei@pD9E5C929.dip.t-dialin.net) joined #forth
01:00:20 --- quit: kc5tja ("THX QSO ES 73 DE KC5TJA/6 CL ES QRT AR SK")
01:03:32 --- join: kc5tja (~kc5tja@66-91-231-74.san.rr.com) joined #forth
01:03:42 --- mode: ChanServ set +o kc5tja
01:03:46 <Robert> Hey kc5tja 
01:04:03 <Robert> http://forth.bespin.org/Members/kc5tja <-- is that the main page about you?
01:04:04 <kc5tja> Howdy.
01:04:08 <kc5tja> Just testing stuff out.
01:04:12 <Robert> Or do you have another?
01:05:12 <kc5tja> While the information presented there is accurate, I no longer have any "official" pages of my own.
01:05:37 <kc5tja>  I expect to get my own personal pages again shortly, though.
01:05:47 <Robert> Okay.
01:05:55 <kc5tja> I'm going to repurpose a section of my company's site to my personal stuff.
01:05:57 <kc5tja> Why do you ask?
01:06:25 <kc5tja> Anyway, it's 1AM here.
01:06:27 <Robert> I440r said he wanted a link to your page, and he didn't reply when I asked if you had any :)
01:06:27 <kc5tja> I have to get to bed.
01:06:31 <Robert> Good night
01:06:46 --- quit: kc5tja (Client Quit)
02:34:43 --- quit: Nutssh ("Client exiting")
03:12:54 --- join: qFox (C00K13S@cp12172-a.roose1.nb.home.nl) joined #forth
05:39:46 --- quit: proteus-away (Connection timed out)
05:54:37 * warpzero is back (gone 06:48:23)
06:07:41 --- quit: qFox (Read error: 54 (Connection reset by peer))
06:09:04 --- join: qFox (C00K13S@cp12172-a.roose1.nb.home.nl) joined #forth
06:25:24 --- quit: I440r ("Leaving")
06:37:21 * warpzero is away: Educamation.
06:42:34 --- quit: chandler ("Reconnecting")
06:42:38 --- join: chandler (~chandler@d-84-77.dhcp-149-159.indiana.edu) joined #forth
07:41:40 --- join: Herkamire (~jason@h000094d30ba2.ne.client2.attbi.com) joined #forth
08:14:44 --- join: kc5tja (~kc5tja@66-91-231-74.san.rr.com) joined #forth
08:14:53 --- mode: ChanServ set +o kc5tja
08:33:45 <Robert> Hello
08:33:53 <kc5tja> Greetings.
08:36:21 <Herkamire> yo
08:36:46 * kc5tja made some progress on FTS/Forth yesterday.
08:36:57 <Herkamire> yay
08:36:59 <kc5tja> Got a number of primitives implemented (though they're rather dumb at the moment; no peephole optimization)
08:37:08 <Herkamire> cool
08:37:14 <kc5tja> I've decided to skip the optimization step until a subsequent version of FTS/Forth.
08:39:59 <Herkamire> kc5tja: speaking of optimization, I played with your memory bandwith benchmarks, and herkforth was about 7X slower than optomized gforth
08:40:46 <kc5tja> Do you do any kind of optimization at all?
08:40:55 <kc5tja> Or, more accurately, does herkforth?
08:40:56 <Herkamire> later, but 7x is with none
08:41:03 * kc5tja nods
08:41:20 <kc5tja> Mine varies between 3x slower than GForth to 2x faster, depending on how you code it.
08:41:56 <Herkamire> did I say gforth?? oops. I meant gcc
08:42:21 <Herkamire> 7x slower than gcc -O2 -funrol-loops
08:42:42 <kc5tja> Ahh, in that case, you're better than me.
08:43:00 <kc5tja> I'm currently about 10x slower than GCC with -march=athlon -O3 -fomit-frame-pointer.
08:43:27 <Herkamire> yeah I have -arch=7400
08:43:40 <kc5tja> Damn RISC users... :D
08:43:49 <Herkamire> :)
08:44:00 <Herkamire> optomization has got to be simpler on my box.
08:44:19 * kc5tja nods
08:44:26 <Herkamire> I changed the inner loop to fetch and store to/from a register instead of the stack, and unrolled it a bit, and it was only 5% slower than gcc
08:44:57 <kc5tja> I didn't unroll in mine, because I lack the facilities to do it beyond 3 or 4 times.
08:45:18 <kc5tja> But I did switch to using an A register, and that improved performance by a small amount (21 minutes run-time instead of 33).
08:45:37 <Herkamire> 7x is with my A register
08:45:47 <kc5tja> Oh.
08:45:58 <Herkamire> I use the A register all the time.
08:46:09 <kc5tja> *Epiphany* I guess 7x is about right for me too.  21 minutes / 3 minutes = 7.  :)
08:47:14 <Herkamire> oh, I don't know if it makes much differenc, but I reduced some of the numbers in the benchmark so I din't have to wait so long.
08:47:38 <kc5tja> I used large numbers to make the timer resolution irrelavent.
08:47:43 <Herkamire> my times ranged from 40 secconds to 289
08:47:47 <kc5tja> As long as your timers are good enough, you can use shorter intervals.
08:49:14 <Herkamire> If I can get herkforth to optomize out some stack usage, It could be very fast
08:49:42 <kc5tja> That's where the peephole optimization comes into play.
08:49:49 <kc5tja> I hope that will help.
08:50:49 <kc5tja> It may not help nearly as much as I'd like though.
08:51:43 <Herkamire> gcc unrolled was 40s. herkforth unrolled, with my asm was 42s
08:52:07 <kc5tja> Oh, so you used assembly language too, eh?  :)
08:52:10 <kc5tja> Cheater.  :)
08:52:36 <Herkamire> gcc -O2 was 57s. It looks like I forgot to write down herkforth/asm without unrolling, but I imagine it's about 60-70s
08:53:28 <Herkamire> not for 7X. 7X is just coding it normally in herkforth
08:53:43 <kc5tja> I think that's obvious from what you said above.
08:53:49 <kc5tja> 42s versus 40s is not 7x.  :)
08:53:55 <Herkamire> hehe :)
08:54:27 <Herkamire> the optimization to go from 289s to 60-70s is to simply use a register instead of the stack.
08:54:37 <Herkamire> this optomization dosn't seem to hard.
08:54:54 <kc5tja> My code currently uses the "A" register, and it still takes 21 seconds.
08:55:02 --- join: proteusguy (proteusguy@137.sub-166-153-167.myvzw.com) joined #forth
08:55:14 <kc5tja> I would have to recode the entire V+ function in assembly language if I were to get comparable performance, I think.
08:55:41 <kc5tja> But remember, too, I don't yet have peephole optimization either.
08:55:57 <Herkamire> just look back at the last two instructions, if it's DUP followed by any instruction with destination of the TOS cache register, I can remove the DUP, change the destination register to say r3 and change the source register in the instruction I'm compiling to r3.
08:55:58 <kc5tja> So things like 1 @a + !a+ still do a lot of stack juggling.
08:56:29 <kc5tja> See, I can't do that.  :)
08:56:38 <Herkamire> yeah.
08:57:09 <kc5tja> Actually, I currently do this: @a 1+ !a+, where 1+ emits the code for INC EAX (a single instruction to increment EAX by 1).
08:57:29 <kc5tja> Still, @A emits code to DUP, and !A+ emits code to DROP, so there is always that stack overhead involved.
08:57:39 <Herkamire> same here
08:58:33 <kc5tja> With my register-based MachineForth concept, it'd just allocate and free registers instead of emitting actual code, so I would expect that version to just utterly scream.  :)
08:58:40 <kc5tja> But, I'll play with that at a later time.
08:59:49 <kc5tja> Although, to be perfectly fair, I don't think such a MachineForth would have an A register, due to x86's limited set of registers.
08:59:58 <Herkamire> yeah, I've read about a system for stack optomization where as you compile you keep track of which registers have the top few stack items. and if you need to call an already compiled word, then you first put those values onto the stack normally (or in whatever form you standardize)
09:00:00 <kc5tja> EAX, ECX, EDX, EBX, EBP, ESI, and EDI would be all I have.
09:00:22 <kc5tja> Herkamire: Yeah, that's basically what my system would do.
09:00:27 <Herkamire> I like the A register :)
09:00:52 <kc5tja> Only the depth of the data stack is explicitly restricted to 7 registers.
09:01:19 <Herkamire> oh... you're talking about having the stack entirely in registers?
09:01:26 <kc5tja> Yes.
09:02:14 <Herkamire> too bad you don't have ppc.
09:02:22 <kc5tja> The emphasis here would be on simplicity of the compiler again.
09:02:34 <kc5tja> Then, I'm thinking beyond that, I'd try to make a dataflow-based optimizer.
09:02:53 <kc5tja> That's where we extend the concept to include the actual Forth code representation too.
09:04:20 <kc5tja> Interestingly enough, in the dataflow-optimized Forth environment, I'd store the "compiled" code in a token-threaded or indirect-threaded form.
09:04:39 <kc5tja> This representation would be stored in the data space.
09:05:01 <kc5tja> The code space is reserved explicitly for real compiled code, where the compiler generates code only when necessary.
09:06:01 <kc5tja> E.g., when you reference a word that has not been compiled yet, it'll perform global optimization on that word and all words it depends on (up to a practical limit of course), thus guaranteeing sufficient context with which to optimize register usage, stack usage, and whatnot.
09:06:06 <kc5tja> It'll be sweet when it's done
09:06:12 <kc5tja> (inspired by RAFTS prior art)
09:06:45 <Herkamire> I was thinking of doing something similar
09:06:51 <Herkamire> would be very cool
09:07:21 <Herkamire> I've decided not to do optomization yet though (asside from immediate words that compile one or two instructions)
09:07:44 <kc5tja> That's what I'm doing.  Concentrating on correct code first, then fast code later.
09:10:05 <Herkamire> it seems like really good optomization would be much easier with some sort of intermediate representation, like token-threaded
09:10:22 <kc5tja> Yes, that's why I would use it.
09:11:09 <kc5tja> Especially because I need to record things like how many times a word is referenced, how many cells it takes as parameters, how many cells it produces, whether or not it returns a variable number of results, etc.
09:11:20 <kc5tja> The use of tokens lets me record such meta-data easily.
09:12:27 <kc5tja> For example, if a word has already been compiled, there is no point in recompiling it again.  That'd just waste code space.
09:13:16 <kc5tja> Likewise, if a word is only used three or four times before being redefined for something else, then you might as well just inline all three or four instances.  :)
09:14:44 <Herkamire> I really want my system to have a builtin profiler that automagically optomises cod it fnds to be takink lots of time
09:15:38 <kc5tja> That's a little bit too complex for my liking, I think.  :)
09:16:27 <Herkamire> that's something I was thinking of doing long after it's in OS
09:18:34 <Herkamire> I'd have a timer interrupt that would go of frequently and keep a tally of what words were taking a lot of time
09:19:28 <Herkamire> there's things I don't like about it.
09:19:55 <Herkamire> most notably that I don't have any way with my current system to recompile a given definition
09:20:38 * kc5tja nods
09:21:33 * kc5tja was thinking of writing an OS-like environment in Forth too.
09:21:36 <kc5tja> Multitasking and all.
09:21:43 <kc5tja> It ought to be pretty easy to do.
09:22:11 <kc5tja> The only problem is when you run programs A, B, C, and D, and you want to terminate B, you have two options: either let the code just sit and rot there, or recompile C and D so that the memory is compacted.
09:22:28 <kc5tja> I think that program termination is so rare that it makes sense to take the latter approach.
09:22:50 <kc5tja> However, here again, it also requires that variables be kept in block storage, like ColorForth does.  This way, program state is preserved.
09:22:56 <kc5tja> (well, most of it at least.)
09:25:22 <Herkamire> I keep my variable values in the dictionary sturcture (dictionary = struct with CFA, string, flags)
09:26:08 <kc5tja> Not in the code or data spaces?
09:26:10 <Herkamire> that would be interesting. I hadn't seriously considered having the different programs use different registers so they would be very easy/quick to swap
09:26:20 <Herkamire> I will put it in the data space.
09:26:39 <Herkamire> I did't have a data space when I implemented them.
09:26:55 <Herkamire> my variables are persistant
09:27:16 <kc5tja> Yeah, that's what I mean.  In order for my system to work, variables, buffers, et. al. all need to be persistent.
09:27:20 <kc5tja> (somehow)
09:27:49 <Herkamire> I could easily put 4 processes in my 32 int registers (just on the first CPU) 
09:28:43 <Herkamire> or 6 I suppose
09:31:08 <Herkamire> I suppose I could do my forth with just 4 registers, and have 7 processes + a few extra registers for the task switcher
09:31:42 <kc5tja> Hehe
09:31:52 <kc5tja> Oh, but let's not forget the FPU registers either.  :)
09:32:17 <Herkamire> maaan
09:32:21 <kc5tja> Too bad you can't address memory with an FPU register.  :)
09:32:29 <Herkamire> hehe :)
09:32:42 <Herkamire> my cpu certainly does have a lot of registers
09:33:04 <Herkamire> 192 by my count
09:33:21 <kc5tja> Well, 64 definitely with just integer and floating point alone.
09:33:26 <kc5tja> Then you have another 32 for vector registers.
09:33:33 <kc5tja> Then you have all the system-specific registers.
09:33:40 * kc5tja wishes he had a fast PowerPC.  :(
09:33:47 <Herkamire> oh right, I wasn't counting the special purpose registers
09:33:51 * kc5tja wishes they were more affordable.
09:33:54 <Herkamire> I don't know how many of those there are
09:34:52 <kc5tja> It changes from CPU to CPU, really.
09:35:03 <kc5tja> The opcode space permits up to 1024 though.  :)
09:35:09 <Herkamire> :)
09:36:20 <kc5tja> Man, at this point, I would probably be happy with a 66MHz PowerPC 601 even.  :D
09:36:28 <Herkamire> I like that idea of running processes on different registers to make task switching fast. :)
09:36:50 <Herkamire> I haven't done anything CPU intensive with my forth yet
09:37:01 --- quit: schihei (Client Quit)
09:37:06 <kc5tja> Neither have I.
09:37:20 <kc5tja> Though that will probably come in time, especially as I start making my circuit simulator software.
09:37:22 <Herkamire> I will after I get it to boot and get nice graphics support
09:47:41 <Herkamire> I like to play with making cool graphics with recursive algorithms like fractals.
09:48:05 * kc5tja nods
09:48:23 <Herkamire> And I would eventually like to have a ray tracer
09:48:27 <kc5tja> Since you have the floating point registers on your system, are you going to make a floating point wordset too?
09:48:47 <Herkamire> I don't know
09:50:04 <kc5tja> Well, all I know is that my circuit simulator would definitely benefit from vector math acceleration.
09:50:23 * kc5tja is going to research the MMX and 3DNow! instructions to see if they can benefit me in my quest.  :)
09:50:31 <kc5tja> When I get to that stage of course.
09:50:45 <Herkamire> I'm certainly going to make it easier to do floating point than doing normal asm, but I'm not sure how it will end up.
09:52:47 <kc5tja> I was just wondering, because I can't imagine making a fractal generating program that uses all integer arithmetic.
09:53:21 <Herkamire> :) yeah
09:53:34 <Herkamire> fp certainly makes things easier
09:53:56 <kc5tja> The other thing about FTS/Forth is that the A register is the EDX register, which is also used by the multiplication and division instructions.
09:54:16 <Herkamire> :-/
09:54:17 <kc5tja> So, I don't need an explicit */ operator, because >r * r> / will achieve exactly the same thing.
09:54:37 <kc5tja> The A register holds the most significant 32-bits of the multiplication result, or the / input.
09:55:22 <kc5tja> It makes vector multiplication a bit wonky, I suppose, but overall, I think it's a feature that can be nicely exploited.  I think, at least.
09:55:41 <Herkamire> x86 is so funky
09:59:29 <Herkamire> I'm so glad I have hardware I like
10:03:13 <kc5tja> Interesting.  In ColorForth, * doesn't affect the A register, but / behaves exactly as I'd predict: it sets the A register to the remainder of the division.
10:04:18 <kc5tja> Maybe I should start calling it the M register: short for Memory or Multiplicand, depending on what you're about to do.  :)
10:04:35 * kc5tja will stick with A for now though.
10:05:59 <Herkamire> :)
10:23:44 <kc5tja> YAY!  Got FTS/Forth's read-evaluate loop implemented.
10:23:54 <kc5tja> Of course, evaluate just reprints, verbatim, what the user types in.  :)
10:24:05 <kc5tja> Just a glorified "Hello, what's your name" type program at the moment.
11:28:10 --- join: Nutssh (~Foo@gh-1177.gh.rice.edu) joined #forth
11:38:44 <Herkamire> yay :)
11:38:56 <mmanning> did you use query/expect ?
11:40:36 --- join: bjazz (jazz@pD9E59A8B.dip.t-dialin.net) joined #forth
11:41:25 <kc5tja> I used the ANSI semantics for ACCEPT.
11:41:30 <mmanning> ok
11:41:44 <kc5tja> It fit so perfectly with the system call interface that I have that it was a no-brainer.
11:41:53 <kc5tja> Plus, I prefer ACCEPT over the traditional words anyway.
11:42:02 <mmanning> :)
11:42:15 <kc5tja> ANSI did get *some* things right.
11:42:30 <mmanning> heh thats debateable ;)
11:42:36 <mmanning> but lets not :P
11:42:58 <Robert> Heh
11:43:29 <kc5tja> Well, ACCEPT is a fine example of one word they got right.
11:43:37 <kc5tja> As is KEY and EKEY, KEY? and EKEY?.
11:43:37 <Herkamire> hehe
11:43:46 <mmanning> err wtf is ekey ?
11:43:49 <Herkamire> ekey is an ansi word?
11:43:52 <kc5tja> Yes.
11:43:53 <mmanning> and how do you proniunce it
11:44:02 <kc5tja> EKEY is pronounced E-Key.
11:44:23 <kc5tja> It behaves like key, but fetches *events* (and returns a key to that event) instead of key presses.
11:44:28 <kc5tja> Useful for event-driven programming.
11:44:37 <mmanning> thank god they didnt go for eckey... like ickey but different heh
11:44:40 <mmanning> aha 
11:45:04 <Herkamire> cool
11:45:17 <Herkamire> ppforth uses ekey, I just asumeb he made it up
11:45:21 <kc5tja> Damn, I need to change my ELF code to include the data section needed for the Forth vocabulary vectors.
11:45:44 <mmanning> kc5 erm- bss ?
11:45:56 <kc5tja> mmanning: No.  Hell no.  Absolutely no.
11:46:01 <mmanning> good :)
11:46:04 <kc5tja> mmanning: Otherwise, what good is the cross-compiler?
11:46:05 <mmanning> just chekkin
11:46:24 <kc5tja> Nothing wrong with BSS sections, but I need to preserve the vocabulary state, obviously.
11:46:42 <mmanning> bss is a bitch
11:46:52 <kc5tja> But the ELF code I have is so nice and succinct.  :D  It produces, literally, *the* tiniest applications I've ever had a compiler for on this box.  :)
11:47:00 <mmanning> you cannot guarantee that the bss will be contiguous with your data section
11:47:13 <mmanning> you cannot have "code, bss, data, bss" 
11:47:17 <kc5tja> mmanning: Why in the world would you want it to?  It's a totally separate section.  Treat it as such.  :)
11:47:22 <mmanning> its all just too skrewie
11:47:36 <mmanning> kc5 so that my data can be extended
11:47:39 <kc5tja> No, you just don't understand how to properly use it.  :)
11:47:40 --- quit: bjazz ()
11:47:45 <kc5tja> mmanning: That's not what BSS is for. :)
11:47:49 <mmanning> i dont use it
11:47:54 <mmanning> i have ONE section effectivly
11:48:08 <kc5tja> mmanning: It's for allocating variables that don't need pre-allocation.  Typically used when you have, oh, say, 16MB worth of uninitialized data in your code.
11:48:18 <kc5tja> It'd suck to have a 16MB executable, only 4K of which is real code.
11:48:21 <mmanning> yes i  know heh
11:48:55 <mmanning> i know what bss is, i initially looked into using it as above but ran into problems ;)
11:48:59 <mmanning> and im glad i did
11:49:00 * kc5tja is glad that Forth uses its dictionary like a stack
11:49:10 <mmanning> because even if i had solved those problems the result would have been a DOG
11:49:18 <kc5tja> It lets me make a version of FTS/Forth with a 16MB dictionary space if I wanted to, and it'd still only emit the minimal-sized executable.
11:49:51 <mmanning> yes. there are no great big gaping holes in an isforth save either heh
11:50:25 <mmanning> on entry into forth all headers are butted up against code space and are relocated out to head space
11:50:42 <mmanning> on fsave the headers are relocated again to "here" and everything is saved as a single entity
11:51:08 * kc5tja nods
11:51:12 <mmanning> im thunkin of adopting some sort of compression mechanism so that isforth executables unpack themselves on boot
11:51:22 * kc5tja likes the idea of using separate sections though.  It seems more modular to me that way.
11:51:45 <mmanning> well head space and list space are internally seperate sections, but the elf file is ONE section :)
11:51:54 <kc5tja> That's what I mean.
11:51:59 <kc5tja> I prefer separate sections in the ELF file.
11:52:20 <mmanning> yes i originally wanted that too but decided this way was actually easier
11:52:21 <kc5tja> This way, I can quickly examine different section contents using commonly available tools.
11:52:21 --- join: ASau (~asau@158.250.48.196) joined #forth
11:52:35 <ASau> Dobryjj vecher!
11:52:40 <mmanning> actually, kernel.com does have list and header in different sections
11:52:43 <kc5tja> And, separate sections are a requirement if I want to start linking to libdl.so.
11:52:58 <mmanning> but when isforth does an fsave after extending the kernel its all in 1 section
11:54:40 --- part: Nutssh left #forth
11:56:35 <Herkamire> I like accept
11:57:34 * kc5tja now has two blocks, one for turnkey, and one for save.  :)
11:57:40 <kc5tja> turnkey, of course, creates just a raw executable.
11:57:49 <kc5tja> save also records the state of the vocabularies.
11:58:15 <cleverdra> kc5 - does your turnkey include only an entry-word's dependencies?
12:01:22 <cleverdra> I found several APLs for unix, also: an ancient ASCII apl11 written by Ken Thompson, a GPL'd openAPL based off apl11, adding APL's font and various modernizations, and something else that I haven't managed to compile.
12:01:57 <cleverdra> both of them assume that you have a clue as to their use and terminology, unfortunately.
12:02:18 <cleverdra> I think I'll just implement a K-lookalike.
12:04:46 --- join: golya (~golya@kempelen.iit.bme.hu) joined #forth
12:06:13 <golya> Hi! I'm a forth newbie. I'm stuck at the end of the tutorial, but I want to peek into forth's capabilities. Can sy say in what is forth good at? So where to use forth?
12:07:22 <kc5tja> cleverdra: There is no automated dependency management.  You must manually ensure the dictionary is as clean as you desire it to be before turnkeying.
12:07:32 <cleverdra> golya - this question would go easier for everyone if you talk about Forth's applicability to a specific domain that interests you.
12:07:39 <kc5tja> golya: I'm not sure how one can answer that question.  That's a little like asking what C is good for.
12:07:40 <cleverdra> kc5 - OK, good enough.
12:09:04 <golya> well. Now, what I know about forth, that it is a cross-platform, low-level language, and fast.
12:09:20 <kc5tja> cleverdra: Yeah, K is a nice language.  Very nice.  I'm just not too sure how it can work so well without the ability to apply vector arithmetic to different dimensions/axes in a vector/matrix operation.
12:09:34 <cleverdra> 'low-level' doesn't describe it very well. gcc -DPACKAGE_NAME=\"gc\" -DPACKAGE_TARNAME=\"gc\" -DPACKAGE_VERSION=\"6.2\" "-DPACKAGE_STRING=\"gc 6.2\"" -DPACKAGE_BUGREPORT=\"Hans.Boehm@hp.com\" -DGC_VERSION_MAJOR=6 -DGC_VERSION_MINOR=2 -DPACKAGE=\"gc\" -DVERSION=\"6.2\" -DSTDC_HEADERS=1 -DHAVE_SYS_TYPES_H=1 -DHAVE_SYS_STAT_H=1 -DHAVE_STDLIB_H=1 -DHAVE_STRING_H=1 -DHAVE_MEMORY_H=1 -DHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_UNISTD_H=1 -DHAVE_DLFCN_H=1 -DSILENT=1
12:09:41 <kc5tja> cleverdra: There must be something I'm missing.
12:09:41 <cleverdra> blech.
12:10:00 <cleverdra> kc5 - er, why do you suppose that it lacks that ability?
12:10:20 <kc5tja> cleverdra: Because it's not in the set of adverbs or verbs of K, as documented in the K Users Manual.
12:10:30 <kc5tja> I'm referring to J/APL's " adverb, BTW.
12:10:33 <golya> cleverdra: well, that can I do nice interactive programs in forth? Are there data structures? (I'm not a forther [yet])
12:10:40 <cleverdra> kc5 - I don't know anything about that adverb, sorry.
12:11:14 <cleverdra> golya - er, yes, Forth has any kind of data structure (with as nice a syntax) as you want -- hence my interrupted "'low level' doesn't describe it very well." remark.
12:11:14 <kc5tja> golya: There are no data structures built into the language.  You would need to code these yourself.  It's not usually hard to do, but it dependign on the Forth environment, it may impose a small performance hit if you do.
12:11:47 <kc5tja> golya: Due to Forth's low-level beginnings, it seems that the best data structures you can apply in Forth are the array and the stack.
12:11:59 <cleverdra> golya - Forths generally make 'nice interactive programs' more easy to develop than most other languages, simply because of KEY EKEY KEY? and such.
12:12:02 <Herkamire> some forths have data structures, but I think it's better to do them yourself. as kc5tja said, it's not hard
12:12:35 <kc5tja> golya: If you really wanted to, you can even include object oriented programming facilities as powerful as Smalltalk. 
12:12:46 <golya> Well, is there a place, where I can see some *easy* but useful forth code? 
12:12:54 <kc5tja> CLOS-like object orientation is a bit harder, but not unobtainable.
12:12:59 <cleverdra> golya - gforth comes with an 'oof' example of a particular OO extension and Lisp-like list extensions.
12:13:08 <cleverdra> golya - take a look in the gforth distribution, to start.
12:13:18 <kc5tja> cleverdra: What Forth tutorial are you looking at?
12:13:28 <cleverdra> kc5 - I don't look at any.
12:13:40 <kc5tja> Freaking autocompletion.
12:13:44 <golya> I have the gforth 0.6.2 manual.
12:14:01 <Herkamire> golya: you have gforth installed then?
12:14:03 <kc5tja> That is perhaps not the best tutorial I've seen.  :)  It's adequate I suppose, but . . .
12:14:03 <cleverdra> golya - note that gforth has two tutorials.
12:14:56 <kc5tja> golya: Also, there is usually an inverse relationship between easy and useful.  :)
12:15:01 <golya> I read that, which is not about the internals of forth
12:15:37 <golya> So? Any good place to look at? url?
12:15:44 <cleverdra> golya - gforth has two 'easy' (but not very useful -- unless you like what they do) games in the distribution: sokoban.fs and tt.fs
12:17:08 * cleverdra prepares to go back to school.
12:19:23 <ASau> Hm.
12:19:34 <ASau> Why not start from Gforth?
12:19:50 <golya> Asau: I don't know what to do now.
12:20:09 <cleverdra> golya - fix the bugs in sokoban.fs
12:20:15 <golya> Maybe I need some exercises, that prove me, that forth is easy and useful :)
12:20:16 <Herkamire> hehe
12:20:26 <ASau> Though you have too many possibilities, it's rather good way to start.
12:20:43 <cleverdra> golya - add a 'go to level N', a 'skip level', and a 'refresh level' command.  Make sure that you handle scoring sensibly.
12:20:44 <Herkamire> golya: print out the first 100 primes :)
12:21:04 <cleverdra> Herkamire - oh, boo.  If you can do that you may as well print out N primes.
12:21:05 <Herkamire> golya: or the fibbinochi sequence
12:21:17 <cleverdra> golya - write a program to emit the digits of PI until you stop it.
12:21:33 <ASau> Clev., Herk.: Should start from simple calculations.
12:21:44 <golya> Yes, and after?
12:21:47 <Herkamire> golya: print out four plus five :)
12:21:51 <cleverdra> asau - the tutorial has those enough.
12:22:07 <kc5tja> golya: Are you familiar with the use of CREATE and the , and C, words?
12:22:08 <golya> Herkamire 4 5 .
12:22:19 <ASau> OK. Then why not  follow tutorial?
12:22:24 <kc5tja> golya: actually, 4 5 + .
12:22:29 <cleverdra> golya - write an IRC keepalive -- something to stay on a connection, allow local connections, and keep an IRC connection alive with logging.
12:22:31 <golya> kc5tja: I'm exactly at that point.
12:22:36 <golya> kc5tja Ok.
12:22:49 <golya> kc5tja Ok. typo.
12:22:59 <Herkamire> golya: what kind of programs do you like to create? games? editors? graphics?
12:23:02 <kc5tja> golya: Then, maybe what you can try doing is a program that take a string and prints it out in big letters.
12:23:34 <Herkamire> kc5tja: that sounds fun
12:23:48 <kc5tja> Like, S" A" bigtype might produce the following:
12:23:49 <kc5tja>   *
12:23:50 <kc5tja>  * *
12:23:55 <kc5tja> *****
12:23:56 <kc5tja> *   *
12:23:58 <kc5tja> *   *
12:24:00 <kc5tja> or something.
12:24:03 <golya> I'm sure you have plenty of ideas, but I prefer an URL, or some kind of structured stuff.
12:24:11 <ASau> kc5tja: Maybe, SF?
12:24:39 <kc5tja> ASau: Marcel Hendrix' version you mean?  Perhaps.
12:24:56 <Herkamire> there is some source code here: http://www.forthfreak.net/wiki/index.cgi?ForthCode
12:25:05 <ASau> kc5tja, I do.
12:25:21 <Herkamire> I don't know how good it is as I haven't looked at much of it.
12:27:44 <ASau> golya, http://dmoz.org/Computers/Programming/Languages/Forth
12:27:56 <ASau> Then, "Personal Pages"
12:28:06 <ASau> "Marcel Hendrix"
12:28:55 <ASau> There is "Starting Forth" book at his site.
12:29:11 <ASau> "SF" is a must, I think.
12:29:20 <golya> thx
12:30:17 <ASau> Also, dmoz is a good starting point.
12:33:50 <ASau> I can't help with better English book as I'm satisfied with native translations.
12:34:22 <ASau> You can try to find a better tutorial in dmoz' links.
12:34:46 <kc5tja> As far as code *examples* are concerned, though, the ForthFreak Wiki page posted earlier is a good start.
12:34:51 <kc5tja> I'd wager it's even better than Taygeta's.
12:35:09 <golya> :)
12:35:15 <Herkamire> cool :)
12:35:35 <ASau> Yes, and there's http://www.forthfreak.de/wiki 
12:39:18 <golya> And I think making an interpreter is also possible in forth :)
12:39:29 <ASau> BTW, Herkamire.
12:40:22 <ASau> IIRC, you provided Forth bot here?
12:41:21 <ASau> "16-bit dragon"
12:56:18 <kc5tja> w00t!  Got the ELF image all created, and things are lookin' good.
12:56:37 <kc5tja> Now I can write the parser and hopefully get the system interpreting from command-line before I need to get to work.
12:57:10 <Herkamire> golya: interpreter for what?
12:57:48 <Herkamire> ASau: yeah, I had a bot in here. the forth it supported was rather limited and accentric though.
12:59:36 <Herkamire> it would be better to have a more standard and extensive
13:01:47 <ASau> Hm.
13:02:01 <chandler> hm, there was a forth bot?
13:02:08 <kc5tja> There used to be.
13:02:26 <ASau> It seems I've seen something to link stdin/stdout and IRC.
13:02:26 <chandler> cool
13:02:29 <mmanning> isforth has teh sources to a do nothing irc bot written entirely in forth
13:02:37 <ASau> But I may be wrong.
13:03:25 <ASau> Ha!
13:03:54 <ASau> I don't know IRCP but I've run telnet to Forth console.
13:04:00 <ASau> Done with netcat.
13:11:14 --- quit: golya ("Leaving")
13:28:17 --- quit: proteusguy (Read error: 104 (Connection reset by peer))
13:41:48 <Herkamire> ASau: tcpclient
13:42:15 <Herkamire> except that links descriptor 6 and 7 to read/write a tcp socket
13:43:19 --- join: _proteus (proteusguy@109.sub-166-153-176.myvzw.com) joined #forth
14:47:32 --- join: Nutssh (~Foo@gh-1177.gh.rice.edu) joined #forth
15:04:29 --- quit: ASau ()
16:01:09 --- join: I440r (~mark4@12-160.lctv-a5.cablelynx.com) joined #forth
16:03:58 --- join: proteusguy (proteusguy@182.sub-166-153-176.myvzw.com) joined #forth
16:29:35 --- join: Sonarman (~matt@adsl-64-160-166-125.dsl.snfc21.pacbell.net) joined #forth
16:34:35 --- quit: _proteus (Connection timed out)
16:36:30 --- quit: chandler ("Changing IRC hosts...")
16:36:51 --- join: chandler (chandler@64-145-60-36.client.dsl.net) joined #forth
16:57:53 <Herkamire> herkforth has a cut/paste stack
16:58:24 <Herkamire> sorta like an undelete key, except it puts it after the cursor
17:00:14 <Herkamire> so you can hold down backspack to delete a definition, then go elsewhere, and hold down shift-U to paste it 
17:15:55 --- join: dubious (~marc@209.71.234.197) joined #forth
17:45:05 * warpzero is back (gone 11:07:37)
17:45:54 <cleverdra> Herkamire - what platforms does herkforth target?
17:51:19 <I440r> ppc i think
17:56:29 --- quit: Nutssh ("Client exiting")
18:24:07 --- join: blockhead (default@dialin-2-tnt.nyc.bestweb.net) joined #forth
18:53:56 <Herkamire> cleverdra: ppc linux right now. eventually newworld Macs
18:54:25 <Herkamire> it could easily be ported to Mac OS X
18:54:46 <Herkamire> I just need the Mach-O header format
18:55:15 <Herkamire> (once I get it booting it won't matter what OS you have, so long as you have Mac hardware
19:16:46 --- join: Nutssh (~Foo@gh-1177.gh.rice.edu) joined #forth
19:24:00 <Herkamire> hi Nutssh 
19:30:23 <Nutssh> Hi.
19:30:29 <Nutssh> Rah, another windows worm.
19:31:01 --- quit: qFox ("if at first you dont succeed, quit again")
19:40:53 <chandler> Herkamire: I haven't had time to look at it myself but the mach-o file format is documented well by Apple
19:41:09 <chandler> http://developer.apple.com/documentation/DeveloperTools/Conceptual/MachORuntime/8rt_file_format/chapter_4_section_1.html
19:45:02 <Herkamire> chandler: thanks for the link
19:45:22 <Herkamire> looks like it only shows how to do it in C though. not giving values for any of the constants.
19:46:04 <Herkamire> I can deal though. I have a C program that makes it easy to print out many constants and their values
19:47:23 <Herkamire> I'm not going to add Mach-O support anytime soon. others are welcome to though.
19:47:27 <Herkamire> I'm more interested in making it boot
19:55:54 <chandler> there are other docs around on their site though
20:05:56 --- join: arke (~Chris@wbar8.lax1-4-11-099-104.dsl-verizon.net) joined #forth
20:06:04 --- quit: blockhead ("Client Exiting")
20:10:48 <arke> oh yay it works oh yay it works oh yay it works
20:11:23 --- quit: cleverdra ("grumble")
20:14:45 <arke> Oh Man.
20:14:54 <arke> I have thought of soooooo much cool stuff while I was netless
20:15:01 --- quit: arke ("Leaving")
20:15:17 --- join: arke (~Chris@wbar8.lax1-4-11-099-104.dsl-verizon.net) joined #forth
20:15:35 <arke> Erm, that was _not_ on purpose ^_^
20:15:40 <arke> Erm
20:15:43 <arke> Actually
20:15:51 <arke> I meant to say that that was me, not my connection
20:15:51 <arke> :D
20:16:20 <arke> alright, who wants to know of the great things I thought about while gone?
20:22:23 --- join: [Forth] (~Forth@12-160.lctv-a5.cablelynx.com) joined #forth
20:22:32 <arke> Hi ForthBot
20:38:00 --- join: cleverdra (irc@206.61.132.99) joined #forth
20:45:52 <Herkamire> :) one of my koch fractals came out nicely: http://herkamire.com/jason/images/fractals/koch/19.png
20:46:46 <arke> Hiya Herk!
20:46:55 <arke> Wow, that's neat
20:50:20 <Herkamire> source for it is here: http://herkamire.com/jason/programming.html
20:50:24 --- quit: arke (Read error: 104 (Connection reset by peer))
20:50:31 <Herkamire> SDL + Linux
20:52:06 --- join: arke (~Chris@wbar8.lax1-4-11-099-104.dsl-verizon.net) joined #forth
21:01:03 --- join: arke_ (~Chris@wbar8.lax1-4-11-099-104.dsl-verizon.net) joined #forth
21:01:03 --- quit: Herkamire ("goodnight all. bb tomorrow")
21:01:05 --- quit: arke (Read error: 104 (Connection reset by peer))
21:01:07 --- quit: dubious ("Leaving")
21:06:39 --- nick: arke_ -> arke
21:09:25 --- join: dynamowku (~d@adsl-217-182-47.owb.bellsouth.net) joined #forth
21:10:18 <dynamowku> if i create a word : bla ( a1 -- push a1 ) a1 ; it doesnt let me use a1 in my word...how do i do that?
21:10:55 <arke> a1 is already on the top of the stack there, if that's the correct stackframe
21:11:15 <arke> what did you want bla to do?
21:11:42 <dynamowku> evaluate a polynomial but this stack notation is making hard on me to keep the a1 values....and its a float value too
21:11:48 <TreyB> I think dynamowku wants locals.
21:11:59 <dynamowku> TreyB: what's that?
21:12:00 <arke> eek locals are evil ^_^
21:12:34 <TreyB> dynamowku: locals == automatic variables in C
21:12:35 <dynamowku> im really really new to this...its for programming languages course in my college...we learn a new language every other week or something...
21:12:57 <dynamowku> oh ok...so i dont want those correct? i should find a way to do my word with the stack?
21:13:12 <TreyB> You should try that, yes.
21:13:25 <dynamowku> hmm...*grabs pencil and paper* :)
21:13:31 <arke> :)
21:13:39 <arke> you can cheat and use the return stack
21:13:51 <arke> although that's not really cheating ^_^
21:13:54 <dynamowku> what's that?
21:13:58 <arke> Heh.
21:14:01 <dynamowku> he didnt mention that stack....
21:14:09 <dynamowku> floating point and the regular is all he mentioned
21:14:17 <TreyB> Have you seen any of the Forth tutorials?
21:14:18 <arke> When you call a word, it pushes an address of where to go back to on the return stack.
21:14:33 <dynamowku> no i havent seen any tutorials...just the documentation my prof gave us along with GForth
21:14:41 <TreyB> Ah.
21:14:57 <TreyB> Gforth comes with a tutorial in the info file.
21:15:06 <dynamowku> so im shooting blindly right now...
21:15:19 <dynamowku> hmm...ill go download the full GForth then and see if it can help
21:15:31 <TreyB> You have access to a UN*X box with gforth installed?
21:16:05 <TreyB> If so, you probably already have the tutorial on the machine.
21:16:09 <dynamowku> umm...i doubt it...my work servers probably doesnt have forth
21:16:43 <arke> dynamowku: by the way, rot -rot >r r> are your friends ^_^
21:16:44 <TreyB> What platform do you do your classwork on?
21:17:07 <dynamowku> i just checked...my linux box doesnt have them...we do it on windows
21:17:23 <dynamowku> ive seen rot and -rot...ill checkinto >r and r>
21:17:43 <TreyB> Did you install gforth from the .exe installer?
21:17:57 <dynamowku> no...my prof just gave us the .exe
21:18:00 <arke> dynamowku: just make sure that you keep it the way it was with >r and r> 
21:18:02 <TreyB> Ah.
21:18:32 <TreyB> http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/
21:19:06 <TreyB> Follow the tutorial section there.
21:19:46 <dynamowku> ok..thank you!
21:21:52 * TreyB goes to play a bit of Ratchet and Clank.
21:22:02 <arke> :)
21:22:25 <dynamowku> good game :)
21:23:11 <kc5tja> Back.
21:24:06 <arke> kc5tja: :)
21:24:15 <arke> kc5tja: i have thought of sooooooooooooo much stuff while I was gone :)
21:24:29 * kc5tja nods
21:24:45 <kc5tja> I got a lot of progress with FTS/Forth today.
21:24:59 <arke> Cool :)
21:25:03 <kc5tja> Implemented many MachineForth primitives, including the A register, and such.
21:25:06 <kc5tja> Really, really neat.
21:25:17 <kc5tja> I'm not going to make my goal, though, it looks like.  :(
21:25:25 <arke> Heh
21:25:31 <arke> I came up with something that might help you alot
21:25:42 <kc5tja> My goal was to get it interpreting text from command line today.  Doubt that'll happen.
21:25:48 <kc5tja> But I do have the read/evaluate loop implemented.
21:25:55 <arke> awesome :)
21:26:21 <arke> kc5tja: OT: do you know of a good editor beside Vi/Emacs? possibly something very exotic and ... different.
21:26:28 <kc5tja> What things did you think of
21:26:31 <kc5tja> ?
21:26:38 <kc5tja> arke: I am not familiar with any.  
21:27:02 <kc5tja> I know they exist though.
21:27:13 <arke> kc5tja: Well, I thought of a very very very cool forth register assignment scheme for x86
21:27:24 <arke> i heard of THE or something ... is that any good? :)
21:27:36 <kc5tja> I've seen some references to an editor called `sam,' though I'm not sure how exotic it is.  Supposedly, it's based on acme, the 8.5 standard text editor.
21:27:39 <arke> kc5tja: esp = rstack, esi and edi are _both_ used for the data stack
21:28:10 <kc5tja> arke: THE is something I'm very interested in.  qm was going to be a text editor by me, with my own interpretation of the concept.
21:28:41 <kc5tja> Why both ESI and EDI?
21:28:42 <arke> Well, I didn't mean the humane interface, but the editor THE :)
21:28:55 <kc5tja> Oh.  I don't know anything about THE.
21:29:04 <kc5tja> the "other white editor."
21:29:10 <arke> :D
21:29:18 <arke> Well, here's how it works.
21:29:50 <arke> : dup s-write stosd, ;
21:29:58 <arke> : drop s-read lodsd, ;
21:30:50 <arke> s-write is an immediate word that ensures that edi is up to date
21:31:02 <kc5tja> I would change the order of operations.
21:31:15 <arke> good case, it does nothing, bad case, it compiled a mov edi, esi
21:31:18 <kc5tja> I would always assume that ESI=EDI at the beginning of DUP and DROP, and do something like this:
21:31:24 <kc5tja> : dup stosd, s-write ;
21:31:28 <kc5tja> : drop lodsd, s-read ;
21:31:42 <arke> how would that work?
21:31:48 <arke> (but do you like my idea? :) )
21:32:16 <kc5tja> Well, when stosd is executed, we know for a fact that ESI != EDI.  So s-write compiles mov esi,edi.
21:32:34 <arke> oh, heh
21:32:37 <arke> naah
21:32:43 <kc5tja> Likewise, when lodsd is executed, we know that ESI != EDI.  So, s-read compiles mov edi,esi (note register reversal).
21:32:53 <arke> compiler keeps a flag on which register is currently up2date
21:33:22 <arke> Hrm. I don't really know which would be better.
21:33:24 --- part: dynamowku left #forth
21:33:37 <kc5tja> Well, as long as the compiler can maintain proper state, then that's a fairly neat idea.
21:33:53 <arke> Something you might wanna do for FTS/Forth :)
21:34:06 <kc5tja> For now, I'll continue to use what I'm using now.
21:34:14 <arke> Of course :)
21:34:15 <kc5tja> But I'll evaluate it for later use in future optimizations.
21:34:26 <arke> I'll definetely be using that for RkForth, once I finally get that started.
21:34:36 <arke> Do you like the idea? :)
21:34:59 <kc5tja> As long as you can maintain proper compiler state, sure.  That's the trick that would make the whole thing work.
21:35:35 <kc5tja> The only problem is that it sucks up a CPU register that perhaps could be used for something else.
21:35:42 <kc5tja> So it depends on what you want in your target Forth environment.
21:35:53 <arke> like what? Forth doesn't need many registers :)
21:36:31 <Nutssh> Get it working, then worry about tweaks?
21:36:36 <arke> EBP is spare too. Got nothing for it to do. Might use it as a dictionary base pointer
21:36:48 <kc5tja> Ideally, true.  But I'm quite likely going to be implementing primitives that work with vectors in the future (especially for my circuit simulator).  I may need an extra register or two.
21:36:58 <arke> vectors?
21:37:13 <kc5tja> arke: Vectors are 1-dimensional arrays.
21:37:34 <arke> an array-based forth? :D
21:37:49 <kc5tja> No, vector math primitives coded for FTS/Forth.
21:37:52 <arke> You know what's pissing me off?
21:38:02 <arke> I'm killing stuff, yet it won't die.
21:38:05 <kc5tja> But my friend Billy is seriously considering a vector-based Forth implementation.
21:39:02 <arke> cool
21:39:28 * arke is coding a 3D renderer for his TI-83 .... yes, you may laugh.
21:40:51 <arke> I read about CF's */
21:40:58 <arke> Talk about coolness.
21:41:11 <kc5tja> You never knew about */?  It's been in Forth since the very beginning.  :)
21:41:17 <arke> heh
21:41:21 <kc5tja> In fact, MY Forth is the oddball of the bunch, in that it lacks */ completely.
21:41:39 <arke> */ ( a b c --- a*(b/c) )
21:41:55 <arke> quite useful, I must say.
21:41:58 <kc5tja> Well, more accurately, as far as order of operations is concerned, it's (a*b)/c
21:42:01 * kc5tja nods
21:42:11 <arke> kc5tja: well, but it comes out the same, ... i think.
21:42:26 <kc5tja> When dealing with integers of finite length, not always.
21:42:42 <kc5tja> Multiplication is done first because it produces the higher precision (32-bits times 32-bits equals a 64-bit number).
21:42:52 <kc5tja> Then division is used to reduce the precision back to 32-bits.
21:43:12 <arke> I don't really get how the CF */ works.
21:43:21 <kc5tja> But you can think of it as being the same algebraic operation, yes.
21:43:36 <kc5tja> Here is FTS/Forth's definition:
21:43:42 <kc5tja> : */ >r * r> / ;
21:43:43 <arke> mov ecx, eax
21:43:49 <arke> lodsd
21:43:55 <arke> imul [esi]
21:44:00 <arke> idiv [ecx]
21:44:07 <kc5tja> imul [esi]
21:44:08 <arke> lea esi, esi+4
21:44:13 <kc5tja> idiv ecx ; no [...]
21:44:19 <I440r> add esi, byte 4
21:44:39 <kc5tja> I440r: No, lea esi,[esi+4].  LEA is smaller, and doesn't change flags.
21:44:41 <I440r> i dont thing add esi, byte 4 is any slower but its smaller
21:44:49 <arke> according to chuck, its idiv [ecx], but that might be a typo :)
21:44:54 <I440r> i dont think the lea is smaller
21:44:58 <kc5tja> arke: Definitely a typo.
21:45:05 <kc5tja> I440r: LEA is 3 bytes.  ADD is 6.
21:45:09 <I440r> i think the 4 is compiled as a 32 bit number
21:45:11 <arke> I440r: but it doesn't preserve flags.
21:45:12 <kc5tja> Don't believe me?  NASM it.  :)
21:45:26 <arke> which, unfortunately, CF is based on :(
21:45:30 * arke hates the concept of flags
21:45:32 <I440r> add reg, byte n is not 6
21:45:43 <kc5tja> I440r: Don't make me paste the results of ndisasm here.
21:45:48 <I440r> ill accept the preserve flags arguement :)
21:45:54 <arke> :)
21:46:06 <arke> or debug, for that matter.
21:46:11 <arke> but debug isn't linuxed
21:46:52 <kc5tja> I440r: Sorry, I didn't see the byte modifier.
21:46:58 <kc5tja> I440r: In that case, it's the same length as LEA.
21:47:02 <kc5tja> 3 bytes either way.
21:47:16 <arke> :)
21:47:27 <arke> How do imul and idiv work?
21:47:32 <arke> they seem evil.
21:47:41 <arke> :)
21:47:41 <kc5tja> arke: IMUL => EDX:EAX = EAX * ECX
21:48:04 <kc5tja> arke: IDIV => EAX = (EAX/ExX); EDX = (EAX % ExX)
21:48:25 <I440r>    2
21:48:25 <I440r>      3 00000000 6683C001                add eax, byte 1
21:48:51 <I440r> however i DO accept the flags arguement heh
21:48:56 <kc5tja> I440r: Your assembler is buggy; the 66 prefix turns that into add al,byte 1
21:48:58 <arke> yep :)
21:49:04 <I440r> no
21:49:15 <I440r> er thats nasm
21:49:33 <kc5tja> Dude...
21:49:34 * kc5tja sighs
21:49:35 * kc5tja posts
21:49:38 <kc5tja> [bits 32]
21:49:40 <I440r> kc im starting to believe you
21:49:42 <I440r> i know
21:49:47 <kc5tja>   add esi,4
21:49:47 <I440r> i know what the 66 is
21:49:50 <kc5tja>   add esi,byte 4
21:49:54 <kc5tja>   lea esi,[esi+4]
21:49:56 <kc5tja> produces:
21:50:20 <kc5tja> 00000000 81c604000000
21:50:20 <I440r> let me change to using esi instead of eax
21:50:32 <kc5tja> 00000006 83C604
21:50:41 <kc5tja> 00000009 8D7604
21:50:42 <kc5tja> :)
21:50:58 <arke> Ack.
21:51:02 <arke> x86 evil.
21:51:07 * kc5tja thinks you forgot to include [bits 32] in your source.
21:51:22 <arke> I really think we should all start using _my_ CPU :)
21:51:37 <I440r> oh i did
21:51:53 * arke came up with the coolest chip ... maybe great for embedding?
21:52:09 <I440r>     5 00000000 83C601                  add esi, byte 1
21:52:09 <I440r>  
21:52:17 <I440r> 3 bytes
21:52:23 <kc5tja> Yep, that agrees with what I have.
21:52:27 <kc5tja> But I'm also correct re: LEA.  :D
21:52:37 <I440r> yes it preserves flags
21:52:55 <I440r> however. in certain cases the lea is slower i believe. however this may no longer be true
21:53:05 <I440r> i dont keep up with that shit no more
21:53:08 <I440r> waste of time to do so
21:53:19 <arke> 0xF-bit RISC proc, with 0xF instructions, and a 0xF instruction fetch. 0xF registers, r0 being a constant non-locking 0. Jumps/Branches are cool as they use register dependencies to make wasted prefetch cycles = 0
21:53:27 <kc5tja> Not for that addressing mode.  I think it's slower if you do something like [esi+edi], since that would require 4-port access to the register file to do fully.
21:53:50 <I440r> well the only time i would use lea that way would be for a multiply
21:54:00 <I440r> lea eax, [eax+2*eax]
21:54:05 <I440r> multiply eax by 3
21:54:17 * kc5tja nods
21:54:18 <arke> lea is kinda neat that way ^_^
21:54:41 <I440r> the a86 assembler allows you to do lea eax,[eax*3] hehe
21:54:57 <I440r> etc etc
21:54:57 <arke> i think nasm does too
21:54:58 <Nutssh> Its probably an at-least 1 ghz CPU. An extra clock cycle in a prototype don't matter. :)  ANd profiling will be much better at fidning problems anyways. :)
21:55:18 <arke> Nutssh: referring to me?
21:55:28 <arke> Nutssh: I was more thinking of something like 20mhz.
21:55:30 <I440r> hmmm ill benchmark 10000 lea's against 10000 adds hehe
21:55:31 <Nutssh> I"m not sure.
21:55:49 <I440r> whic will tell me which one is faster on MY box lol
21:55:55 <kc5tja> :)
21:56:02 <arke> ;)
21:56:18 <Nutssh> I've always had the best luck write it first, then profile. 
21:56:20 <kc5tja> I440r: Good point.  Maybe I should do the same.  But not right now.  I have more important things to do with FTS/Forth first.
21:56:20 <arke> kc5tja: how do ya like my newest CPU? (not that you know alot :))
21:56:44 <I440r> err how do you tell nasm to assembler something multiple times ?
21:56:50 <I440r> rept ?
21:56:56 <kc5tja> I440r: TIMES <expr> <instruction>
21:57:02 <arke> kc5tja: no FPU or MMU, but I think that at 20Mhz with decent hardware, it'll do the job those mcd's p2-200 registers barely do.
21:57:13 <I440r> hats it
21:57:39 <kc5tja> arke: Well, I'm looking at perhaps building my own MISC using discrete components, with asynchronous logic.
21:57:56 <I440r> so times 10000 lea eax, [eax+1] 
21:58:08 <kc5tja> I can probably get the thing running at around 40MHz equivalent speed because of asynch's unique signaling, and its highly localized signal propegation paths.
21:58:11 <arke> WHY THE FUCK WONT WINDOWS KILL
21:58:18 <arke> ugh
21:58:21 <I440r> i wanna know why it wont die :)
21:58:54 <Nutssh> kc5tja: Sounds neat.
21:58:57 --- join: imaginator (~gps@166.70.196.201) joined #forth
21:59:17 <kc5tja> And while it's possible for it to go faster, I'd be really shocked if it did.  :)
21:59:37 --- quit: arke (Read error: 104 (Connection reset by peer))
22:00:35 <imaginator> Hi 
22:00:56 <imaginator> Why did the Forth CPUs not take over the world?
22:01:39 <kc5tja> Too simple.
22:01:50 <I440r> the add seems to be faster here
22:01:55 <I440r> but i would never swear to it
22:02:06 <I440r> timer-reset fud .elapsed 00:00:01.715 ok
22:02:06 <I440r> timer-reset zud .elapsed 00:00:01.498 ok
22:02:10 <kc5tja> You can't maintain business if the CPU is so simple that any arbitrary competitor can make one without a lick of reverse engineering expenditure.
22:02:29 <I440r> not unless you have it patented
22:02:33 <I440r> which takes time
22:02:42 <kc5tja> I440r: Chuck has patents on them already.
22:02:44 <imaginator> What cool apps ran on the Forth CPUs?
22:02:45 <kc5tja> But that didn't help.
22:03:13 <kc5tja> imaginator: Virtually every satellite in orbit today has an RTX-2001 stack CPU in it.  There are some exceptions (e.g., Hubble Space Telescope has 80286).
22:03:31 <imaginator> wow
22:04:29 <I440r> 286 ?
22:04:31 <I440r> lol
22:04:39 <I440r> ok the add is definatly faster here
22:04:47 <I440r> i did 100000 instructions each
22:04:50 <imaginator> I440r what are you benchmarking?
22:04:54 <I440r> and did a 10000 0 do xxx loop
22:05:09 <I440r> the difference between lea eax, [eax+1] and add eax, byte 1
22:05:15 <I440r> the add was faster on THIS processor
22:05:21 <I440r> amd athlon xp 1800
22:05:40 <I440r> you watch - the numbers will reverse on a pentium :P
22:05:50 <I440r> 00:00:12.977
22:05:50 <I440r> 00:00:09.837
22:05:50 <I440r>  ok
22:06:15 <I440r> thats 100 thousand instructions of lea inside a 100000 0 do loop takes 12 seconds
22:06:22 <I440r> the same number of adds takes 9
22:06:50 <imaginator> That reminds me, I've been trying to convert a saying in finance to programming.  Basically the statement is: "If you take care of the pennies the dollars fix themselves."
22:07:07 <I440r> thats an old brittish saying
22:07:12 <imaginator> If you take care of the cycles the [what?] fix themselves.
22:07:17 <I440r> look after your pennies and the pounds will look after themselves
22:07:45 <I440r> imaginator, i think optimizing at the instruction level is FUN. it has no other practical use that i can see
22:08:15 <kc5tja> I440r: Then you've never had to squeeze every ounce of performance from a CPU for a real-world application then.
22:08:33 <I440r> kc5 name one (no im not saying they dont exist)
22:09:13 <I440r> ive had to optimize specific routines before. but only because i was not allowed to change the algorithm to a faster one
22:09:17 <kc5tja> I440r: To one-up the competition, Hifn released a Pentium software-only implementation of an LZ77 decompressor in software that outperformed HARDWARE by a factor of 2:1, by hand-tweaking the code in assembly.
22:09:39 <I440r> hifn ?
22:09:47 <kc5tja> The result: the software is now embedded in many routers used in the world today, because it performs as good as dedicated compression hardware for network packet processing, without requiring a twice-as-expensive CPU.
22:09:57 <I440r> kc5 i can guarantee that half of his optimizatijons were intel cup specific
22:10:04 <kc5tja> I440r: Duhh, of course.
22:10:18 <kc5tja> I did say Pentium-tweaked.  :)
22:10:26 <I440r> i.e those optimizations are counter proiductive on a amd
22:10:35 <kc5tja> I440r: Perhaps.
22:10:44 <I440r> the point for production software is you cant always guarantee exactly what processor it will run on :)
22:10:49 <I440r> but it IS fun :)
22:10:50 <kc5tja> Wrong.
22:11:00 <I440r> i said you cant ALWAYS
22:11:01 <kc5tja> Production software != DESKTOP software.
22:11:10 <I440r> ok
22:11:14 <kc5tja> :)
22:11:15 <I440r> if your going toi make that qualification :)
22:11:18 <Nutssh> I've found that sometimes the most trivial of changes can be a huge difference, the trick is figuring out what needs to be changed.
22:11:54 <I440r> you take your pick of processor. optimize a quic sort written in any languate you want
22:11:56 <I440r> c or assembler
22:12:01 <I440r> optimize it to the hilt
22:12:28 <I440r> ill use a radix counting sort and do multiple sorts on the same data in the time it takes you to do it once
22:12:35 <I440r> assuming a non trivial ammount of data
22:12:42 <I440r> however
22:12:45 <I440r> !!!
22:12:48 <I440r> i cant sort in place heh
22:12:54 <I440r> so i need more memory than you
22:13:25 <kc5tja> I440r: Why are you so patently obsessed with this irrelavent and inapplicable benchmark?
22:13:43 <I440r> its not irrelavant - well IT is - the point its making isnt
22:13:44 <kc5tja> If radix sort is so much faster, then what is preventing me from coding the most optimized, bad-ass RADIX sort instead of quicksort?
22:14:01 <I440r> kc5 lol nothing
22:14:04 * warpzero is away: Cuss words! Oh no!
22:14:22 <I440r> but your optimized quick against my very badly written radix counting
22:14:29 <I440r> the radix will win
22:14:43 <I440r> assuming i have the memoryh for 2 copies of the data
22:14:46 <I440r> 1 sorted
22:14:48 <I440r> 1 unsorted
22:14:53 <I440r> PLUS a buffer for the counts
22:15:00 <I440r> of 256 bytes
22:15:22 <kc5tja> Well, I am offended by even mentioning that comparison, because as a professional programmer, I benchmark several sorting algorithms, determine which is best for my needs, then optimize the hell out of *that*.  For me, it's a complete non-issue.
22:15:59 <I440r> kjc5 but you picked the best algorithm. not "take this one out of the library"
22:16:05 <I440r> thats cheating :P
22:16:46 <kc5tja> heh
22:16:48 <kc5tja> .ckear
22:16:51 <kc5tja> wtf
22:16:55 <I440r> yes. processor optimizations can give HUGE performance increases. but not as huge as algorithm selection
22:16:58 <I440r> eh ?
22:18:35 <I440r> my typing must be infectious
22:22:03 --- join: Serg (~z@212.34.52.140) joined #forth
22:23:30 <kc5tja> I440r: The thing is, they're multiplicative in nature.
22:23:49 <kc5tja> Processor + algorithmic optimization makes for overwhelmingly superior performances.
22:29:11 <I440r> yup
22:29:26 <I440r> until someone tries to run it somewhere else lol
22:29:57 --- quit: Sonarman (Read error: 110 (Connection timed out))
22:31:15 <Nutssh> Yup, but knowing what parts are important is also important, and is frequently surprising.
22:32:10 <I440r> ya
22:32:14 <I440r> profiling helps
22:33:44 <imaginator> Is there a profiler that gives more usable output than gprof?  It seems more function oriented, and as I try to avoid functions it ends up not being very useful.
22:34:09 <I440r> forth teaches hyou to factor your code
22:34:11 <imaginator> (that is something better for profiling than clock() or time())
22:34:15 <I440r> FACTOR your code :P
22:34:31 <imaginator> huh?
22:35:07 <I440r> you said you avoid functions
22:35:07 <imaginator> I use the inline keyword, and my code is factored.
22:35:14 <I440r> ok :)O
22:35:43 <imaginator> I'm searching for more of an instruction level profiler that would work w/ C.
22:35:52 <I440r> aha
22:36:40 <I440r> the best kernel humour can be found in /usr/src/linux/drivers/net/sunhme.c 
22:36:41 <I440r> one of suns original network cards was named the Sun Big MAC 
22:36:41 <I440r> (mac as in mac address, network wise) 
22:36:43 <I440r> some future developers decided to continue on the naming scheme and produced the Sun Happy Meal Ethernet adapter (hme)...
22:36:46 <I440r> lol
22:37:21 <imaginator> I hope that McDonalds doesn't sue ;)
22:37:26 * kc5tja liked Commodore's continued system of naming their I/O chips after government organizations.  :)
22:37:27 <I440r> lol
22:37:34 <I440r> lol
22:37:41 <kc5tja> Motorola had the PIA, MOSTek had the VIA, and then Commodore had the CIA.  :D
22:38:02 <kc5tja> It was rumored the Commodore 128's I/O interface chip was supposedly called the FBI chip, but it turned out to be just a refined CIA.  :)
22:39:18 <Nutssh> imaginator: gprof can give you line-level information if you compile the program with debugging flags and pass gprof the right options.
22:39:48 <imaginator> Nutssh: I'll look into that then.  Thanks
22:39:51 <Nutssh> And, there are ways to do basic block level profiling, which can also be useful.
22:40:36 <Nutssh> (the statistical sampler gives the current PC at 100hz, which gprof can combine with symbols to assign that PC to a line of code or to a function, but the raw PC statistics are there.)
22:41:53 <I440r> zzz time
22:41:59 <Serg> hi folks !
22:42:13 <I440r> serg lol
22:42:18 <Serg> see my homepage: http://cryptomancer.narod.ru
22:42:34 <Serg> all in RU, but maybe add some ENG
22:42:49 <Serg> I440r: it has link to IS-FORTH ;))
22:42:59 --- join: vegemite (leontopod@intertwingled.net) joined #forth
22:43:03 <I440r> cool :)
22:43:15 <vegemite> ?
22:43:26 --- nick: vegemite -> Teratogen
22:43:30 <Teratogen> HALLO!
22:43:33 <I440r> hi lol
22:43:51 <Serg> seems like I440r eaten a LOL pill ;))
22:43:55 <imaginator> Nutssh: that sounds great.
22:44:03 <I440r> :)
22:44:49 <I440r> actually i440r needs to eat a sleeping pill :/
22:45:17 <I440r> anyone here a rubics cube fanatic ?
22:45:32 <Serg> ;(((((( i hate drugs (anything mind-active ex ..
22:45:42 <Serg> ..ex vitamines found in natural food
22:45:50 <I440r> i mean its time for bed, i never do drugs like that 
22:46:07 <Serg> ;)
22:46:13 <Serg> me slept a little too
22:46:25 <Serg> was playing GTA3 ;)
22:46:43 <I440r> gta3 ?
22:46:51 <Teratogen> I440r, hallo!
22:47:00 <Serg> shoot a bus and chase it till it burn, looking how it rampages and smashes other cars
22:47:00 <I440r> eh ?
22:47:09 <Teratogen> I just upgraded from win 98 to win 98 se
22:47:10 <Teratogen> wh00t
22:47:10 <Serg> GTA3 = Grand Theft Auto
22:47:30 <Serg> great game ! drive'n'shoot ;))
22:47:33 <I440r> i saw a mpg today of a us helecopter watching 3 iraqui guys setting up to plant a road mine
22:47:38 <Teratogen> my favorite game of all time was and is Descent 2
22:47:43 <Teratogen> although I here there is a Descent 3
22:47:50 <I440r> he shot at one of them as he crossed the road and LITERALLY tore the guy to pieces
22:48:04 <I440r> the others were on the left side of the road and right side of the road each
22:48:19 <I440r> the second iraqui was fired on 2 seconds after the first
22:48:23 <I440r> and HE was tore up
22:48:33 <I440r> the third hid behind a druck and would have stayed hidden
22:48:40 <I440r> but he slipped and fell and came into view
22:48:43 <I440r> not for long
22:48:52 <Serg> seems like VERY BAD play movie
22:48:53 <I440r> i didnt like the decent games heh
22:49:14 <I440r> it was actual footage from the helecopter
22:49:21 <Serg> vere they blind and deaf ?????? did they hear and see chopper ???
22:49:25 <I440r> you were seeing exactly what the pilot was seeing
22:49:32 <I440r> you see a shudder in the view as he fired
22:49:41 <I440r> then you see the bullets rip the target to pieces
22:49:56 <I440r> no. he was at least a couple of mies away 
22:50:04 <Serg> but why target was so stupid ???????
22:50:07 <I440r> using infared
22:50:16 <I440r> they were iraqui
22:50:20 <Serg> would YOU plant a mine in view of enemy chopper ????
22:50:40 <I440r> the first guy was crossing the road looking happy, you coule TELL!!!!
22:50:53 <I440r> he was bouncing about ina "weehee im gona plant a bomb hehe" mannter
22:51:04 <I440r> he didnt knwo the chopper was there
22:51:10 <Serg> hey, was he deaf ??
22:51:13 <I440r> noi
22:51:20 <I440r> the helecopter was 2 miles awayu
22:51:31 <I440r> can you hear a helecopter 2 miles away ?
22:51:46 <I440r> it might even have been further away - but if he was his shooting was awesome
22:52:06 <kc5tja> I440r: Computers are wonderful things.  :)
22:52:06 <Serg> can YOU hit anything from 2 miles, even from bench-rest, not to say from chopper what is not stable gun platform ?
22:52:25 <I440r> kc5 yes but his shooting was STILL awesome if that was further than 2 miles
22:52:41 <I440r> serg duh ive seen people who could
22:52:56 <I440r> a 30-06 will go 2 miles NO problem
22:53:01 <I440r> these were 30 mm cannon
22:53:34 <I440r> imagine 80 or 90 of those slamming into you in half a second flat
22:53:48 <I440r> actually the rate of fire wasnt that fast
22:54:06 <I440r> but shit all you could see on the infa-red was a huge patch of warm sand
22:54:42 <Serg> even 7.56 of Mosin goes 4 km, but think of _dispersion_
22:54:46 <I440r> i can hit a 6 inch target with my 45 caliber handgun at 100 yards :)
22:55:06 <I440r> drop can be calculated
22:55:23 <I440r> wind interfearance would be negligable to a 30 mm cannon at those ranges
22:55:31 <I440r> specially at those rates of fire
22:55:46 <I440r> the recoil would cause more vertial drift
22:56:15 <I440r> ok. that 45 at 100 yards is without a rest
22:56:48 <Serg> listen, I440r:
22:57:06 <Serg> IL-2 of WW2 time had 2 20-mm rapid fire cannons
22:57:26 <I440r> ok
22:57:31 <Serg> it shot _tank_ from 1000-200m w/ collimator aim
22:57:38 <I440r> erm actually ive been saying 30mm and i meant 20 lol
22:57:57 <Serg> of 100-400 rounds, wery few hit so huge target, coz of _dispersion_
22:58:16 <Serg> very few _if any_ in some passes
22:58:30 <I440r> i saw the bullets from these shots hit a 6 to 8 foot ciccle 
22:58:36 <I440r> with the target centered therein
22:58:48 <I440r> was that helecopter moving or stationary
22:58:54 <I440r> this one was hovering
22:58:55 <I440r> watching
22:58:59 <I440r> picking its time
22:59:04 <I440r> chosing its targets
22:59:40 <Serg> IL-2 was strafing at panzer column at 300-400 km/h
22:59:53 <I440r> thats why they missed
23:00:29 <kc5tja> If you're hovering, you're basically sniping.
23:00:35 <I440r> yup
23:00:41 <Serg> hell no !
23:00:43 <I440r> thats exactly what this guy was doing
23:01:04 <Serg> try 'sniping' from a swing ;))
23:01:11 <I440r> serg i think the apache is kinda more advanced than a ww2 helecopter hehe
23:01:18 <I440r> lol
23:01:22 <kc5tja> Serg: Our choppers can stay stationary as a rock when hovering due to gyroscopic stabilization.
23:01:47 <Serg> how much does it weight ?
23:02:03 <I440r> the apache usually pokes its head up ofer the crest of a hill, lets its electronics take a snapsoot. then it ducks for cover
23:02:04 <kc5tja> It'd take some pretty nasty cross-winds to make it swing while hovering, and I know for a fact that Iraq doesn't have heavy cross winds.  It *can't* -- it's a desert.  :)
23:02:18 <I440r> the pilots then pick their targets and take em out one at a time
23:02:32 <Serg> what is speed and weight of a round (bullet+gases) ?
23:02:40 <I440r> no idea heh
23:02:54 <I440r> i cant even tell you what my hand loaded 223's chrony at lol
23:02:57 <kc5tja> Serg: That's rather classified information anyway.  There's no way we'd be able to find out as civilians.
23:03:00 <I440r> but there a 69 grain bullet
23:03:23 <Serg> fu.. grains, let's talk in SI
23:03:28 <kc5tja> Hahahah :)
23:03:37 <I440r> lol i cant shoot that in my ar-15 lol :P
23:04:00 <I440r> i think i wanna get my ar a new barrel
23:04:09 <I440r> because this one has excessive freebore
23:04:16 <I440r> most modern rifles do
23:04:18 <I440r> bah
23:05:34 <Serg> really, i suspect what damn propagandf men hired innocent 'actors' from poor dropouts to 'plant a mine' as play movie, and then meanly killed 'em point-blank
23:06:02 <I440r> point blank lol
23:06:11 <Serg> and i change my mind _only_ then i see or calculate what such far hit is possible
23:06:14 <I440r> no. you could tell that one guy was really really happy lol
23:06:24 <I440r> he was lioke "woohooo!!! im gona plant a bomb!!!!"
23:06:33 <I440r> oopts.. think again buddy
23:06:50 <Serg> sure - he was thinking of money he'll get for play, but caught a 20mm shell
23:07:18 <I440r> more than just one
23:07:23 <I440r> 40 or 50 if you ask me
23:07:27 <Serg> ;(
23:07:30 <I440r> all within the space of a second or 2
23:07:34 <I440r> anyway time for zzz
23:07:49 <Teratogen> let us go Forth, brothers
23:07:55 <Serg> anyway, i'll change my mind only after seeing or calculating so far hit
23:07:56 <I440r> :)
23:08:00 <Teratogen> yea, let us go Forth into the valley of the Shadow of Lisp
23:08:07 <I440r> lol
23:08:27 <I440r> yea tho i walk in the shaddow of the valey of LISP. i shall fear NO evil!
23:13:10 <kc5tja> You fools!  The LISP cannot be destroyed with your weapons!  It can only be destroyed in the land of McCarthy, where it was forged!!
23:13:13 <kc5tja> Oops, wrong story.
23:14:24 * Serg did not grasp Lisp as easy as Forth ;))
23:15:45 <imaginator> lol
23:16:30 <Serg> lotsa parens like holes in a road, i stumbled over at every step
23:18:45 <kc5tja> It definitely takes some getting used to.
23:18:52 <kc5tja> A good tutorial is a requirement.
23:19:11 <kc5tja> But I still think it's very beneficial to learn Lisp (or Scheme, a very, very close relative to Lisp).
23:33:07 --- part: Nutssh left #forth
23:40:29 --- quit: Teratogen ("SKYKING, SKYKING, DO NOT ANSWER")
23:43:18 <Serg> kc5tja: only if i'll have a task what can be done in Lisp superiorly to other languages
23:43:25 <Serg> what are such tasks ?
23:48:57 <kc5tja> Serg: That's like saying you'll only learn C only if it can be used for tasks that it's well suited for.
23:49:05 <kc5tja> Lisp is a general purpose programming language.  It can be used for anything.
23:49:47 * kc5tja notes that AutoCAD is written in Lisp, as is Emacs.
23:50:10 <kc5tja> Many plug-ins for GIMP are written in Scheme, a simplified dialect of Lisp.
23:50:20 <kc5tja> Etc.
23:51:38 <cleverdra> except that Lisp has certain fairly important features that make it slightly more 'general purpose' than, say, C.
23:53:01 <Serg> hi cleverdra ;)))
23:53:15 <cleverdra> howdy, Serg =)
23:53:24 <Serg> so, what adwantage Lisp gives me ?
23:54:14 <cleverdra> dynamic typing, the compiler at run-time, and the language at compile-time =)
23:57:06 * Serg is screwed - main W2K server hung like fascist schwine in Nurenberg ;((
23:59:59 --- log: ended forth/04.01.26