00:00:00 --- log: started forth/03.09.17
00:51:05 --- join: njd (~melons@njd.paradise.net.nz) joined #forth
01:11:02 --- quit: njd (Read error: 104 (Connection reset by peer))
01:24:52 --- join: Grant1 (~pyromania@202.59.99.234) joined #forth
01:43:19 --- quit: Grant_ (Read error: 110 (Connection timed out))
01:50:49 --- join: Grant_ (~pyromania@202.59.99.234) joined #forth
01:55:56 --- quit: Grant1 (Read error: 110 (Connection timed out))
01:57:39 --- join: njd (~melons@njd.paradise.net.nz) joined #forth
02:11:46 --- quit: njd ("Leaving")
04:11:42 --- join: Grant1 (~pyromania@202.59.99.234) joined #forth
04:27:28 --- join: njd (~melons@njd.paradise.net.nz) joined #forth
04:30:32 --- quit: Grant_ (Read error: 110 (Connection timed out))
04:57:39 --- join: Grant_ (~pyromania@202.59.99.234) joined #forth
05:13:29 --- join: Grant_P (~pyromania@202.59.99.234) joined #forth
05:16:09 --- quit: Grant1 (Read error: 110 (Connection timed out))
05:30:29 --- quit: Grant_ (Read error: 110 (Connection timed out))
06:33:34 --- join: XeF4 (~xef4@polymer225.gprs.suomen2g.fi) joined #forth
06:41:01 --- join: mmanning (~mmanning@saturn.vcsd.com) joined #forth
06:41:07 --- nick: mmanning -> I440r-wrk
06:42:06 --- quit: Grant_P (Read error: 60 (Operation timed out))
06:52:37 <XeF4> seen kc5tja
07:24:14 <I440r-wrk> where ?
07:27:09 <XeF4> here
07:31:35 --- quit: rpc (leguin.freenode.net irc.freenode.net)
07:31:38 --- quit: ianP (leguin.freenode.net irc.freenode.net)
07:32:15 --- join: ianP (ian@inpuj.net) joined #forth
07:32:15 --- join: rpc (~rpc@global.whiteh8.net) joined #forth
07:50:25 --- join: XeF4_ (~xef4@allozyme79.gprs.suomen2g.fi) joined #forth
08:11:41 --- quit: XeF4 (Read error: 110 (Connection timed out))
08:18:01 --- join: arke (~rk@ca-cmrilo-docsis-cmtsj-b-36.vnnyca.adelphia.net) joined #forth
08:31:21 --- join: Grant_P (~pyromania@202.59.99.234) joined #forth
09:34:08 --- quit: SDO (Read error: 110 (Connection timed out))
09:34:45 --- join: Grant1 (~pyromania@202.59.99.234) joined #forth
09:42:40 --- quit: Grant_P (Read error: 60 (Operation timed out))
09:45:26 --- join: XeF4 (~xef4@eukaryote69.gprs.suomen2g.fi) joined #forth
10:08:22 --- quit: XeF4_ (Read error: 110 (Connection timed out))
10:14:34 --- join: XeF4_ (~xef4@mitosis196.gprs.suomen2g.fi) joined #forth
10:19:36 --- quit: XeF4 (Read error: 110 (Connection timed out))
10:45:10 --- quit: XeF4_ (Read error: 104 (Connection reset by peer))
10:45:32 --- join: Speuler (~Speuler@mnch-d9ba4516.pool.mediaWays.net) joined #forth
10:45:38 <arke> y0
10:45:42 --- join: XeF4 (~xef4@mitosis188.gprs.suomen2g.fi) joined #forth
10:45:42 <Speuler> oi
10:45:50 <arke> y0
10:47:01 <Speuler> why is there (afaik) no forth compiler, generating stand-alone ELF binaries  (except maybe sedForth) ?
10:47:19 <arke> Speuler: well, it is being worked on, dont worry.
10:47:30 <arke> actually, im working on the DOS one right now....
10:47:35 <Speuler> ws just considering starting myself
10:48:30 <Speuler> for DOS, there are several
10:48:56 <Speuler> even doing a decent job on optimization
10:49:34 <Speuler> there should be one for unix (existed 10 or 15 years ago) but i forgot its name
10:49:38 <XeF4> Speu: because that is usually not so useful in practice
10:50:24 <arke> hm ... it should be useful
10:50:27 <Speuler> i used a compiler under msdos for many years, thought it was very useful
10:50:35 <arke> i find it quite useful
10:51:14 <Speuler> turning out executables w/o the code required for compile-time only, can't say that's not useful 
10:51:49 <Speuler> "hello world" in 80 bytes .com  
10:51:58 <XeF4> I use a lot of "compile-time" stuff at runtime
10:51:59 <Speuler> (ok, that's NOT useful :)
10:55:34 <arke> 80 bytes .com ...
10:55:52 <arke> could be less, i think
10:56:17 <arke> mov al, 0x06
10:56:20 <XeF4> could be ehm.. 17 or so at most
10:56:23 <arke> yeh
10:57:00 <Speuler> program setup, string output routine, program exit including
10:57:28 <Speuler> string alone is 12 bytes
10:58:09 <arke>  mov ah, 0x09
10:58:09 <arke>  mov dx, string
10:58:09 <arke>  int 0x21
10:58:09 <arke>  ret
10:58:09 <arke> string: db 'Hello, World!', 13, '$'
10:58:10 <Robert> Doesn't IsForth create ELF binaries?
10:58:14 <Speuler> or you need to represent it as base36 number, or compress it otherwise
10:58:45 <Speuler> arke, where's the stack ?
10:58:49 <arke> Robert: well, but its not ncc
10:58:54 <Speuler> did your compiler optimize it away ?
10:59:07 <arke> Speuler: i dont know, i just know that Robert does that with .com's, and it works
10:59:54 <Robert> Argh.
11:00:02 <Robert> We're talking about Forth programs here, arke.
11:00:25 <Robert> Forth compilers can't just do something like that, unless you provid them with  AI :)
11:00:40 <arke> Robert: well, i think its compiled as dd dup, dd swap, etc., and not as push ebx; xchg ebx, [esp] and stuff ... so the interpreter is still there
11:00:50 <XeF4> actually, a forth compiler could do that without much more than a peephole optimizer
11:01:08 <Speuler> the compilers i used didn't check whether the prog is that simple that no init of par stack, for eample, would be required, and set it up anyway. also, "type" was compiled as fn, receiving the string as known from forth, on the stack (actually, registers)
11:01:10 <Robert> Ehrm.
11:01:25 <Speuler> before int 0x21 there's missing a mov ax,04c00
11:01:35 <Speuler> or you'd have to use int 020
11:01:41 <Speuler> (depreciated)
11:01:54 <XeF4> speu: you can also just ret from a .com
11:02:09 <Robert> Yes, offset 0 contains int 0x20.
11:02:11 <Speuler> assuming there's a "0" on return stack
11:02:29 <Robert> There is.
11:02:36 <XeF4> speu: there always is because cs:0100 is CALLed by the program loader
11:02:43 <Speuler> not if i set it up differently
11:03:18 <XeF4> if you set it up differently it isn't a .com loader anymore
11:03:23 <Speuler> for example, pointing to some mem at SS: behind CS
11:04:06 <Speuler> com file is just a binary image, woth offset $0100. it receives control at first byte, and i can set up segments as i wish, it is still a com
11:04:52 <Speuler> you mean, if the exe loader does the setup, it is not a com, with that you're right
11:04:57 <XeF4> no, you can't
11:05:11 <Speuler> but nothing prevents code in the com to do that
11:05:19 <Speuler> sure i can. i did so
11:05:19 <I440r-wrk> anyone here knnow jim shcneiders email ( i think i spelt his name rite :)
11:05:21 <XeF4> I can also interpret the fields of an ELF binary however I please, but there are only certain ways I can interpret them if I want to call my loader an ELF loader
11:05:38 <Speuler> i made multi-segmented coms alright.
11:05:51 <XeF4> Speuler: nothing prevents the code in the com from doing that, but it is obvious the com doesn't do that so there is no need
11:07:38 <Speuler> ??
11:07:45 <Speuler> the programmer decides what the need is
11:07:48 <Speuler> not the com
11:07:55 <Speuler> the com is the result of the programmers work
11:08:01 <XeF4> my point is:
11:08:08 <XeF4> the loader may not just set up the stack however it pleases.
11:08:17 <Speuler> "microsoft doesn't fix its bugs so there is no need" :)
11:08:35 <Speuler> what is "the loader" ?
11:08:38 <XeF4> the programmer knows the com does not do that because that code occurs before any such changes
11:08:42 <XeF4> qed
11:08:51 <XeF4> Speuler: the DOS executable loader
11:09:06 <Speuler> the com loader just places the image in mem, and starts it
11:09:29 <Speuler> and when the binary says "exit", control goes back to dos
11:09:35 <Speuler> in between, it is the program
11:09:40 <XeF4> the com loader places the image in mem, calls it, then returns control to the OS
11:09:46 <Speuler> and the program may set up segments as it likes
11:09:52 <Speuler> no.
11:10:01 <Speuler> the program returns control
11:10:05 <Speuler> by calling a dos function
11:10:14 <XeF4> you are an idiot
11:10:28 <Speuler> you may mixup the exe and the com loader
11:10:40 <XeF4> from where are you pulling these dos specs?
11:11:00 <Speuler> have you ever seen DOS :)
11:11:01 <XeF4> indeed, exes must call a dos function to return control
11:11:12 <Speuler> AH =4c
11:11:17 <Speuler> AL=exit code
11:11:17 <XeF4> a few times yes
11:11:36 <XeF4> that is permissible, but not the only way
11:11:49 <I440r-wrk> int 20 is an old way too
11:11:53 <I440r-wrk> but frowned upon
11:12:01 <Speuler> all of those mentioned earlier already
11:12:11 <Speuler> but int20 requires CS=DS=SS
11:12:26 <I440r-wrk> you can also just 'ret' but that usually takes you to an 'int 20' contained within the psp
11:12:26 <Speuler> 4cxx, int21, works with CS <> DS <> SS
11:12:47 <XeF4> it is of course strongly recommended to call a dos function to return control because if the program as left junk on the stack, there is no other way
11:12:54 <Speuler>  /ignore XeF4
11:12:59 <XeF4> but in this case it is trivial to prove the program has not left anything on the stack
11:13:00 <Speuler> for calling me idiot
11:18:43 <XeF4> ok then you're not an idiot,but you have some compulsion to jump through hoops even in cases where they obviously they don't apply
11:19:28 <XeF4> have you considered working for the EU agricultural board? they need people like you.
11:22:40 <arke> heh
11:23:32 <arke> hrm ... how would one make a screensaver for DOS?
11:24:11 <XeF4> hook keyboard and timer interrupts, start screensaving when no keyboard interrupt has happened for n timer interrupts
11:24:25 * arke browses int 0x21
11:25:05 <XeF4> best to browse an irq<->int table
11:25:08 <XeF4> and hook those
11:25:30 <XeF4> irq0=int8=timer irq1=int9=kbd normally afaik
11:26:31 <Speuler> arke, interface with timer interrupt for inactivity time, keyboard interrupt, for kicking the timer,
11:27:12 <Speuler> save screen somewhere and draw your niceties
11:28:09 <I440r-wrk> mov ah, 3
11:28:11 <I440r-wrk> into 010
11:28:18 <I440r-wrk> then wait for someone to hit a key
11:28:20 <I440r-wrk> :)
11:28:32 <I440r-wrk> int 0x10 even
11:28:56 <arke> seems easy...
11:29:09 <arke> hm bah.
11:29:14 <arke> i should be working on forth
11:29:17 <arke> :P
11:29:21 <Speuler> there's not much int int21 to help you
11:30:30 <XeF4> arke: it's basically easy except that other programs try to set the vga registers and draw to the screen etc
11:30:32 <I440r-wrk> theres another way, dont need to save screen - dos has video pages
11:30:39 <I440r-wrk> just switch video page and revert when done
11:31:12 <I440r-wrk> on a vga all the crtc registers etc are +rw - you can save the vga's state easilly
11:31:19 <Speuler> arke, i still have tsr-stuff for cforth aka 4thcmp, to easily generate tsrs
11:31:22 <I440r-wrk> on an ega some are ro or wo
11:31:49 <Speuler> but i figure no need for a forth prog as screen saver :)
11:31:50 <XeF4> and on svga it's impossible to know what you should save
11:32:19 <arke> hmm ... how do tsr's work?
11:32:37 <Speuler> terminate and stay resident. an exit without releasing the mem
11:32:52 <Speuler> if an interrupt handler points into the code, it can gain control
11:33:27 <Speuler> s/interrup handler/ interrupt vector/
11:33:44 <Speuler> the handler is in your resident code
11:33:56 <arke> ooh :)
11:33:57 <arke> so
11:34:38 <arke> i could make a proggie which filters BIOS screen calls by saving the address at 0x10 (for later use), then replacing it with my own!
11:35:00 <Speuler> i suppose so
11:35:21 <XeF4> you could yes
11:35:40 <XeF4> far pointer at 0000:0040
11:35:56 <Speuler> indeed, for a bios emulator (pc bios) for a non-pc-compatible machine, i did something similar
11:36:30 <Speuler> sirius, has its video ram at iirc E0000
11:36:46 <Speuler> differently organized too
11:37:11 <Speuler> been using compiled forth for it
11:40:27 <arke> hrm .... recursive calls arent possible in forth ....
11:40:42 <Speuler> eh ?
11:40:53 <Speuler> who told you that ?
11:41:03 <Speuler> probably XeF4 ...
11:41:17 <arke> well, they seem not possible in gforth
11:41:41 <arke> : cheese cheese ;
11:41:41 <arke> *the terminal*:1: Undefined word
11:41:41 <arke> : cheese cheese ;
11:41:41 <arke>          ^^^^^^
11:41:42 <arke> Backtrace:
11:41:44 <arke> $F84DCC throw
11:41:46 <arke> $F907F0 no.extensions
11:42:20 <XeF4> arke: because cheese is not defined until ; puts it in the dictionary.  use RECURSE instead
11:42:26 <Speuler> : xxx dup if 1- dup . recurse then ;
11:43:16 <arke> hm ok
11:43:19 <arke> also
11:43:36 <arke> what if i have blah and foo, and foo calls blah and blah calls foo, how would i do that?
11:44:08 <Speuler> one would be a forward ref
11:44:23 <Speuler> you'd call a word which hasn't been defined yet
11:44:29 <XeF4> arke: defer
11:44:34 <Speuler> fwd refs are not standard in forth
11:44:47 <Speuler> you could use defer for the same effect
11:44:56 <XeF4> arke: but most forths are not smart enough to optimize out the mutual recursion and the stack overflows quite easily
11:45:13 <arke> mine will be!!!
11:45:15 <arke> :)
11:45:36 <Speuler> your will what ?
11:45:55 <arke> : foo ....... recurse ;  --> call foo; ret --> jmp foo
11:46:53 <XeF4> arke: you support something more elaborate than tail-call elimination?
11:50:29 <arke> if ... recurse else ... then ;
11:50:38 <arke> also tail call
11:54:35 --- part: Speuler left #forth
12:20:59 --- join: SDO (~SDO@co-trinidad1a-42.clspco.adelphia.net) joined #forth
13:01:19 --- quit: XeF4 (Read error: 110 (Connection timed out))
14:01:11 --- join: proteusguy (~username@sgi.scigames.com) joined #forth
14:11:45 <Robert> Hi!
14:11:49 <Robert> Long time no see
14:20:18 --- quit: Grant1 (Read error: 110 (Connection timed out))
14:24:36 --- join: gilbertbsd (~gilbert@fl-nked-ubr2-c3a-37.miamfl.adelphia.net) joined #forth
14:25:34 <gilbertbsd> arke what started out as a prank?
14:47:03 --- join: gilbertplan9 (~gilbert@fl-nked-ubr2-c3a-37.miamfl.adelphia.net) joined #forth
14:47:27 --- part: gilbertplan9 left #forth
14:57:28 --- join: conjure1 (~oak3120@gambit.instruct.langara.bc.ca) joined #forth
14:57:34 <conjure1> hey, anyone around?
14:59:20 <Robert> Yep.
15:03:53 --- quit: gilbertbsd (Read error: 110 (Connection timed out))
15:04:52 <conjure1> could you recommend me a good place for beginning forth?
15:04:59 <conjure1> of your personal opinion.
15:05:27 <Robert> Hmm...
15:05:34 <Robert> To be quite honest - here. :)
15:06:08 <Robert> The best way to learn, and UNDERSTAND Forth, in my opinion, is to write your own Forth system.
15:06:20 <Robert> Check my programming links at http://robert.zizi.org/
15:06:37 <Robert> There you can find "Moving Forth", a great document about how Forth works.
15:06:44 <Robert> And "Build your own forth", also nice.
15:06:57 <conjure1> wicked.
15:07:02 <Robert> What?
15:07:09 <conjure1> your help :)
15:07:16 <Robert> Heh.
15:07:44 <Robert> I was learning Forth by asking people in here... I also used the pForth tutorial (google for it) as a reference while learning.
15:07:52 <Robert> So I can't recommend any books or so.
15:08:20 <Robert> But understanding Forth, how it works, is pretty important.
15:09:06 <conjure1> yeah.
15:09:15 <conjure1> and I can just learn that from online documents?
15:11:15 <I440r-wrk> not entirely, but thats why theres #forth :)
15:12:00 <Robert> Yeah.
15:12:12 <Robert> But there are Forth tutorials
15:12:19 <Robert> Just google and find one that you like.
15:12:34 <Robert> If there's something you don't understand...well, like I440r-wrk said, that's what #forth is for.
15:13:26 <conjure1> what's a good compiler from *nix?
15:13:35 <I440r-wrk> isforth :)
15:13:39 <I440r-wrk> *snicker*
15:13:43 <I440r-wrk> do you code assembler ?
15:14:08 <conjure1> a bit
15:14:11 <I440r-wrk> ok
15:14:16 <conjure1> I'm getting into it more though.
15:14:16 <I440r-wrk> thats always a plus
15:14:28 <conjure1> ok, here's my question.
15:14:34 --- join: kc5tja (~kc5tja@66-91-231-74.san.rr.com) joined #forth
15:14:35 --- mode: ChanServ set +o kc5tja
15:14:53 <conjure1> would fourth cohere with my c and asm knowledge or hinder it?
15:15:00 <I440r-wrk> kc5 do you know the guy that wrote the win32forth assembler ?
15:15:12 <I440r-wrk> im trying to contact him but all the emails i found of his bounce
15:15:13 <kc5tja> No.
15:15:38 <kc5tja> conjure1: Depends on how you approach it.
15:15:52 <kc5tja> I440r-wrk: He's on clf though.
15:16:06 * kc5tja is pretty sure.
15:16:25 <Robert> conjure1: If you understand assembly language, you'll understand everything about Forth. Might be harder otherwise.
15:16:32 <I440r-wrk> he was there a while back but then stopped but came back and posted once or twice and.....
15:16:39 <I440r-wrk> he is a slippery kinda guy :)
15:16:40 <Robert> conjure1: But Forth is pretty different from both those languages.
15:16:58 <Robert> conjure1: For example, you usually don't factor your code very well in assembly language.
15:17:07 <conjure1> yeah
15:17:10 <I440r-wrk> i do
15:17:18 <kc5tja> OK, this is weird.  KSirc has a bug in it, I think.
15:17:21 <conjure1> so, if I'm learning asm concurently with fourth do you think I'll have a problem?
15:17:27 <conjure1> or will it just confuse both matters.
15:17:36 <kc5tja> I switch to a different channel tab, and type "/clear", and it always clears #Forth's channel, no matter what.
15:17:40 <kc5tja> Gahh... :/
15:17:45 <Robert> conjure1: Nah, if you're smart you'll be OK.
15:17:46 <kc5tja> So I lost a lot of context
15:17:48 <I440r-wrk> no - thats not a problem
15:18:24 <Robert> conjure1: The extensibility of Forth is also much larger than in C/asm.
15:18:53 <kc5tja> conjure1: A great way to learn assembly language and Forth together is to actually write a Forth in assembly language, from ground zero.
15:19:08 <conjure1> hmm...
15:19:13 <conjure1> that sounds like a good idea
15:19:31 <Robert> Exactly what I suggested earlier ;)
15:19:35 <kc5tja> This is one of the reasons why there are literally so many Forth environments available.
15:19:39 <Robert> That's how I learnt.
15:19:46 <kc5tja> Likewise. 
15:20:02 <kc5tja> Except now I'm dusting off my old work, and integrating some newer ideas, and writing my next generation FS/Forth for Linux.
15:20:26 <kc5tja> (speaking of which, I need to install gforth on this Linux installation so that I can run the target compiler)
15:20:55 <conjure1> so, what exactly are the benefits of fourth?
15:21:05 <conjure1> I mean, I'm somewhat confused on that part.
15:21:11 <I440r-wrk> when you've seen one forth, you've seen ONE forth heh
15:21:30 <I440r-wrk> speed of development, size of executable
15:21:44 <I440r-wrk> and.  ITS FUN!!!!
15:21:45 <I440r-wrk> c isnt
15:22:04 <Robert> I440r-wrk: It can be made very small and very large.
15:22:05 <Robert> er
15:22:09 <Robert> conjure1: It can be made very small and very large.
15:22:12 <kc5tja> conjure1: Forth's claim to fame is that it is a truely integrated, wholesome environment.
15:22:25 <kc5tja> The operating system's calling conventions are the same as a subroutine's calling conventions.
15:22:38 <kc5tja> Likewise, the command-line shell happens to be the programming language itself.
15:22:38 <Robert> conjure1: Everything from a 4kB complete environment, with interpreter, compiler and editor, to large systems with lots of extra functions.
15:22:54 <kc5tja> It can do this because it exploits, rather than hides, how the computer actually works.
15:23:08 <conjure1> ah, ok.
15:23:54 <kc5tja> Therefore, as a programmer, if you can solve a problem using the computer itself, rather than some abstraction of the computer based on some conceptual model of it, then the resulting software is easier and smaller.  It might not be as fast, but it is often fast enough.
15:24:21 <kc5tja> (Besides, it's poor practice to prematurely optimize anyway -- a great way to infest your code with bugs is to prematurely optimize)
15:25:02 <conjure1> true.
15:25:03 <Robert> On stack CPUs, Forth can be very fast.
15:25:09 <kc5tja> I440r-wrk mentioned that programming in Forth is fun.  This is true if you enjoy programming in general.  One of the reasons is that, like a sports car, as soon as you tell the machine to do something, the effect is immediate.
15:25:15 <Robert> But x86 and many other processors aren't designed for Forth.
15:25:20 <kc5tja> Robert: On stack CPUs, Forth is the fastest language possible.
15:25:26 <Robert> Exactly.
15:25:30 <conjure1> well, I find programming fun.
15:25:34 * kc5tja does too.
15:25:37 * Robert too.
15:25:42 <Robert> Suprisingly enough ;)
15:25:47 <conjure1> :D
15:25:52 <conjure1> anyways, I've gotta run to class.
15:26:02 <conjure1> I'll be on later today though.
15:26:07 <conjure1> set up a screen or something :D
15:26:16 <kc5tja> After I finish FS/Forth for Linux, I'm intending to continue to write a version of FS/Forth that runs on raw PC hardware; no underlying OS needed.
15:26:33 <conjure1> I should try writing fourth for my sparc :)
15:26:38 <Robert> See you.
15:26:47 <conjure1> I'm getting a bit ahead of myself, but that'd be really cool.
15:26:54 <kc5tja> That'd be fun, I think.
15:26:55 <conjure1> sparc64 is a wicked processor in my opinion.
15:27:01 <Robert> kc5tja: FS/Forth, what kind of Forth is that? Colored, ANS, F83, own inventions?
15:27:05 <conjure1> much better than the x86
15:27:38 <Robert> Never used any large CPU other than x86 :(
15:27:42 <kc5tja> Robert: It's a traditional ASCII-source-type MachineForth inspired variation of PygmyForth for x86.
15:27:44 <Robert> Just microcontrollers.
15:27:49 <conjure1> ok, I'm gone.
15:27:51 <Robert> Bye.
15:27:59 <kc5tja> bye conjure1
15:28:00 <Robert> kc5tja: OK, nice :)
15:28:07 <Robert> kc5tja: What language do you code it in?
15:28:13 <conjure1> later guys, thanks again, although I'm sure I'll be thanking you more :)
15:28:32 <kc5tja> Currently, I'm writing an FS/Forth target compiler in GForth (PygmyForth for the unsupported DOS version).
15:28:36 --- quit: conjure1 ("conjure1 has no reason")
15:29:05 <kc5tja> After that, I'll proceed to write FS/Forth in the target compiler's dialect of FS/Forth.
15:29:33 <Robert> Oh. So it will eventually be self-compiling?
15:30:06 <kc5tja> That's the intent, yes.
15:30:21 <kc5tja> I've never written a target-compiled Forth before, so this is my second time at it.
15:30:41 <Robert> "target-compiled", what exactly does that mean?
15:30:43 <kc5tja> I'm just trying it.  I could have just written it in NASM, and I probably would have finished it by now if I had.  Target compilers aren't hard to write, just time consuming.
15:31:06 <kc5tja> A C compiler is a target compiler -- it takes abstract C source code and compiles it for a "target processor."
15:31:13 <kc5tja> In most cases, it happens to be the same CPU that you're running it on.
15:31:16 <kc5tja> But it doesn't have to be.
15:31:57 <kc5tja> But since C isn't interactive, it's usually quite redundent to call all C compilers target compilers -- only those that target different CPUs than the host CPU.
15:32:10 <Robert> Oh.
15:32:13 <kc5tja> In Forth, it's a little bit different; the normal compiler is interactive, run from within the Forth environment itself.
15:32:32 <kc5tja> Hence, it by default targets the host CPU.  It has to, or else the system would crash.  :)
15:32:34 <Robert> Then I wrote one of those in IsForth, to compile my Forth for the AVR VM.
15:32:37 <Robert> Worked fine.
15:33:02 <Robert> In not that many hours, I was able to write a Forth compiler in Forth, and write a Forth system for it.
15:33:07 <kc5tja> However, running the compiler outside of the interpreter of Forth as a separate program enables the possibility of targeting different CPUs; hence, it's a target compiler.
15:33:35 <kc5tja> Well, I have to admit that if I spent 8 hours a day on it, the target compiler would take maybe two or three days.
15:33:53 * kc5tja is already almost to the point of supporting colon definitions in his target compiler, and it's only 4 or 5 screens long.  :)
15:33:54 <Robert> Not very much.
15:34:00 <kc5tja> (well, 10 if you count shadow blocks)
15:34:05 <Robert> I mean, imagine a C++ compiler ;)
15:34:23 <kc5tja> But it's taking me a long time because I have many other, higher priority projects on my plate at the moment.
15:34:49 --- quit: proteusguy ("Client Exiting")
15:35:40 <Robert> The entire interactive Forth system for the microcontroller is less than 600 lines of Forth code.
15:35:43 <kc5tja> I just finished moving all my stuff into a smaller room at the house, so I'm going to be relaxing for most of today.  But then I have to get busy on my homework.
15:35:57 <kc5tja> My Forth is a little bit more complex than your Forth, I think.  :)
15:36:13 * kc5tja needs to implement BLOCK, UPDATE, FLUSH, and friends, so that I can have some kind of I/O.
15:36:30 <Robert> And the cross-compiles less than 300 lines, exclusing data tables.
15:36:31 <Robert> Well, sure.
15:36:43 <Robert> But mine is still working fine.
15:36:44 <kc5tja> Then I need to implement the dynamic library support, so I can invoke arbitrary functions in popular libraries.
15:37:05 <Robert> Just wanted to say that it's very simple, but still working fine.
15:37:10 <kc5tja> And unlike GForth, my system will be fully documented.
15:37:20 <kc5tja> Well, my system will also be quite simpe.
15:37:21 <kc5tja> simple even.
15:37:26 <Robert> Oh, right.. documentation.. ;)
15:37:29 <kc5tja> Just not as simple.  :)
15:37:57 <Robert> Doesn't have to be. You're making a good end product, I wasn't aiming for something like that ;)
15:38:54 <kc5tja> Yeah -- for my work in Linux, I'm looking for something that simultaneously can: 1) replace the shell as my primary Linux interface, and 2) allow me to write arbitrary Linux software (e.g., X11 software, console software, etc).
15:40:04 --- join: Grant_P (~pyromania@202.59.99.234) joined #forth
15:40:21 <kc5tja> Then, obviously, having completed my goal there, the next obvious goal is to replace Linux itself.  :D
15:42:00 <Robert> Haha!
15:42:22 <Robert> That'll take more than 4 days, I think.
15:42:52 <Robert> But it would be impressive if you did, so that you can prove for the world that bloatware isn't needed.
15:44:02 <kc5tja> Actually, no -- replacing Linux with a bootable software image is actually rather fast.
15:44:03 <kc5tja> :)
15:44:20 <kc5tja> Especially when you can compile the kernel in a few milliseconds.
15:44:37 <kc5tja> What will take the remainder of the time, I think, is writing the actual applications.
15:44:49 <Robert> And hardware support!
15:44:51 <kc5tja> (most of which can be at least designed and prototyped under the Linux version of FS/Forth)
15:45:14 <kc5tja> Portability is a myth; support your own damn hardware.  :D  (Folks who port ColorForth have to after all!)
15:45:18 <kc5tja> Actually, I was thinking about that problem.
15:45:25 <kc5tja> I believe I have at least a partial solution.
15:46:16 <kc5tja> Basically, if someone were to download the software from a website, the website could build the desired Forth image because it has the relavent block source for each device you aim to support.
15:47:52 <kc5tja> Hmm
15:48:12 <kc5tja> Robert: Can you post something?  I am trying to see what this "Follow" thing does in KSirc.
15:49:00 <Robert> Uhm.
15:49:11 <Robert> Post what?
15:49:17 <kc5tja> Just responding to my question was enough.
15:49:18 <Robert> Just messages like these?
15:49:20 <Robert> OK. 
15:49:21 <kc5tja> It didn't do anything.
15:49:28 <kc5tja> I wonder what it means...
15:49:33 <kc5tja> Time to RTFM I think...
15:50:08 <Robert> Interesting idea about the website.
16:07:13 --- join: Grant1 (~pyromania@202.59.99.234) joined #forth
16:08:47 <arke> greetings and salutations.
16:12:53 <kc5tja> testing 1 2 3
16:13:03 <kc5tja> testing 1 2 3 (again)
16:13:22 <kc5tja> OK, this is most annoying.
16:13:57 * kc5tja switches to XChat...  KSirc is nice, but XChat is nicer.  :D
16:14:16 --- quit: kc5tja ("THX QSO ES 73 DE KC5TJA/6 CL ES QRT AR SK")
16:15:45 --- quit: Grant_P (Read error: 60 (Operation timed out))
16:18:39 --- join: kc5tja (~kc5tja@66-91-231-74.san.rr.com) joined #forth
16:18:40 --- mode: ChanServ set +o kc5tja
16:22:28 <Robert> I like irssi, best console client I've tried.
16:22:46 <Robert> And since I'm often IRCing from school, a console client is needed.
16:25:25 * kc5tja prefers to IRC in X11 because I can switch between multiple channels very easily.
16:25:51 <kc5tja> Doing that with a console client is very annoying.
16:26:01 --- part: kc5tja left #forth
16:26:05 --- join: kc5tja (~kc5tja@66-91-231-74.san.rr.com) joined #forth
16:26:06 --- mode: ChanServ set +o kc5tja
16:26:14 <kc5tja> Sorry.
16:26:22 <kc5tja> X-Chat's new keyboard shortcuts are really, really annoying.
16:38:32 --- quit: Grant1 (Excess Flood)
16:39:20 --- join: Grant_P (~pyromania@202.59.99.234) joined #forth
16:43:01 * kc5tja is away: foodage
16:49:47 * kc5tja is back (gone 00:06:46)
17:18:54 <ianP> i tried xchat for a second and i think i prefer epic
17:46:18 <arke> ive never tried epic...
17:53:34 --- join: I440r (~I440r@sdn-ap-009txhousP0277.dialsprint.net) joined #forth
18:25:22 <ianP> it's ircii with good scripting support
18:27:19 <arke> :)
18:45:35 * kc5tja is away: I'm busy.
18:45:36 * kc5tja is back (gone 00:00:01)
18:46:08 <kc5tja> back
18:46:24 * kc5tja thought he already had his away flag set, but I guess I didn't.
18:46:44 <kc5tja> brb
18:46:46 --- quit: kc5tja ("THX QSO ES 73 DE KC5TJA/6 CL ES QRT AR SK")
18:47:14 --- join: kc5tja (~kc5tja@66-91-231-74.san.rr.com) joined #forth
18:47:15 --- mode: ChanServ set +o kc5tja
19:04:20 <kc5tja> TeStInG
19:08:45 <I440r> ?
19:08:49 <I440r> testing what ?
19:08:50 <I440r> h3eh]
19:08:58 <kc5tja> Just fooling around with my IRC client a bit.
19:09:55 <I440r> aha ok :)
19:18:16 --- join: Sonarman (~matt@adsl-64-160-164-57.dsl.snfc21.pacbell.net) joined #forth
19:54:45 <kc5tja> Shoot.  Today is a waste.  :/
19:54:58 <kc5tja> I wanted to get some work done on FS/Forth.  But I don't have enough time.  Have to do homework.
20:10:54 --- join: LOOP-HOG (TofuMonste@207.191.240.26) joined #forth
20:11:30 <LOOP-HOG> forth didnt start out as a prank did it?
20:11:44 <I440r> lol no
20:11:52 <I440r> but it ended up that way "_
20:11:53 <I440r> :)
20:12:28 <LOOP-HOG> i suppose if it amused you :/
20:12:43 <I440r> forth unlike c DOES amuse me
20:12:49 <I440r> io have a great deal of fun coding it
20:12:56 <LOOP-HOG> thats good
20:13:02 <I440r> do you know forth at all ?
20:13:06 <LOOP-HOG> yes
20:13:11 <I440r> or have you just looked at some sourcese ?
20:13:12 <LOOP-HOG> count type
20:13:15 <I440r> oh so you code forth ?
20:13:17 <I440r> well cool :)
20:13:27 <I440r> and you dont like it ?
20:13:30 <LOOP-HOG> yes
20:13:35 <kc5tja> Forth is not, nor will ever be, a prank.
20:13:43 <kc5tja> It is, however, a much needed slap in the face of established convention.
20:13:56 <LOOP-HOG> oh i see what you mean
20:14:34 <I440r> LOOP-HOG where are you from ?
20:14:43 <LOOP-HOG> Portland, Oregon
20:15:00 <I440r> are you a forth beginner or expert ?
20:15:16 <LOOP-HOG> I'm an amature programmer
20:15:23 <LOOP-HOG> I feel like Forth is my native programming language
20:15:32 <LOOP-HOG> I can write like 2500 line programs ok
20:15:41 <I440r> cool "_
20:15:46 <LOOP-HOG> but i don't think that makes me an expert programmer in the grand scheme of things
20:15:51 <I440r> argh i cant type smileys!
20:15:53 <I440r> lol
20:15:58 <I440r> what forth do u use ?
20:16:19 <LOOP-HOG> i wrote a game a long time ago
20:16:33 <LOOP-HOG> lately i wrote an invoicing program
20:16:45 <LOOP-HOG> just to see if i could do it
20:17:02 <LOOP-HOG> I have scripted my website using Forth
20:17:06 <I440r> using what forth ?
20:17:18 <LOOP-HOG> right now i'm using SwiftForth
20:17:26 <I440r> you regged it ?
20:17:31 <LOOP-HOG> i wrote my game using ForthMacs for the Atari ST
20:17:32 <I440r> im using it at work, never used ti before
20:17:35 <I440r> i hate it
20:17:39 <LOOP-HOG> why?
20:17:45 <I440r> because its ans
20:17:51 <LOOP-HOG> so
20:18:03 <I440r> because its one HUGE convoluted BAD solution to the "target compiler" problem
20:18:19 <LOOP-HOG> i don't get into compiler details
20:18:30 <LOOP-HOG> it is optimising, so i already know its above my head
20:18:43 <I440r> well swiftx is an umbilical compiler too
20:18:48 <I440r> thats another thing i HATE
20:18:54 <I440r> its NOT a forth compiler
20:18:55 <LOOP-HOG> SEE isn't very useful, you have to use LOCATE and WHERE
20:19:00 <I440r> there are no colon definitions what so ever
20:19:12 <I440r> yea see is useless
20:19:41 <LOOP-HOG> what are you doing with it?
20:19:49 <I440r> satelite tracking software
20:19:54 <LOOP-HOG> cool
20:20:08 <LOOP-HOG> so people can watch satelite tv?
20:20:27 <I440r> lol this is used to track ANY satelites
20:20:38 <I440r> the huge astronomical ones
20:20:40 <LOOP-HOG> so they don't bumb into each other :^) ???
20:20:42 <I440r> the military communication ones
20:20:44 <kc5tja> LOOP-HOG: Although not written in Forth, there exists satellite tracking software for amateur radio satellites too.
20:21:18 --- part: kc5tja left #forth
20:21:21 --- join: kc5tja (~kc5tja@66-91-231-74.san.rr.com) joined #forth
20:21:22 --- mode: ChanServ set +o kc5tja
20:21:35 <kc5tja> OK, that sucked.  I *MUST* change the default key bindings on this program.
20:21:46 <I440r> kc this is slightly more complex, when you have a 200 foot dish it becomes very difficult to remain aimed at the satelite and from the dishes point of view that geo stationary object is scribing a figure of 8 up there :)
20:22:08 <LOOP-HOG> orbital mechanics
20:22:18 <kc5tja> I440r: It's not at all more complex.  In fact, you have it easy.
20:22:20 <I440r> which i dont understand heh
20:22:24 <LOOP-HOG> you get to play with some big equipment
20:22:43 <I440r> actually, i dont - i just get to play with the equipment that does so heh
20:22:55 <LOOP-HOG> ok
20:23:40 <kc5tja> I440r: Remember, amateur satellites are about the size of Sputnik (e.g., if you're a few degrees off, you DON'T see it), travel *FAST* through the sky (LEOs usually), and have HIGHLY eccentric orbits (Phase-3D, last I recalled, went out 1/4 the way to the moon at its farthest point, and in as close as LEOs at its nearest point)
20:24:08 <LOOP-HOG> was that a mistake, its orbit?
20:24:12 <LOOP-HOG> that's pretty eccentric
20:24:23 <I440r> kc5 with a large dish if you are a few SECONDS off you dont see it
20:24:31 <I440r> dont ask me why
20:25:26 <kc5tja> I440r: That must be a very long focal length dish then.  As in, VERY long.  As in, longer than any radio astronomy dish, let alone commercial broadcast dish.
20:25:38 <kc5tja> A few degrees is usually what most dishes are at beam-width wise.
20:25:55 <I440r> even with commercial broadcast dishes, th elargetr the dish the more accurate you ahve to be
20:26:19 <kc5tja> I know all that.
20:26:22 <I440r> they have some very clever tracking software including knowing how the thing tracked previously and predicting where its going to go
20:26:24 <kc5tja> I deal with optics, remember?  :)
20:26:30 <I440r> heh
20:26:31 <kc5tja> The larger the collecting surface, the greater the resolution.
20:26:54 <kc5tja> But if you have a "fast" dish, you don't need the positional accuracy.
20:27:00 <kc5tja> (e.g., a dish with a short focal length)
20:28:08 <kc5tja> LOOP-HOG: No, it is eccentric by design.
20:28:29 <LOOP-HOG> what does it do?
20:28:31 <I440r> the satelite doesnt actually move in a figure of 8
20:28:37 <I440r> it just LOOKS like it does to the dish
20:28:45 <LOOP-HOG> I know that it just seems that way because of orbital mechanics
20:28:48 <I440r> again, dont ask me to explain it :)
20:29:00 <ianP> LEO=?
20:29:17 --- quit: njd ("Leaving")
20:29:25 <kc5tja> LOOP-HOG: It's a voice repeater on several amateur bands, digipeater, BBS, and more.
20:29:28 <ianP> got it
20:29:30 <kc5tja> ianP: Low Earth Orbit
20:29:47 <I440r> low, high, you name it - we track it
20:29:52 <I440r> we even have software to do star tracking
20:29:54 --- join: njd (~melons@njd.paradise.net.nz) joined #forth
20:29:54 <LOOP-HOG> nobody uses BBSes any more do they?
20:30:31 <LOOP-HOG> i still dont see why it would need to go all of the way out there if all its doing is bouncing amature radio waves off if it
20:31:10 <kc5tja> LOOP-HOG: Radio BBSes are still in use.
20:31:20 <LOOP-HOG> hmmm
20:31:47 <kc5tja> LOOP-HOG: It goes that far out for the simple reason of visibility.  The further out it is, the more people can see/use it for longer (it travels through the sky at a slower rate)
20:32:00 <LOOP-HOG> oh i see
20:32:26 <LOOP-HOG> any thoughts on the x-prise
20:32:27 <kc5tja> LOOP-HOG: Most amateur satellites, in contrast, are usable only for about 5 minutes as they go across the sky from horizon to horizon.
20:32:51 <LOOP-HOG> some hobby that restricts you to 5min at a shot :^)
20:33:04 <I440r> the goal is unrealistic
20:33:05 <kc5tja> LOOP-HOG: There's more to amateur radio than just satellites.
20:33:11 <I440r> not only do they have to go up and come back safely
20:33:16 <I440r> they have to do it again 3 weeks later
20:33:19 <I440r> BULLSHIT
20:33:41 <kc5tja> I do not believe that it is "bullshit."
20:33:47 <kc5tja> We're almost there as it is.
20:33:51 <LOOP-HOG> i was thinking that the ony two teams that had even a small chance were Scaled and Starchaser
20:34:01 <LOOP-HOG> Not Armiadillo
20:34:37 <LOOP-HOG> I don't think that Scaled are using computers onboard, so i would feel safest in that 
20:34:45 <LOOP-HOG> Armadillo is software
20:34:53 <LOOP-HOG> I would never go up in that
20:35:10 <LOOP-HOG> Starchaser I don't know but they have actually put hardware up into the sky
20:35:40 <I440r> :)
20:35:48 <I440r> fly that software :)
20:35:56 <kc5tja> Anyway, I need to get some homework done.'
20:36:00 <LOOP-HOG> ok
20:36:03 <arke> y0
20:36:07 <kc5tja> So, thanks for the chats.  :)
20:37:48 <LOOP-HOG> I'd like to be able to go up into space for a sub orbital hop but even at like $25k it would be kind of a lot for me
20:38:01 <LOOP-HOG> i don't know how much it will be 
20:38:51 <I440r> it would be fun tho :)
20:39:14 <ianP> just to go fly high in the amtopshere?
20:39:30 <LOOP-HOG> I know that Forth is good at creating very reliable software, i would maybe go up if there were computers onboard if they were programmed in Forth using the classic style
20:39:40 <LOOP-HOG> To go up like 60 miles
20:39:47 <LOOP-HOG> it would be wild
20:39:52 <I440r> define 'classic style' ?
20:39:56 <I440r> "not ans" ?
20:40:05 <LOOP-HOG> write small words and then test each small word as you go
20:40:10 <LOOP-HOG> iterative approach
20:40:17 <I440r> right
20:40:22 <I440r> thats teh only real way to code forth
20:40:28 <I440r> no need for any fancy shmancy debugger
20:40:39 <LOOP-HOG> i don't use DEBUG 
20:40:42 <I440r> <-- writing a debugger for his forth :/
20:40:43 <I440r> lol
20:41:26 <I440r> so how did you discover #forth ?
20:41:31 <kc5tja> For the record, after starting the programming practice of XP, and exercising test-first-by-intention, I've had to use a debugger only twice in the last two years of my coding career.
20:41:31 <LOOP-HOG> atleast they answer your questions on the SwiftForth mail list, even my stupid ones
20:41:36 <I440r> and are u gona be regular here now ? :)
20:41:37 <kc5tja> Regardless of language
20:42:08 <I440r> kc5 but we all knew already that ytou were a real coder
20:42:15 <I440r> not some drag and dro[p script kiddie
20:42:20 <I440r> using msvc++ :/
20:42:26 <LOOP-HOG> cut and paste coding is pastey
20:42:44 <LOOP-HOG> I will try to come here more often
20:43:04 <kc5tja> Actually, I do use MSVC++.  :D  But I don't use the wizards -- I hand code everything.
20:43:19 <LOOP-HOG> I heard about Forth a long time ago when i was a kid reading a video game magazine
20:43:24 <kc5tja> That's the other nice thing about Forth -- it's the great equalizer between platforms.
20:43:50 <I440r> loop cool :)
20:44:07 <kc5tja> It doesn't matter if I'm coding for FS/Forth under x86 or my future Forth for 65816, or your Atari ST forth, for my Amiga's JForth -- 90% of the code is portable regardless of where it's run.  The other 10% is easily handled by just spending some time writing a small compatibility layer for each platform.
20:44:10 <LOOP-HOG> I don't remember how i discovered #forth, i just happen to have a link to it
20:44:48 <LOOP-HOG> I have an old book with FIG forth in it and i can read it
20:44:54 <LOOP-HOG> try that with 30 year old BASIC even
20:45:08 <kc5tja> No kidding.
20:45:14 <LOOP-HOG> compare ATARI BASIC against the latest Visual Basic
20:47:51 <I440r> compare COMMODORE 64 basic against vb
20:48:14 <LOOP-HOG> I swear that VB is neither Visual nor is it Basic
20:48:19 <kc5tja> Or a better example: AmigaBASIC to Visual Basic
20:48:22 <I440r> or "lazer basic" another good basic for the c64
20:48:28 <I440r> oh yea
20:48:29 <I440r> drool!
20:48:30 <I440r> heh
20:48:37 <I440r> cept i always coded asm on my amiga
20:48:42 <kc5tja> AmigaBASIC owns.
20:48:43 * kc5tja nods
20:48:45 <I440r> i did mess with basic a lil tho
20:49:12 <kc5tja> But it's patently clear that Microsoft's AmigaBASIC gave birth to Visual Basic for Windows.  Same language structure, same syntax highlighting rules, and more.
20:49:18 <LOOP-HOG> I knew BASIC on the Atari 800XL, and i can say that FORTH kicks its butt
20:49:28 <kc5tja> The only difference is, VB ruins a lot of stuff that AmigaBasic got right.
20:49:47 <kc5tja> LOOP-HOG: Forth kicks a lot of language's butts.  It's not hard to beat BASIC.  :)
20:50:09 <LOOP-HOG> 20 GOTO 10  ( ugh)
20:50:46 <I440r> lol
20:51:21 <kc5tja> For FS/Forth: : hello ." Hello world!" hello ;
20:51:23 <kc5tja> ;)
20:51:43 <LOOP-HOG> recusion
20:51:53 <LOOP-HOG> but will the break button work?
20:51:57 <kc5tja> Tail-call recursion, so it's really a jump back to the beginning, not a call.
20:52:07 <I440r> you dont need to smudge/reveal first ?
20:52:12 <LOOP-HOG> thats the only think, but i hardly make my machine go into an infinate loop anymore
20:52:14 <I440r> thats bad dood!
20:52:14 <I440r> lol
20:52:39 <kc5tja> LOOP-HOG: My computer doesn't have a break button anyway, so no, it won't work.  :)
20:52:51 <kc5tja> LOOP-HOG: Not unless you install a custom keyboard interrupt handler or something.
20:52:59 <kc5tja> I440r: No, I do not bother with smudging.
20:53:09 <LOOP-HOG> There is a break button on the button bar of SwiftForth but I fail to see any use for it
20:53:24 <I440r> isforth doesnt need to smudge because the new word is hidden till reveal time
20:53:33 <I440r> i.e. its not in teh vocabulary thread yet
20:53:43 <kc5tja> LOOP-HOG: I've put SwiftForth into an infinite loop like that once (: hw begin ." hello " again ;), and I found that the break button does not break out of it.  :)
20:53:56 <LOOP-HOG> silly
20:54:02 <LOOP-HOG> so what's it good for?
20:54:12 <kc5tja> I440r: So, in other words, it's "smudged."  
20:54:14 <I440r> loop how much does swiftx cost ?
20:54:16 <kc5tja> LOOP-HOG: I don't know.
20:54:42 <I440r> smudging is clearing a "im hidden" bit 
20:54:55 <I440r> when the word is already chained to the vocabulary
20:54:57 <LOOP-HOG> i got it for like $270 on sale
20:55:02 <LOOP-HOG> its normally like $400
20:55:04 <I440r> cool
20:55:12 <I440r> you could hvae had isforth for free :)
20:55:14 <I440r> heh
20:55:28 <LOOP-HOG> does it work in Windows?
20:56:19 <I440r> no :/
20:56:28 <I440r> it doesnt even work in fbsd :P
20:56:43 <kc5tja> I440r: Smudging can be implemented that way.  Or it can be implemented in a list insertion/removal.  It doesn't matter how it's implemented.  What's important is that SMUDGE toggles the visibility status of the word (however it does it)
20:57:42 <I440r> heh i dont have a smudge word, i do have reveal tho - sounds like a better name to me too
20:57:53 --- join: Herkamire (~jason@h000094d30ba2.ne.client2.attbi.com) joined #forth
20:58:19 * kc5tja nods
20:58:20 <kc5tja> I agree.
20:58:31 <arke> kc5tja: greetings.
20:58:39 * kc5tja used to have REVEAL (which I got from PygmyForth) -- but I don't even use that anymore.
20:58:40 <LOOP-HOG> hi
20:58:41 <arke> kc5tja: i decided to use :; instead of ()
20:58:43 <kc5tja> arke: Howdy.
20:58:51 <arke> REVEAL????
20:58:54 <kc5tja> arke: You mentioned that already last time.  :)
20:58:56 <arke> is that like SEE???
20:58:58 <arke> oh :P
20:59:05 <I440r> no
20:59:06 <LOOP-HOG> PEEK?
20:59:13 <Herkamire> his this server been down for a few hours?
20:59:13 <I440r> when you type...
20:59:17 <kc5tja> arke: No -- REVEAL is a word which exposes the last created definition to the rest of the dictioanry.
20:59:18 <I440r> : foo blah blah
20:59:27 <kc5tja> Herkamire: Nope.  Not from my perspective.
20:59:31 <I440r> teh definition for foo itself is hidden, you cant make a word reference itself
20:59:43 <I440r> reveal "reveals" the hidden word
21:00:05 <I440r> actually you can make the word recursive but not by referencing its name
21:00:16 <Herkamire> my system clock got reset. and I just fixed that. maybe that was it.
21:00:31 <Herkamire> seems odd that would cause trouble with irc
21:02:02 <kc5tja> Herkamire: Hmm
21:02:24 <kc5tja> I440r: My original idea was to use the word AGAIN to form the loop: : hello ." Hello world! " again ;
21:03:07 <kc5tja> But then I realized that that just got in the way of things.  That's just "one more compiler word" to deal with, and I didn't feel up to explaining to people why I redefined AGAIN over its traditional meaning.
21:03:31 <I440r> erm. already spoken for, and a better solution that wont crash your stack too
21:03:41 <I440r> : hello begin ." hi" again ;
21:04:07 <LOOP-HOG> i just use BEGIN AGAIN
21:04:23 <kc5tja> I440r: You are forgetting that I am not using the standard control structures.  I'm taking my control structures from ColorForth.
21:04:26 <Herkamire> kc5tja: I'm currently a fan of tail recursion:   : hello ." Hello, world!" hello ;
21:04:57 <Herkamire> the down side is that you loose the ability to call the previous definition of the same word.
21:05:12 <kc5tja> However, in my original design, one could not refer to the currently defined word by name (it'd refer to a previous definition if one existed)
21:05:36 <I440r> herc you dont but its more difficult
21:05:40 <kc5tja> Herkamire: Yep.  
21:05:41 <I440r> : foo blah blah ;
21:05:43 <I440r> ' foo
21:05:53 <I440r> : foo [ , ] blah blah ;
21:06:06 <kc5tja> I440r: That patently will not work in a native code environment.
21:06:21 <I440r> ok,,,
21:06:24 <kc5tja> That will absolutely crash the system should foo be executed.
21:06:30 <kc5tja> A better solution is this:
21:06:31 <I440r> : foo literal execute blah blah ;
21:06:33 <I440r> heh
21:06:41 <kc5tja> : foo blah blah ;
21:06:43 <kc5tja> : foo1 foo ;
21:06:47 <kc5tja> : foo something else foo1 ;
21:07:09 <kc5tja> It doesn't take that much extra space, and incurs a small performance hit, but not much.
21:07:37 <kc5tja> That also assumes you call it only once.
21:07:44 <I440r> actually it would prolly be optimized out
21:07:46 <kc5tja> It's better to create a wrapper for any previous definitions you need.
21:08:00 <I440r> and compiling it as a literal and calling execute also takes up space
21:09:06 <kc5tja> Yes, but it relies on the state of the data stack being pristine at compile-time to work.  That is a bad assumption for FS/Forth in particular.
21:09:12 <kc5tja> (and many other Forths, like Pygmy)
21:09:16 <LOOP-HOG> ' key  :  key  literal execute  somehthing-else  ;
21:09:59 <I440r> well im a big fan of predictability
21:11:35 <kc5tja> I'm a big fan of a simple system.
21:11:56 <kc5tja> And it's quite predictable: the state of the data stack going into a colon-definition is the domain of the compiler.  Hands off, pal.
21:12:33 <I440r> im with chuck oin this
21:12:46 <I440r> there IS no "compiler/user" domain distinction
21:13:08 <I440r> i.e. if its ok for the "system" to do it its ok for the user to do it
21:13:11 <I440r> not so in ans forth
21:13:38 <I440r> to steal a quote 
21:13:39 <LOOP-HOG> what i just typed works in Swift
21:13:58 <I440r> isforth was not designed to stop people from doing stupid things because that would stop them doing clever things
21:14:00 <LOOP-HOG> I want to be able to pass stuff to a word being compiled and then to make it a literal
21:14:13 <LOOP-HOG> I440r  right on!
21:14:28 <I440r> LOOP-HOG i suggested that above as a solution
21:16:12 <LOOP-HOG> ok
21:16:33 <kc5tja> I440r: Well, I'll tell you what -- I wrote four Forth environments, and each time, I could not find a way to leave the data stack completely untouched by the compiler.
21:17:04 <I440r> check isforth
21:17:11 <I440r> it does it
21:17:18 <kc5tja> But at what cost?
21:17:23 <I440r> none
21:17:27 <kc5tja> I'm also with Chuck on this: the simplest possible hardware/software combination.
21:17:36 <kc5tja> And if that means I leave a few values on the data stack during compilation, so be it.
21:17:39 <I440r> the only time the compiler leaves something on the stack is INSIDE a definition
21:17:40 <kc5tja> You'll just ahve to deal with that.
21:17:51 <kc5tja> I440r: YES!!!!
21:17:55 <LOOP-HOG> i suppose that you could have a separate compiler stack, but then your compiler words probably have more words in them
21:17:57 <kc5tja> What the bloody heck do you think I mean?
21:18:21 <I440r> so i can easilly drop an item onto the stack for later use inside the next or some subsequent definition
21:18:23 <I440r> 5
21:18:30 <kc5tja> If you enter an IF block, the address of the IF statement's fixup is left on the data stack.
21:18:34 <I440r> : five literal ;
21:19:13 <I440r> right. but when starting the creation of a new colon definition you should not have anything onm the stack other than what the user put there
21:19:34 <I440r> and you should be able to use that anywhere
21:19:44 <I440r> ' foo >body
21:19:47 <I440r> : blah
21:19:53 <I440r>   10 0 do .....
21:19:57 <I440r> here you have a problem
21:20:07 <kc5tja> I'm personally in opposition to that style of programming.  It leads to unmaintainable code.
21:20:11 <I440r> if you want to use the stack item inside the do loop you have to do a swap
21:20:23 <I440r> true
21:20:26 <I440r> its stupid
21:20:32 <I440r> but it can also be clever
21:20:42 <kc5tja> Well, you have to [ swap ] -- a simple swap will get run at run-time, not compile-time.  :)
21:20:43 <I440r> i dont tell the user "dont ever do this for any reason"
21:20:51 <I440r> i say "go ahead, knock yoursef out"
21:21:01 <I440r> yes lol
21:21:04 <kc5tja> I don't subscribe to that.
21:21:07 <I440r> you know what i meant :P
21:21:27 <kc5tja> I subscribe to, "This is my Forth system.  Is it not nifty?  BTW, read the docs.  They exist for a reason.  If something breaks, and you didn't read the docs, is your own damn fault."
21:22:31 <I440r> :)
21:22:41 <I440r> if you break it you own both pieces ?
21:22:42 <I440r> heh
21:23:02 <kc5tja> I'm sorry?
21:23:29 <I440r> its a quote from some old shareware dos progie
21:23:39 <I440r> i forget which but i stole it and put it in my terminfo code
21:23:51 <I440r> i said if you modify this and break it you own both pieces
21:23:56 <I440r> i.e. its not MY fault
21:23:57 <I440r> heh
21:24:41 <I440r> erm not terminfo, elf header code in fsave
21:26:48 <kc5tja> Heh
21:28:14 <I440r> :)
21:28:29 <I440r> "this was a bitch to write if you break it you own both pieces" or something like that
21:28:36 <I440r> i admit i STOLE that :)
21:30:01 <kc5tja> Hehe
21:34:14 <LOOP-HOG> i wonder if i'll be good enough to write my own Forth one day
21:34:40 <I440r> not if you ignore compiler details hehe
21:37:39 <LOOP-HOG> for now its just Swift
21:40:39 <LOOP-HOG> i could but it would probably take me a really long time
21:42:09 <I440r> thats good
21:42:14 <I440r> isforth only took 2 years so far :)
21:42:42 <LOOP-HOG> sounds like quite a project
21:43:12 <LOOP-HOG> well, i think that i'm going to split now
21:43:17 <LOOP-HOG> i'll come back some time
21:44:51 --- quit: LOOP-HOG ()
21:45:51 <I440r> a new regular i hope :)
21:46:35 <Herkamire> god damn.
21:46:51 <Herkamire> I haven't had this much trouble getting linux setup up since the first time I did it.
21:49:44 <I440r> lol
21:51:56 <Herkamire> and that was on new apple hardware. with a graphics card that wasn't fully supported.
21:53:43 <kc5tja> Heh
21:54:08 <kc5tja> FS/Forth is currently going on its sixth or seventh year of development, if you consider its 1.0 release.  :)
21:54:18 <kc5tja> It's not that the system is very complicated or big.
21:54:37 <kc5tja> It's just that it's taken that long to hone and refine the architecture towards something I am looking for.
21:55:05 <kc5tja> And it's still not perfect -- after FS/Forth for Linux, you can bet the hardware-native copy of FS/Forth will be totally different again, being even simpler (of course, as there is no underlying OS).
21:55:12 <kc5tja> And frankly, I can't wait to start it.
21:55:19 <kc5tja> But I want the Linux FS/Forth done first.
21:56:06 <I440r> :)
22:00:10 <kc5tja> OK, break time from homework.  I only have two more problems to do, but they both involve long polynomial division.  :)
22:03:34 <I440r> :)
22:03:58 <Herkamire> fs/forth sounds like a great project
22:04:11 <Herkamire> certainly seems like what I'm doing.
22:04:37 <Herkamire> I hope I will be that flexible
22:04:58 <Herkamire> rrr, I mean it seems like what I'm trying to do
22:05:26 <Herkamire> I am making fairly major changes to how the forth works still.
22:05:35 <Herkamire> don't know if I will stop doing that ever
22:05:54 <Herkamire> I hope I never get to the point where I feel majorly restricted from doing that :)
22:08:06 <Herkamire> I hope I can get my business going to the point where it only takes 8 or less hours a week so I can devote some serious time to my forth system
22:08:19 * kc5tja nods
22:08:29 <Herkamire> I probably average 10 hours/week on my forth now
22:08:35 <kc5tja> I'm looking to incorporate FS/Forth into my work schedule.
22:08:42 <kc5tja> Nice.  :)
22:08:50 <Herkamire> I hope to make it 20 or 30 (maybe 40 in the winter :))
22:08:54 <kc5tja> That's about 9.9 hours more than I am devoting at the moment.
22:09:41 <Herkamire> kc5tja: maybe my dream of having this thing booting and having an email client and text-based webbrowser in 2 years isn't crazy then :)
22:12:39 <kc5tja> I don't think it's crazy.
22:12:48 <kc5tja> I feel it is very doable.
22:21:32 --- join: Serg_Penguin (Serg_Pengu@212.34.52.140) joined #forth
22:21:41 <Serg_Penguin> hi !
22:22:52 <Herkamire> kc5tja: me too.
22:24:19 <Herkamire> and 5 years to be user-friendly to non-geeks for a few tasks
22:25:14 <Herkamire> (could be 2.5 years, but I want to keep it a high priority to make architectural changes and redo things)
22:25:37 <Herkamire> and I want time to test and rethink interface ideas
22:26:39 <Herkamire> designing good interfaces is not something I have much experience with. that makes it takes at least 3X longer
22:27:10 <Herkamire> I'm 7 or 8 months into this project. 
22:27:21 <Herkamire> (I think I'm making pretty good progress)
22:27:37 <Herkamire> part of the reason I'm not further along is that I haven't done asm before
22:27:50 <Herkamire> and mostly because I haven't done this sort of forth before
22:28:17 <Herkamire> I've only made one forth before this and it was a cheesy little one in C (not very complete, and I never really did anything with it)
22:28:48 <Herkamire> I think you learn a lot when you start using it, because you find out if your design decisions pay off like you thought they would :)
22:29:30 <Herkamire> I am regularly suprised at finding that my color forth editor is broken or incapable in major ways.
22:29:48 <Herkamire> because I don't use it yet except to test things (mostly the editor it's self, or that the forth in fact runs)
22:30:43 <kc5tja> Yeah.
22:31:20 --- quit: Sonarman ("Lost terminal")
22:31:21 * kc5tja has always wanted to write some kind of computer introduction, starting from ground zero, and bringing the user up through binary numbers, through basic machine language concepts, all the way up through to writing their own Forth.
22:31:42 <kc5tja> Then, once the Forth environment is written, move into more advanced concepts, like garbage collection, some text processing,  and the like.
22:33:00 <kc5tja> I would use a hypothetical microprocessor of my own design, so as to keep the concepts independent of real hardware.  This way, the reader of the book would get equal value, regardless if he's specifically targeting a PowerPC or MIPS or x86 device.
22:33:48 <I440r> nite nite ppl
22:33:53 <I440r> work tomorrow
22:33:55 <I440r> need to go zzz
22:33:56 <kc5tja> 73 I440r
22:34:03 <I440r> :)
22:34:14 --- quit: I440r ()
22:34:46 <Serg_Penguin> does one have compiled IsForth ?
22:35:02 <Serg_Penguin> i need 'kernel.com' file ;((
22:36:24 * kc5tja does not have it.
22:36:31 <kc5tja> Bummer that I440r just left too.
22:37:23 <Herkamire> kc5tja: coool :)
22:37:32 <Serg_Penguin> hmm.. Forth what can't compile self is not a good thing :((
22:38:04 <Herkamire> kc5tja: what medium? (book, webpage, in-person presentanion, SDL program...)
22:38:25 <Herkamire> isforth requires a binary for the distro?
22:39:38 <Serg_Penguin> it is only source ;(( and why should i mess w/ NASM ?
22:39:48 <Herkamire> aaaarrg my clock being wrong has caused me all sorts of problems. I've been bug hunting for a while. I just found out that my code works perfectly well, it's just that "make" was all confused because if the weird file dates.
22:40:07 <Herkamire> Serg_Penguin: oh, I see
22:42:59 <Serg_Penguin> forth is mega cool for command-line driven proggies, like text games ;))
22:43:12 <Serg_Penguin> it's a best UI i can imagine ;))
22:43:55 * Serg_Penguin is patching yet another MS DCOM RPC hole ;)) another epidemy is about to break loose
22:47:44 <kc5tja> Serg_Penguin: Who or what writes the first Forth?
22:48:05 <kc5tja> Serg_Penguin: There is not a single Forth in the whole wide world that cannot compile itself without some form of outside help.
22:48:30 <kc5tja> E.g., PygmyForth can "meta-compile" itself -- that is, it can spawn new copies of itself from its own source code, but you need a copy of PygmyForth already working to do it.
22:49:29 <kc5tja> FS/Forth currently uses GForth for its target compiler environment; when it's done, it'll be able to meta-compile itself like PygmyForth can.  But since FS/Forth doesn't exist, I can't do it yet.
22:50:24 <Serg_Penguin> hmm, the 'chicken or egg' problem was solved naturaly many years ago, by writing the wery first ASM right in HEX code
22:50:28 <kc5tja> Herkamire: Which medium?  For my book?  I would optimize it for print, but I might consider a website or something.
22:50:39 <Serg_Penguin> and since that time - cross-compiling, etc..
22:50:47 <kc5tja> Serg_Penguin: So, that solves it then.  All you need to do is write your own kernel.com in raw hex.
22:50:51 <Herkamire> kc5tja: cool
22:51:00 <kc5tja> Serg_Penguin: Yes.  And this is bad how?
22:51:21 <kc5tja> Serg_Penguin: isForth is written in assembly language.  You need an assembler to compile its kernel.
22:51:29 <kc5tja> I really don't see the problem with this.
22:52:03 <Serg_Penguin> i see the problem in starting all over again, reinventing the wheel
22:52:57 <Serg_Penguin> so, we'll never reach the spread of GCC, what is written in it's own language and can cross-compile self for any platform
22:53:40 <kc5tja> Serg, what you "desire" we already "have."
22:53:50 <kc5tja> Forth has been recompiling itself for years and years and years.
22:54:00 <kc5tja> But there is perpetually a chicken-and-egg problem.
22:54:07 <kc5tja> isForth cannot write itself.
22:54:34 <kc5tja> Likewise, FS/Forth cannot write itself.
22:54:48 <kc5tja> If you want to build version 1.0.0 of FS/Forth for Linux, you MUST have GForth to do it.  That's as simple as it gets.
22:55:51 <Serg_Penguin> so, FS/Forth can be meta-compiled either by self or GForth ? good !
22:55:57 <kc5tja> No
22:55:59 <kc5tja> One or the other.
22:56:11 <kc5tja> Note: meta-compiling and target compiling are subtly different.
22:56:25 <kc5tja> Meta-compiling is when you compile yourself for the host processor you're running on.
22:56:43 <kc5tja> E.g., PygmyForth's meta-compiler cannot produce a version of PygmyForth for ARM or SPARC, for example -- only 8086.
22:56:52 <kc5tja> (and I do mean 8086 -- it doesn't even support 80286 or 386).
22:57:24 <kc5tja> The only way to produce a version of Pygmy forth 80286 or some other CPU environment is to write a compiler that reads Pygmy's source, and compiles a target image.
22:57:32 <Herkamire> I just checked, and the asm source that goes into my forth compiles to 900 bytes. That would be feasable to hand-code in hex, but utterly pointless.
22:57:35 <kc5tja> (and even then, you have to fix up its meta-compiler)
22:58:27 <Serg_Penguin> surely, different compiler backend for different platform
22:58:32 <kc5tja> That brings up another difference between target and meta-compiling: a target compiler uses a separate compiler.
22:58:34 <kc5tja> Serg_Penguin: No.
22:58:40 <kc5tja> Forth has no concept of "back-end."
22:58:42 <Herkamire> bedtime.
22:58:42 <kc5tja> Forth is not C.
22:58:46 <kc5tja> 'night Herkamire
22:58:53 --- quit: Herkamire ("goodnight guys")
22:58:55 <Serg_Penguin> erhm,  ... different target
22:59:40 <kc5tja> You have to replace the whole compiler.
22:59:57 <kc5tja> Meanwhile, a meta-compiler uses the exact same compiler that all the other colon definitions use.
23:00:33 <Serg_Penguin> and takes the stub from self's exe file ?
23:02:36 <kc5tja> The stub?
23:04:47 <Serg_Penguin> kernel.com in IsForth ;)) the very basic things, like address interpreter, @ c@ ! c! etc..
23:08:25 <kc5tja> No.  The meta-compiler would use the same colon compiler to generate the core kernel too.
23:08:36 <kc5tja> The kernel, btw, is hardly a stub.  :)
23:08:52 <kc5tja> A stub is generally a small piece of code intended to interface one language to another.
23:17:41 <kc5tja> Three hours -- 12 math problems.
23:17:47 <kc5tja> Thank goodness I'm only taking one class this semester.
23:18:06 <kc5tja> At that rate, I'd be totally burned out if I was taking three or four classes (normal class load)
23:19:09 <kc5tja> But, the homework is finished at least.
23:22:50 <Serg_Penguin> do you believe what infrasound is used in catholic churches to wash the brains ?
23:26:16 <kc5tja> No.  But I do believe that the tone choices they use for their chord progressions induce a state of euphoria -- these chords are found in many progressive rock-n-roll bands, such as Genesis and Pink Floyd, to induce a similar effect.
23:26:35 <Serg_Penguin> here is a hot debate in one RU forum :))
23:26:40 <kc5tja> Well, I need to jet.  I need to sleep for school tomorrow.
23:26:47 <Serg_Penguin> ok
23:26:51 <Serg_Penguin> g'nite
23:26:55 <kc5tja> Thanks.  :)
23:26:56 <kc5tja> night
23:27:00 --- quit: kc5tja ("THX QSO ES 73 DE KC5TJA/6 CL ES QRT AR SK")
23:27:24 --- quit: Serg_Penguin ()
23:59:59 --- log: ended forth/03.09.17