03:18:45 --- log: started forth/01.12.30
03:18:45 --- quit: clog (^C)
03:18:45 --- log: stopped forth/01.12.30
03:19:02 --- log: started forth/01.12.30
03:19:02 --- join: clog (nef@bespin.org) joined #forth
03:19:02 --- topic: 'do drop >in'
03:19:02 --- topic: set by I440r on [Thu Dec 27 13:09:40 2001]
03:19:02 --- names: list (clog @aaronl)
04:12:22 * aaronl is away: banging head on desk
09:14:50 --- join: edrx (edrx@200.240.18.52) joined #forth
09:36:55 --- join: oxygene (oxygene@linux-future.de) joined #forth
09:37:24 --- quit: edrx ("[x]chat")
09:37:43 <oxygene> hey
09:37:51 --- join: Stepan (~stepan@port-213-20-224-177.reverse.qdsl-home.de) joined #forth
09:37:56 <Stepan> hi :-)
09:38:53 <oxygene> .o0O #OpenBIOS overtake in #forth ;)
09:49:35 --- join: I440r (mark4@1Cust5.tnt3.bloomington.in.da.uu.net) joined #forth
09:50:34 <oxygene> hi I440r
09:50:56 <I440r> zim i just thunked of something - i burned your stuff to a cdrw - is your cd able to read from phaze change cd's ?
09:51:03 <I440r> btw zim - you change your nick WAY too often :P
10:03:51 --- quit: Stepan (Remote closed the connection)
10:05:36 --- quit: I440r ("BitchX-1.0c18 -- just do it.")
11:05:00 --- join: I440r (mark4@1Cust71.tnt3.bloomington.in.da.uu.net) joined #forth
11:06:12 <I440r> hi oxy
11:06:17 <I440r> you a forth coder ?
11:07:06 <oxygene> I440r: yes, I used forth a lot on my c64 *g* and I now try to refresh my knowledge as I'm working on OpenBIOS, an OpenFirmware-implementation
11:07:29 <I440r> cool
11:07:47 <I440r> im making a linux x86 forth
11:07:54 <I440r> except ive not been working on it for months
11:08:07 <I440r> plucking up the courage to start work on it again soon
11:08:14 <oxygene> another one? ;)
11:08:52 <I440r> isforth
11:08:57 <I440r> written in pure assembler
11:09:06 <I440r> not no lame ass c forth 
11:10:13 <oxygene> I440r: threaded or some optimizing stuff?
11:10:24 <I440r> no optimizations
11:10:30 <I440r> i hate optimizing compilers
11:10:42 <I440r> they destroy the 1:1 co-relation between source and object
11:10:43 <I440r> and 
11:10:49 <I440r> you dont know whta the fuk you get with them
11:10:57 <oxygene> hehe :)
11:11:24 <I440r> direct threaded
11:11:37 <oxygene> hmm... I thought about building a forth-system consisting of a CALL into the dictionary itself....
11:12:03 <oxygene> atm we're using a c-forth for OpenBIOS as it's a fast-hacked thing
11:13:01 <oxygene> hmm... direct threaded? never did one
11:36:26 --- quit: I440r ("Reality Strikes Again")
11:40:26 --- join: I440r (mark4@pool-63.52.217.149.ipls.grid.net) joined #forth
14:45:26 * aaronl is back (gone 10:33:04)
14:45:44 * aaronl is away: I'm busy
15:00:13 * aaronl is away: gargargar
15:30:16 --- join: I440r_ (mark4@pool-63.52.217.50.ipls.grid.net) joined #forth
15:33:15 --- quit: I440r (Read error: 60 (Operation timed out))
16:28:32 --- join: Fare (fare@samaris.tunes.org) joined #forth
16:29:09 --- join: Speuler (~l@c38038.upc-c.chello.nl) joined #forth
16:29:20 <Speuler> hi
16:29:27 <Fare> lo
16:30:27 <Speuler> hi
16:33:28 <oxygene> hey
16:35:17 <I440r_> bongo!
16:35:17 <I440r_> dood
16:35:17 <I440r_> any info on jobs there yet man ?
16:35:27 <I440r_> im desperatly desperat for a job :)
16:35:33 <Fare> forth jobs? where?
16:35:48 <I440r_> hi fare :)
16:36:01 <Speuler> hi i440r
16:36:01 <Speuler> i should ask you ...
16:36:19 <I440r_> u mean ur out of work now ?
16:36:28 <Speuler> last thing mrrapp said was you weren't answering to his mail
16:36:45 --- nick: I440r_ -> I440r
16:37:21 <Speuler> i've finished prev project a few days ago
16:37:23 --- mode: ChanServ set mode: +o I440r
16:37:25 <Speuler> that was asm
16:37:40 <Speuler> different department, floor, people
16:38:01 <I440r> yea 
16:38:06 --- mode: I440r set mode: +o clog
16:38:08 --- mode: I440r set mode: +o Fare
16:38:10 --- mode: I440r set mode: +o oxygene
16:38:13 --- mode: I440r set mode: +o Speuler
16:38:27 <Speuler> thanks
16:38:35 <Speuler> now i can kick me
16:38:52 <I440r> :)
16:39:12 <Speuler> I440r: how did the correspondence work out ?
16:39:33 <I440r> ive heared absolutely NOTHING from them
16:40:10 <Speuler> that's about what those from the agency said about you
16:40:20 <oxygene> hmm... anyone here interested in working on a free OpenFirmware implementation for x86 and other architectures?
16:40:30 <I440r> i mailed them my resume so the ball was in their court
16:40:42 <Speuler> tried to contact you several times they said
16:41:12 <I440r> via what method ?
16:41:13 <I440r> fone?
16:41:14 <I440r> email ?
16:41:26 <Speuler> i suppose email
16:41:34 <Speuler> not sure
16:41:35 <I440r> well ive recieved no emails about jobs
16:43:02 <Speuler> what DID you receive ?
16:43:16 <I440r> from them ?
16:43:17 <I440r> nothing
16:43:33 <I440r> if they emailed me i didnt see them
16:43:44 <Speuler> when did you mail them for the last time ?
16:44:02 <I440r> ages ago - i  was also emailing other agencies left right and centre
16:44:15 <I440r> theres absolutely no jobs going in this country roght now
16:44:54 <I440r> i got 3 agencies unable to place me
16:44:59 <I440r> and ive mailed my resume all over
16:45:11 <I440r> since sept 11 the economy has nose dived :(
16:45:25 <Speuler> thanks. good reason 4 me not to try the us
16:45:37 <I440r> no - try anyway
16:45:44 <I440r> if u get a job u get a job :)
16:45:50 <I440r> if u dont try u wont get one heh
16:46:15 <Speuler> i a native citizen doesn't manage, a foreigner's chances wouldn't be good 
16:46:36 <I440r> im sure there are jobs out there, its finding them thats the trick heh
16:46:38 <I440r> im trying
16:46:41 <Speuler> bringing my truck along would be costly too :)
16:46:44 <I440r> just not having any luck :(
16:50:04 <Speuler> maybe mrgreenspan should put forward some optimistic remarks about the economy
16:50:16 <I440r> ct heh
16:50:20 <I440r> ct what does he know :P
16:50:30 <Speuler> industry seem to need that kind of statements
16:51:11 <Speuler> not relevant what he knows but what others think he knows
16:51:48 <Speuler> duisenberg (european counterpole to mrgreenspan) tried this tonight
16:51:56 <Speuler> let's see :)
16:52:34 <oxygene> Speuler: what did duisenberg say? that everythings fine with the move to the EUR?
16:52:54 <Speuler> he said "we are through the stagnation, and he expects grows again now"
16:53:05 <Speuler> first slower, then quicker
16:53:12 <Speuler> starting with 2002 :)
16:53:13 <oxygene> no wonder - war always means grows in industry
16:53:32 <oxygene> and a new currency with all that maintenance work, too - of course ;)
16:54:10 <Speuler> was the belgian news i was listening to. in those excerpts of duisenberg's speech, there was no mentioning of euro at all
16:54:48 <oxygene> hmm... "starting with 2002" and "europe" ...
16:55:14 <Speuler> oh yes, he said something about euro
16:55:25 <Speuler> he said "he'd love the u.k to join"
16:55:43 <oxygene> hehe, those nasty separatists on that isle far far away ;)
16:56:33 <Speuler> and in the same news item, they reported some u.k companies accepting euros.
16:56:43 <Speuler> like, gas station, shops
16:57:00 <Speuler> not a legal tender there, but you can pay with it
16:57:15 <oxygene> hmm... what was it - didn't they want the euro or didn't they pass the requirements?
16:58:07 <Speuler> the tories didn't wnat it, and labour wasn't opposed but wants to take the slow lane
16:58:34 <Speuler> see how things work out first
16:59:06 <I440r> u know what the word "tori" means ?
16:59:23 <I440r> it was a word used by highwaymen in ireland. it means "give me"
16:59:29 <Speuler> i know about tory island, pirate island
17:00:58 <Speuler> tory island is off the coast of ireland btw
17:01:52 <Speuler> i think they still don't pay taxes there
17:02:23 <Fare> more power to them!
17:04:22 <I440r> :)
17:04:35 <Speuler> why, because of not paying taxes ? there are companies evading tax payments - just evading taxes doesn't make you good :)
17:04:43 <Fare> yes
17:04:51 <Fare> moral persons don't support robbery
17:07:17 <Speuler> or would call it differently
17:09:31 <Fare> just calling robbery "tax" doesn't make it moral
17:09:34 <Fare> just legal
17:10:21 <Speuler> there are at least two aspect to taxes
17:10:50 <Speuler> some uses of tax i could support
17:11:08 <Speuler> but the lack of control about the part i wouldn't like to support annoys me
17:11:43 <Speuler> not all tax is put to bad use
17:12:26 <I440r> no - those parts that arnt are usually wasted or leeched :P
17:12:43 <Fare> Speuler: the part you could support needn't be tax so you would support it
17:12:54 <Speuler> probably.
17:13:03 <Fare> so taxes are always evil.
17:13:20 <Fare> in the best case, the evil is small or even null
17:13:37 <Speuler> considering they pay for ms licenses with it. awful thought
17:14:00 <Fare> consider they pay for enforcement of MS's IP privileges.
17:15:34 <Speuler> there's quite an dispute going on in german parlament, about windows versus linux use
17:15:56 <I440r> yea
17:15:59 <I440r> what happned with that ?
17:16:04 <Speuler> both systems have fiery pro- and opponents
17:16:21 <Speuler> ms offered source codes to look at a while ago
17:16:26 <I440r> ya
17:16:32 <I440r> but NOT to the general public
17:16:36 <Fare> and whoever wins, he will have those who disagree pay to support their point of view
17:16:39 <Speuler> no ms came up with some drumbeating
17:16:46 <I440r> and if someone dumped 50 thousand lines of code on your desk would it make any sense to you ?
17:16:59 <Speuler> not much news: their system saver because sources not open etc
17:17:17 <Speuler> the linux proponent answer is:
17:17:30 <I440r> not so
17:17:37 <Speuler> you can have look specialists at the code, and see what it actually does
17:17:52 <I440r> its more suceptable to hacks because known attacks take MONTHS to be fixed
17:17:53 <Fare> who pays the specialist?
17:17:54 <I440r> if they ever are
17:18:04 <Speuler> tax payer
17:18:09 <Fare> who's ready to sign one's mind into a NDA after having read the horror?
17:18:13 <Speuler> same who would pay for the damage
17:18:15 <Fare> Speuler: then it's the same problem
17:18:35 <oxygene> at least the german government already works on alternatives
17:18:41 <Speuler> no. better pay for prevention of problems than effects of problems
17:18:51 <oxygene> eg. sponsoring gnupg and paying the sphinx-project
17:19:08 <Fare> Speuler: sometimes. Not always.
17:19:20 <Speuler> gpg was sponsored by ministry of economics
17:19:27 <Fare> Speuler: do you prove your programs correct before you run them?
17:19:44 <Speuler> depends what program, what for, what use
17:19:47 <Fare> do you use a strongly-typed language?
17:19:58 <Speuler> if serious, i don't do that myself
17:20:12 <Speuler> only fix it where it fails the tests 
17:20:13 <Fare> Speuler: see. Sometimes it pays to prevent problems, sometimes not.
17:20:24 <Speuler> no
17:20:32 <Speuler> (not strongly typed)
17:20:38 <Speuler> (usually not)
17:21:10 <Speuler> like, nukes. lets them explode, or work, to proof them ?
17:21:31 <Fare> work to have them removed.
17:21:42 <Speuler> or, environmental issues
17:21:55 <Speuler> clean up the mess later on ?
17:22:08 <Speuler> or, computer, os.
17:22:22 <Speuler> wait till it falls to pieces 
17:23:17 <Speuler> when does it pay NOT to prevent a problem ?
17:24:06 <Speuler> when you can sell a new version of what caused the problem ?
17:24:12 <Fare> when the problem is small and the prevention measure expensive.
17:24:28 <Fare> that's where insurances come into play.
17:24:58 <Speuler> you mean, fix windows by insuring against it ?
17:25:36 <oxygene> better: letting ms paying the insurance - as some kind of garantuee that they'll do their best ;)
17:26:18 <Fare> insurance is against problems that are not sure to happen
17:26:24 <Fare> windows is a sure problem
17:26:30 <Fare> so you can't insure against it
17:26:30 <Speuler> whoever likes to do so, sure. my insurance is to not have ms on my disk
17:27:06 <Speuler> that insurance is free too
17:27:55 <Fare> that's a case where prevention pays.
17:28:14 <Speuler> parlament is possibly settling for mixed-systems solution
17:28:41 <Speuler> linux on servers, some windows on workstations
17:28:44 <Fare> die parliament, die!
17:28:54 <Fare> a good politician is a dead politician
17:29:01 <oxygene> not that bad as a beginning... critical workstations get linux, too I guess ;)
17:29:20 <oxygene> after 5 years they notice that they can switch the rest to linux, too...
17:29:44 <Fare> why should politicians decide technical questions, to begin with???
17:29:51 <Speuler> germany is one of the few countries with more linux than ms systems accessable through internet
17:30:07 <Speuler> i would have thought france would be another case
17:30:10 <Speuler> but no
17:30:28 --- join: Stepan (~sr@dialin-145-254-235-196.arcor-ip.net) joined #forth
17:30:29 <Fare> France is worse.
17:30:36 <Fare> nighty night, anyway
17:30:45 --- quit: Fare ("Hey!  Where'd my controlling terminal go?")
17:31:02 <oxygene> hi stepan
17:31:20 <Stepan> Hey :-)
17:35:06 <I440r> hi Stepan
17:35:13 <I440r> u been in here before ? u code forth ?
17:35:21 <Stepan> bits
17:35:29 <Stepan> i have to.. :)
17:35:36 <I440r> you HAVE to ?
17:35:36 <oxygene> I force him to ;)
17:35:40 <I440r> can i have a job where your at ?
17:35:43 <Stepan> it's my inner voice telling me forth is good
17:35:46 <I440r> oh heh
17:35:54 <I440r> it is
17:35:56 <Stepan> Hehe..
17:35:57 <I440r> c is evil
17:36:20 --- topic: set to 'forth is good - c is evil!' by I440r
17:36:37 <Stepan> I440r: it's the openbios project.. you are welcome to have a job here.. unfortunately we dont have any money to pay someone.. :)
17:36:40 --- topic: set to 'forth is good - c is bad! -- forth-geek farm' by oxygene
17:36:43 --- mode: oxygene set mode: +o Stepan
17:36:59 <I440r> reply doh! - and i got mortgage payments to make :(
17:37:17 <I440r> nono - c isnt bad, c is EVIL!!!!!
17:37:28 <I440r> in x = 4
17:37:34 <I440r> in y y = 5;
17:37:42 <I440r> erm int y=5;
17:37:48 <oxygene> four legs good, two legs bad ;)
17:37:49 <Stepan> :-))
17:37:54 <I440r> erm no im fubaring this
17:37:57 <I440r> int x=4;
17:38:03 <I440r> int y=x+++++x;
17:38:04 <Stepan> c rocks whereas forth is devine
17:38:23 <I440r> there - proof that c is evil
17:39:08 <Stepan> heh.. no w4rz ;)
17:39:16 <oxygene> in the end y=10; x=6
17:39:37 <I440r> nope
17:39:50 <I440r> the result cannot be determined
17:40:22 <oxygene> right... as ++x and x++ are equal in priorities
17:40:46 <I440r> plus = with the way the code would be optimized you would have things like
17:40:47 <I440r> inc ax
17:40:50 <I440r> add bx,ax
17:41:03 <I440r> and on some processors that wouldnt cause an agi
17:41:12 <I440r> so teh cached value of ax would be added to bx
17:41:17 <Stepan> agi?
17:41:24 --- topic: set to 'forth is good - c is nasty!' by oxygene
17:41:43 --- topic: set to 'forth is clean - c is for men!' by Stepan
17:41:55 --- topic: set to 'forth is clean - c is for men! | : FC RECURSIVE DUP 1 > IF DUP 1 - FC * ELSE DROP 1 THEN ; 42 FC .' by oxygene
17:43:19 <Stepan> I440r: tell me this looks better: hex 4666 dup negate do i 4000 dup 2* negate do 0 dup 2dup 1e 0 do 2swap * e >>a 2* 3 pick + -rot - j + dup dup * e >>a rot dup dup * e >>a rot swap 2dup + 10000 > if "  " leave else i 1d = if " *" then then loop type 2drop 2drop 266 +loop cr 5de +loop
17:43:48 <I440r> well thers soemthign you are forgetting
17:43:55 <I440r> you can factor that code a hell of alot better
17:43:59 <Stepan> oxygene: for example (see) does use {0@} {2!} etc
17:44:02 <I440r> there is little or no overhead for factoring code
17:44:03 <oxygene> I440r: ack
17:44:05 <I440r> unlike in c
17:44:25 <oxygene> I440r: the overhead depends on the forth-system
17:44:31 <I440r> yup
17:44:38 <Stepan> if you know what you do, you can do it, no matter whether it's C or forth
17:44:42 <I440r> but i consider it next to zero
17:44:56 <I440r> because correctly factored  code is easier to debug
17:45:00 <Stepan> if you can't factor right, you're fucked in C. Forth lends you a hand
17:45:00 <oxygene> I440r: some indirect threaded system has some overhead - but that it catched by those huge caches of todays cpus
17:45:03 <I440r> and a hell of alot easier to understand
17:45:14 <I440r> actually i dont like indirect threading
17:45:18 <I440r> i only like direct threading
17:45:24 <I440r> anything else however is NOT threading
17:45:34 <oxygene> I440r: indirect threading is very easy to code...
17:45:47 <I440r> so is direct
17:45:54 <Stepan> oxygene: any clue what it does?
17:45:54 <I440r> i can think direct alot easier than i can indirect
17:46:00 <I440r> why have a pointer to a pointer to you rocode
17:46:07 <I440r> a pointer to a pointer to your code
17:46:14 <I440r> when all you need is a pointer to your code
17:46:34 <Stepan> why use a dup drop when you only need a value once on the stack?
17:46:47 <oxygene> I440r: a pointer to a pointer is useful when you have your thread-resolver inline....
17:47:16 <I440r> thread resolver being next ?
17:47:19 <I440r> or nest/unnest ?
17:47:22 <oxygene> next
17:47:26 <I440r> i would never put nest and unnest inline
17:47:34 <I440r> inline next is hell easy with direct threading
17:47:37 <I440r> lodsd
17:47:40 <I440r> jmp eax
17:47:49 <oxygene> how is direct threaded code done? never seen one (stopped at fig83-systems)
17:48:09 <I440r> direct threading on an x86 
17:48:14 <I440r> assume sp is stack pointer
17:48:19 <I440r> bp is return stack pointer
17:48:26 <I440r> si is interprative pointer
17:48:38 <I440r> : defs are like this
17:48:52 <I440r> dw link back to prev word
17:49:03 <I440r> db 'name goes here'  \,-- counted string
17:49:07 <I440r>  dw pointer to code
17:49:12 <I440r> code:
17:49:16 <I440r>  call nest
17:49:17 <I440r>   dw x
17:49:19 <I440r>  dw y
17:49:20 <I440r>  dw z
17:49:22 <I440r>  dw unnest
17:49:30 <I440r> nest pushes si onto the return stack
17:49:42 <I440r> and then pops the return address of the above call into si
17:49:47 <I440r> si now points at teh dw x
17:49:51 <I440r> next is defined as
17:49:53 <I440r> lodsw
17:49:56 <I440r> jmp ax
17:50:04 <I440r> the lodsw loads what si points at into ax
17:50:12 <I440r> and advances si to point to the dw x
17:50:16 <I440r> you jmp ax
17:50:30 <oxygene> so the forth-code is always embedded into asm-header and asm-footer?
17:50:40 <I440r> always
17:50:53 <I440r> every forth definition has assembler code assiciated with it
17:50:57 <I440r> call nest
17:51:08 <I440r> the definition for a variable would be
17:51:14 <I440r> dw pointer to code
17:51:15 <I440r> code:
17:51:18 <I440r>  call next
17:51:20 <I440r>  dw body field
17:51:31 <I440r> the call to next would leave the address of the body on the stack
17:51:34 <I440r> very simple
17:52:33 <oxygene> ok...
17:52:57 <I440r> if u look at the isforth.sourceforege.net cvs for isforth ull see it up close
17:53:01 <I440r> that shit is old tho
17:53:02 <oxygene> so it's quite similar to indirect threaded code that uses every word as CODE-definition
17:53:05 <I440r> and not in a working state
17:53:21 <I440r> :)
17:53:25 <oxygene> where the CODE-definition does a jump for nest, then does normal compilation
17:53:44 <oxygene> so not much difference (except that indirect is more portable and a bit smaller - not much though)
17:54:14 <I440r> erm no
17:54:20 <I440r> indirect isnt smaller
17:54:31 <I440r> i would put them at about the same size
17:55:01 <I440r> direct threading has some neat advantages over indirect that make it better in some areas
17:55:13 <I440r> ive never seen an indirect threaded implementation that i liked
17:55:18 <oxygene> why the header is the same, except that s/pointer to code/pointer to next/ - code: is then completely a bunch of pointers to words
17:55:27 <I440r> i always felt that it would be smaller and faster if it was direct threaded
17:55:37 <I440r> well
17:55:41 <I440r> for isforth i did this
17:55:46 <oxygene> so it keeps you the "call next" every word
17:55:52 <I440r> i want all my headers to be in their own segment
17:55:58 <oxygene> but thanks for the insights :)
17:56:16 <I440r> not every word calls next
17:56:24 <I440r> they jmp next or have inline next
17:56:30 <I440r> an inline next is a 
17:56:31 <I440r> lodsw
17:56:34 <I440r> jmp ax on every word
17:56:52 <oxygene> I440r: yes, the other ones are either CODE-words which jump like your words and variables/consts which have their own handler
17:56:55 <I440r> in an x86 system you have a speed advantage of aligning your definitions on a paragraph boundryt 
17:57:12 <I440r> so the added extra code on each definition is filling in space that would be left blank anyway
17:57:21 <I440r> tho isforth doiesnt align words yet
17:57:46 --- join: Xuz (aemerson@bgp01079860bgs.wanarb01.mi.comcast.net) joined #forth
17:57:55 <I440r> hi x!
17:58:01 <Xuz> Hello.
17:58:08 <oxygene> hi Xuz
17:58:12 <I440r> alto of new ppl coming in here today :)
17:58:19 <I440r> now were is that asshole TCN :P
17:58:20 <I440r> grrr
17:58:33 * Xuz nodnods, "I'm usually in here when I'm on this network, nobody else ever is, though :)"
17:58:43 <I440r> i know
17:58:49 <I440r> the channel has been a little dead for a while
17:58:52 <I440r> thats my fayult
17:59:01 <I440r> my project has been on hold for months
17:59:39 <oxygene> don't worry - OpenBIOS has been on hold for about 3 years iirc ;)
17:59:39 <Xuz> What kinda' project?
17:59:47 <I440r> linux x86 forth
17:59:51 <I440r> written in assembler
17:59:57 <I440r> using NO standard libraires
18:00:02 <I440r> all i/o done using syscalls
18:00:08 <I440r> direct threaded
18:00:09 * Xuz aahs
18:00:09 <I440r> blah blah
18:00:25 <oxygene> I440r: do you wanna stay below the 2k boundary? ;)
18:00:34 <I440r> why ?
18:00:42 <I440r> what 2k boundry ?
18:01:27 <oxygene> then you'd have the smallest working forth I've seen so far except one implementation on 6502 *g*
18:01:43 <I440r> my 8051 forth is goign to be small |:)
18:02:01 <I440r> th ewhole point to it is to have the smallest forth for the 8051 i can get 
18:02:06 <I440r> and IT is direct threaded too :)
18:02:11 <oxygene> hehe :)
18:02:14 <oxygene> how small?
18:02:25 * Xuz , personally, would like something that can use any library somewhat easily, but doesn't HAVE to if he doesn't want it.
18:03:10 <oxygene> Stepan: you should apply for the IOFCC with your fractal thing above - just do some better layout
18:03:20 <I440r> isforth will be ble to link to libs etc
18:03:24 <I440r> but the kernel will not do so
18:04:22 <I440r> i need to figure some things out with linux kernel tho
18:04:24 * Xuz nods, "I know I CAN with GForth.  Except for functions with more than 6 parameters, last time I checked.  And I haven't found a way to work with something that wants a function pointer."
18:04:25 <Stepan> Obfuscated Forth contest? ;)
18:04:33 <I440r> when isforth runs it needs to copy its headers into head space
18:04:40 <I440r> and stuff like that
18:04:50 <I440r> ohhh i love obfuscated forth heh
18:04:57 <I440r> i dont know any tho
18:05:04 <I440r> forth is very difficult to obfuscate
18:05:07 <oxygene> Stepan: yep
18:05:18 <Stepan> yepp.. forth is unreadable anywas
18:05:29 <Stepan> hard to improve that natural quality
18:05:30 <Stepan> :)
18:05:36 <I440r> no
18:05:45 <I440r> badly written forth is just as unreadable as well written c
18:05:57 <I440r> well written forth is very difficult to obfuscate
18:05:58 * Xuz laughs
18:06:05 --- topic: set to 'forth is clean - c is for men! || : FC RECURSIVE DUP 1 > IF DUP 1 - FC * ELSE DROP 1 THEN ; 42 FC . || badly written forth is just as unreadable as well written c' by oxygene
18:06:37 <I440r> ercursion is a natural obfuscation
18:06:51 <I440r> anything you can do WITH recursion - can be done BETTER without
18:06:53 * Xuz thought recursion was an antiobfuscation.
18:07:04 <I440r> recursion is just a lamers way of itterating anyway
18:07:10 <I440r> hell no
18:07:12 <I440r> its evil
18:07:17 <Xuz> What's evil about it?
18:07:23 <I440r> had a friend write a regeon flood fill 
18:07:27 <Stepan> I can't find anything being hard to read in C
18:07:28 <I440r> his was recursive
18:07:32 <I440r> mine was itterative
18:07:39 <I440r> my code was about 50 times faster
18:07:43 <I440r> a hell of alot smaller
18:07:49 <I440r> and crashed less :P
18:08:11 <Xuz> Were you using something that did tail-call optimization?
18:08:23 <I440r> optimizations are ALSO evil
18:08:27 <Stepan> why should iteration bring you any good in favour of recursion? 
18:08:32 <I440r> thats the beauty of forth
18:08:46 <I440r> you have a 1:1 co-relation between your sources and your object
18:08:54 <I440r> optimizations destroy this
18:09:17 <Xuz> IIRC, I thought either Color Forth or Machine Forth was adding tail-call optimizationa nd taking the iterating words out.
18:09:49 <I440r> ugh
18:09:51 <I440r> evil!
18:10:04 <Stepan> noone needs co-relation if the compilers are correct
18:10:17 <Xuz> Well, co-relation is nice on a level.
18:10:21 <Stepan> that's only for freeks debugging compilers
18:10:32 <Xuz> Not between the source and machine code.
18:10:40 <Xuz> But I want it between the source and the code's view of itself.
18:10:48 <I440r> ugh - forth is so easy to debug
18:11:00 <I440r> you can have the debugger literally reverse engineer your code on the fly
18:11:07 <I440r> have a debugger built in 
18:11:24 <Stepan> I have gdb built in my computer. 8)
18:11:28 <Xuz> Which Forth still gives you.  Even with tail-call optimization :)
18:11:33 <I440r> gdb sucks
18:11:40 <Stepan> it resides on the harddisk ;)
18:11:41 <I440r> realy realy sucks
18:11:47 <Stepan> Why?
18:11:50 <I440r> it is one of the words debuggers ive ever used
18:11:58 <I440r> you set a breakpoint on a function
18:12:00 <I440r> you run
18:12:09 <I440r> itstops on the second instruction of said fun tion
18:12:18 <I440r> you set a breakpoint at address 1234
18:12:21 <Stepan> never did that for me
18:12:30 <I440r> it breaks AFTER executing the instruction at address 1234
18:12:40 <I440r> you set a break popint inside a loop
18:12:50 <I440r> it loops 4 or 5 times before it sees your breakpoint
18:12:55 <I440r> it always doe it
18:12:58 <Stepan> thats not true
18:13:02 <I440r> ive never seen it behave properly
18:13:30 <Xuz> Send a bug report?
18:13:37 <Stepan> bullshit. I've never seen this behavior since i used gdb first time in 94
18:13:53 <Stepan> is there an example
18:13:54 <oxygene> I440r: what arch/os do you use it on?
18:13:55 <I440r> every time i run it i get shit like that
18:14:00 <I440r> x86
18:14:04 <I440r> linux
18:14:40 <I440r> the best assembler and debugger i have EVER seen is
18:14:45 <I440r> a386 and d386
18:14:47 <oxygene> nah, x86 is crap anyway ;)
18:14:50 <I440r> registered a86/d86
18:14:56 <I440r> by eric isaacson
18:15:03 <I440r> he lives only 15 miles from me too
18:15:41 * Xuz wishes he were rich so he could buy that Alpha system he was looking at.
18:16:21 <I440r> i like the 68k
18:16:33 <oxygene> .o0O Stepan will hurt me for that, but ...) alpha? dead technology ;)
18:16:49 <Xuz> Bah.
18:16:53 <Xuz> It's nice :)
18:17:03 * Xuz would REALLY like a 1Ghz 65864 :)
18:17:08 * Xuz errs
18:17:13 <I440r> i like motorola procesors
18:17:18 <I440r> their controlers SUCK
18:17:22 <I440r> i like intel controlers
18:17:28 <I440r> their processors SUCK!
18:19:20 <I440r> but
18:19:35 <I440r> x86 is the way of the world im affrade :P
18:20:06 * Xuz shrugs, "If you have sourcecode to everything, anyway, you don't need to be bound to a crapulicious and evil microprocessor."
18:20:32 <Xuz> Except for programming languages themselves which need to be written in ASM, but that's the special case.
18:21:11 <Stepan> oxygene: x86 is dead technology, not alpha
18:21:16 <oxygene> Xuz: you only need one language-implementation in a very reduced language (ito complexity) like forth - everything else can be derived from that
18:21:22 <oxygene> Stepan: I told you, yes :)
18:21:23 <Stepan> alpha is developed until 2011, x86 stops at 2006
18:21:40 <oxygene> Stepan: not developed, supported...
18:21:50 <Stepan> wrong
18:21:55 <Stepan> supported til 2013
18:21:59 <Stepan> ;-b
18:22:10 <Stepan> _developed_ until 2011
18:22:25 <oxygene> then they even prolonged stuff...
18:22:25 <Stepan> so, beat that, intel boyz ;)
18:22:31 <Stepan> yepp
18:22:33 <oxygene> I don't like intel :)
18:22:33 <I440r> x86 isnt going to be dropped
18:22:35 <Xuz> True, you could write C in Forth or Forth in C or whatever, but most people who would want to write an implementation of one wouldn't want to use the other.
18:22:46 <I440r> motorola wanted to drop the 68k family but way too many ppl used it
18:22:53 <I440r> too much loss of revenue
18:22:54 <Stepan> Xuz: thats the problem openbios has
18:23:21 <Stepan> but still 68k is too expensive for what it does.. even coldfire
18:23:22 <I440r> i was goign to write a forth interpreter in bash s ript
18:23:27 <I440r> and a bash interpreter in forth
18:23:35 <I440r> and have them recursivly interpret each other heheh
18:23:45 <I440r> endless circle feeding off itself hehe
18:24:35 <I440r> like a 2 headed snake devowering itself from both ends :)
18:25:14 --- mode: I440r set mode: +o Xuz
18:26:56 <oxygene> away
18:27:22 <Xuz> Would need to be two-tailed, too :)
18:29:34 <I440r> :)
18:29:42 <I440r> it would need to be an x
18:29:43 <I440r> heh
18:31:13 * Xuz is really annoyed at ANS for the whole business of making it difficult/impossible to fiddle with some things.
18:33:44 <I440r> i dont like ans either
18:36:39 <I440r> i like an 83 standard base with enhancements
18:36:46 <I440r> but still basically the 83 standard
18:36:54 <I440r> shitty words like "cell" have no place in linux
18:37:07 <I440r> 2+ 2* and 2/ are REQUIRED
18:37:17 <Xuz> Welllllll. . . . . 
18:37:26 <I440r> if ur crappy cell size if 4 then you define 4* and 4/ and 4+ too
18:37:26 <Xuz> Cell can be useful.
18:37:32 <I440r> its ugly
18:37:42 <I440r> it hides what you are actually doing
18:37:48 <I440r> portable code is jack of all 
18:37:51 <I440r> not master of one
18:38:19 <Xuz> Not really.  You're just saying that you're using "one address-unit-sized chunk" rather than "one 32-bit chunk"
18:38:22 <I440r> isforth will NOT be portable at all
18:38:48 <Xuz> If you have the same Forth on different architectures, being able to move code between them might be nice.
18:38:55 <I440r> yes
18:39:13 <I440r> but being able to compile isforth kernel on an x86, an alpha, an zx81 etc  etc etc
18:39:16 <I440r> is totally bogus
18:39:27 <Speuler> g'd night
18:39:27 <I440r> you should have one version of the kernel for x86
18:39:33 <I440r> another for alpha
18:39:39 <I440r> another for the sinclair zx81
18:39:53 <I440r> application code should compile and execute identically on all of the above
18:40:32 <Xuz> That's what CELL les you do.
18:40:46 <I440r> no
18:40:59 <I440r> well yes
18:41:04 <Xuz> Obviously if you're writing a Forth in assembler language, you wouldn't expect it to be portable on that level.  But you can write the same Forth (witht he same wordset and philosophy) on different systems.
18:41:04 <I440r> but it also hides whats going on
18:41:18 <Xuz> That way you can decide to ahve 16 bit words or 32 bit words or even 64 bit words.
18:41:21 <I440r> correct thats teh isforth motto :)
18:41:40 <Xuz> ONly on one level.
18:41:46 <Xuz> On another level it makes what's going on clearer.
18:42:07 <I440r> well i disagree
18:42:11 <I440r> i have a nice quote for you
18:42:14 <I440r> from ibm
18:42:21 <I440r> im paraphrazing it slightly but....
18:42:37 <I440r> "we store the value of PI in a variable so that should the value of PI ever change....."
18:43:03 <I440r> people who make up NAMES for every fucking value are burying information in alph visual clutter
18:43:21 <I440r> specially when "cell" could be 2, 4 16, 32
18:43:32 <Xuz> If you're planning on running your program in two parallel universes, making pi a variable would be a very good idea :)
18:43:34 <I440r> if i want to do 2+
18:43:38 <I440r> i want to do TWO plus
18:44:00 <I440r> if i dont know the cell size of the machine my code is running on - i should give up my day job
18:44:09 <Xuz> Same way if you want to run your program on a 16 bit computer and a 32 bit one, being able to just say cell+ or cells is very useful.
18:44:44 <Xuz> Some parts of the code don't really need to care.  Or you could have [if] and friends have conditional definitions at the beginning for the functions that do.
18:44:47 <I440r> well - i think it causes more problems than it fixes
18:44:54 <I440r> just like the "OOP" philosophy
18:44:59 <I440r> hide everything from everyone
18:45:09 <I440r> bury the facts in a heap of obfuscation
18:46:29 <I440r> if a function in my program could be used in multiple locations
18:46:32 <I440r> i say it should be shared
18:46:43 <oxygene> what was it to get an array? 1000 cells allot compile foo?
18:46:44 <I440r> OOP would say "no - this function belongs to this blah blah"
18:46:46 <I440r> and not allow it
18:48:31 <I440r> im bvery set in my ways
18:48:37 <I440r> i hate the way most people code
18:48:45 <Xuz> create foo 1000 cells alot
18:48:50 <I440r> i even hate the way most people format their sources
18:48:54 <oxygene> thanks
18:48:55 <I440r> ya
18:49:05 <I440r> thtas the way i would do it
18:50:03 --- quit: I440r (Read error: 104 (Connection reset by peer))
18:50:09 --- join: I440r (mark4@pool-63.52.217.50.ipls.grid.net) joined #forth
18:50:10 <Xuz> Well, I dislike the way most people code, but for different reasons.
18:50:30 <Xuz> OOP sucks for many things.  However it might be useful for some things.  I dislike (in the extreme) languages that force you to stick to their idea of how code should be written . . . OR ELSE.
18:50:34 <Xuz> Welcome back.
18:50:51 --- mode: Xuz set mode: +o I440r
18:53:49 --- join: Speuler2m (~l@c38038.upc-c.chello.nl) joined #forth
18:54:24 * Xuz waves to Speuler2m
18:55:13 <Speuler2m> hi all
18:55:59 <Speuler2m> just stretched out, but started up the box to do a little bit more forth hacking 
18:56:28 <Speuler2m> might fall asleep anytime soon ...
19:00:43 <Speuler2m> i wonder whether 8 but jumps would be enough for bytecode forth
19:06:55 <Speuler2m> 8 bit ...
19:17:37 <Speuler2m> : fak ?dup if  dup 1- recursive fak * else 1 then  ;
19:18:42 <oxygene> Stepan: default_decode are all the tokens you didn't implement yet?
19:19:09 <Stepan> yep
19:19:40 --- join: TheBlueWizard (TheBlueWiz@ip-216-25-202-99.vienna.va.fcc.net) joined #forth
19:19:53 <TheBlueWizard> hiya all...wow, big crowd tonite
19:19:59 <Speuler2m> : fak dup 1 > if  dup 1- recursive fak * then  ;
19:20:18 --- mode: ChanServ set mode: +o TheBlueWizard
19:21:10 <oxygene> Speuler2m: recursive? not "recurse" ?
19:21:15 <Speuler2m> whose creation is the topic definition ?
19:21:16 * Xuz unafks
19:21:27 * Xuz oopses, wrong channel
19:21:39 <oxygene> Speuler2m: how does your implementation react on input <1 ?
19:21:47 <oxygene> Speuler2m: collab of stepan and me
19:22:41 <TheBlueWizard> hmm...both FC in /topic and fak presented recently are buggy
19:22:53 <oxygene> TheBlueWizard: why?
19:23:03 <oxygene> TheBlueWizard: FC works on OpenFirmware afaik
19:23:04 <Speuler2m> 2nd impl should return parameter unchanged
19:23:22 <TheBlueWizard> FC calls itself right away...infinite recursion as a result
19:23:59 <TheBlueWizard> also, "0 fak" returns 0...wrong
19:24:15 <Speuler2m> : fak ?dup if  dup 1- recursive fak * else 1 then  ;
19:24:19 <Speuler2m> 1st impl
19:24:35 <oxygene> TheBlueWizard: at least in OF recursive only _marks_ as recursive, recurse does that explicit recursion
19:25:30 <TheBlueWizard> ah....must be a dialect :P
19:25:49 <TheBlueWizard> then in that case FC is correct
19:25:51 <Stepan> pretty weird one indeed
19:26:43 <TheBlueWizard> not weird....factorial rules are:
19:26:52 <Speuler2m> i liked old-style "myself" better
19:27:00 --- quit: Stepan ("[x]chat")
19:27:01 <TheBlueWizard> (1) if input is zero, returns 1
19:27:30 <TheBlueWizard> (2) else return a product of that input times a factorial of input-1
19:28:21 <Speuler2m> if input < 0 ?
19:29:01 <TheBlueWizard> not defined...actually it is meaningless anyway
19:29:51 <oxygene> maybe that should return -1 or something to denote error - but that's also a matter of taste/style
19:29:56 <TheBlueWizard> if gamma function were used instead of factorial, and negative integers are mapped to gamma's equivalent, it gives infinities as a result
19:29:57 <Speuler2m> thus, infinite loop would be ok ?
19:30:29 <TheBlueWizard> if you like to see computer crash, or enjoy getting core dumps, fine
19:34:30 <Speuler2m> computer supposed to crash on arithmetic overflow ?
19:34:51 <Speuler2m> or infinite recursion ?
19:36:22 <TheBlueWizard> there are two schools of thought: one, that an app should be able to handle errors gracefully (which a HUGE majority subscribes to), and (2) it is your responsibility not to cause that in the first place (a rather vocal yet extremely tiny minority do)
19:36:23 <Speuler2m> (probably gets to overflow before it runs out of stack)
19:37:52 * TheBlueWizard favors graceful handling approach, where applicable
19:37:55 <Speuler2m> so the app must fix the user
19:38:39 <oxygene> and the user has to complain...
19:38:48 <Speuler2m> 2nd school probably states: how can what has been specified by user be an error ?
19:39:42 <oxygene> :)
19:39:53 <Speuler2m> 1st school says: user is potentially dumb
19:40:21 <TheBlueWizard> yeah...the second school basically say: I don't see any problem....what you get is what you get....
19:40:23 <oxygene> ms subscribes to 1st school with a small change: "user is always dumb"
19:40:42 <oxygene> hm... what you get is what you request?
19:40:58 * TheBlueWizard chuckles..."Good way to describe M$'s approach"
19:43:08 <TheBlueWizard> a simple example: starts an app and it pops up a question: "Enter filename to read from:", and you typed in a nonexistent filename (resulting from a typo, perhaps)
19:43:26 <TheBlueWizard> first school: Put up a message "There is no such file...."
19:43:54 <TheBlueWizard> Second school: (depoending...) *crash*, or gives garbage data
19:44:03 <Speuler2m> creates file...
19:44:14 <Speuler2m> zero len
19:44:39 <oxygene> Speuler2m: creates a handle for that file without creating it - ie. you can work on it as if there were a zero len file
19:45:32 <Speuler2m> after creating the file, the user is right again.
19:46:32 <Speuler2m> and open file r/w can conveniently create a file if it doesn't exist
19:46:43 <oxygene> _can_
19:47:04 <TheBlueWizard> does rerading a nonexistent file automatically create a file?  what if a devious attacker exploit that to clutter up the directory with junk filenames? :P
19:47:14 <TheBlueWizard> reading even
19:47:31 <Speuler2m> devious attacker is always right too
19:47:55 <TheBlueWizard> we have to make those attackers WRONG :)
19:48:31 <oxygene> TheBlueWizard: therefore that app opens as if it exists but it's zero and only creates on explicit save - and then checking all the user-rights...
19:49:48 <Speuler2m> if user got right to start app, why shouldn't he have rights to save files with it ?
19:50:17 <TheBlueWizard> if an attacker can run it, he would likely have the "desired" rights anyway
19:51:00 <Speuler2m> probably. it's not on app-level that privileges need to be checked
19:51:28 <oxygene> Speuler2m: maybe he may run that app but not access the directory writable?
19:51:43 <oxygene> of course that should be caught earlier
19:51:48 <Speuler2m> again, not the app should check that
19:52:19 <Speuler2m> if app denies, a program compiled to write files wouldn't
19:52:55 <oxygene> .o0O we need a completely different security design ;)
19:53:06 * TheBlueWizard nodsnodsnods
19:53:16 <TheBlueWizard> security is a complicated affair
19:53:29 * oxygene thinks the concept of VSTa is nice
19:53:45 <Speuler2m> well, here's your sandbox/home dir, play with it 
19:54:01 <Speuler2m> system files immutable
19:54:03 <oxygene> Speuler2m: ... and don't touch your quota ?
19:54:40 <Speuler2m> problem are files which may be touched/updated by serveral users
19:54:47 <Speuler2m> several
19:55:10 <oxygene> versioning fs?
19:55:20 <Speuler2m> that may be an answer
19:55:32 <Speuler2m> undo effects of user x
19:55:43 <oxygene> so every user may have his own branch which affects his personal quota
19:55:59 <oxygene> other users may merge the other branches into their own...
19:58:03 <Speuler2m> a file would basically just be a pointer to its version in the version archive
19:58:37 <oxygene> Speuler2m: accessible via filename,user,release or something like that
19:59:03 <Speuler2m> filename, version could be a good start
19:59:41 <Speuler2m> version snapshot a working system, to be able to fall back 
19:59:47 * TheBlueWizard feels it is getting Rube Goldbergish...and therefore wrong
19:59:50 <oxygene> hmmm the user has to be in the version, too... maybe the version something like user#number - "user" only gives the latest version of him
19:59:50 <Speuler2m> if something gets deleted/demolished
20:06:00 --- join: Stepan (~sr@dialin-145-254-228-033.arcor-ip.net) joined #forth
20:06:05 <Stepan> re
20:06:21 <TheBlueWizard> hiya Stepan
20:06:24 <Speuler2m> wb
20:06:44 --- mode: oxygene set mode: +o Speuler2m
20:06:46 --- mode: oxygene set mode: +o Stepan
20:07:17 --- quit: I440r ("Trillian (http://www.ceruleanstudios.com)")
20:07:54 <oxygene> Stepan: I guess the fcode return stack should be separate from normal forth return-stack, hm?
20:09:29 <Stepan> no, why?
20:10:13 <oxygene> Stepan: hmm... because there isn't any "normal" forth word at these addresses
20:10:44 <oxygene> Stepan: therefore there's special care to be taken - but maybe that's even better ;)
20:17:40 <oxygene> hmmm... gforth segfaults *g*
20:18:45 <TheBlueWizard> yah *g*
20:20:43 <Stepan> normal forth word?
20:20:53 <Stepan> no. no extra stacks.
20:21:06 <Stepan> we want a small implementation
20:21:14 <Stepan> i dont see we need that
20:21:39 <Stepan> a fcode word is just another flag to a forth word, like immediate 
20:21:56 <Stepan> or am i wrong? ;)
20:23:11 <oxygene> Stepan: an fcode word is a forth-word (maybe anonymous) that appears in the fcode-lookup table
20:23:20 <oxygene> Stepan: or is there any flaw-by-design?
20:35:13 <Stepan> why dont we just use fcode words as normal forth words with the special attribute that it can occur in fcode binaries?
20:35:33 <Stepan> any fcode word has to have an execution token, exactly like a normal forth word does
20:35:36 <oxygene> Stepan: as we still don't have some useful mapping for the fcode-numbvers
20:35:58 <Stepan> what do you consider useful mapping?
20:36:12 <oxygene> Stepan: eg. your dictionary[0x1000]
20:36:27 <Stepan> that sucks anyways and has to go away
20:36:42 <Stepan> it doesnt cover instance specific words and variables
20:37:47 <oxygene> it seems to me that it's still not clear how fcode is handled - as runtime stuff, as one-time-compile to {c,forth,asm} or as jit-compile to {c,forth,asm} ;)
20:38:08 <Stepan> there is no jit
20:38:37 <Stepan> and there is never compiled anything to asm/c.. open firmware is interpretative
20:39:24 <Stepan> grr.. my phone update did not work
20:39:51 <oxygene> read the article from e.rather on l.c.f - it may be compiled even to python if one likes (one wouldn't do in practice ;) but it's not defined how to handle that
20:40:08 <Stepan> no it may not.
20:40:26 <Stepan> any compilation would complicate stuff more than necessary
20:40:51 <oxygene> of course we won't do it for simplicity...
20:41:16 <Stepan> i read that stuff from elizabeth, but i don't see any point in something being different from plain interpretation
20:42:35 <Stepan> We don't need speed, we need it stable and small.
20:43:03 <oxygene> so we interpret it as as far as I could see it fcode-stuff is mostly packed into b(:)-definitions
20:43:45 <Stepan> b(:) is the fcode word tokenized when : is encountered
20:44:49 <oxygene> I know - and it looks like it's not very useful to actually do anything except lots of word-definitions inside a package- at least I haven't seen something else yet
20:46:06 <Stepan> partly true
20:46:25 <Stepan> it generates a package and adds information to the device tree
20:46:38 <Stepan> that is not done within a colon definition
20:47:17 <Stepan> but all driver functionality is realized by defining words or "filling" defer words
20:49:08 <Stepan> an fcode program may use forth words when it knows their xt, and the other way round can a non fcode forth program call an fcode word when it knows it's name or fcode number
20:49:44 <Stepan> this interoperability makes me scared of different stacks
20:49:44 <oxygene> hmmm... a normal forth word can use fcode words only when its package is opened, right?
20:50:09 <Stepan> or when it's one of the standard words
20:50:14 <oxygene> ok
20:50:30 <oxygene> so we can use one global fcode#-table
20:50:52 <Stepan> in a package, you normally need an instance to execute a method, but not always
20:51:00 <oxygene> which may change, words that get deleted from that table should be deleted from dictionary, too...
20:51:45 <oxygene> so it may even be possible to run a method directly from fcode? or could be establish some "if word foo is requested compile it then run" behaviour ?
20:51:50 <Stepan> but 2 packages can have the same words (same # and/or name)
20:52:06 <oxygene> hmmm. what if one package requests such a word from the other package?
20:52:10 <Stepan> you can run a method from fcode yep
20:52:40 <Stepan> no, the word is "compiled" when the package is read.
20:52:51 <oxygene> ah, because of package-open
20:53:05 <oxygene> erm it's called open-package iirc ;)
20:53:11 <Stepan> executing the package only builds the structure in the devtree
20:53:18 <Stepan> for later use with open-package
20:54:03 <oxygene> so we can have something like /sbus/foo/bar/#300->adress-of-word as mapping?
20:54:27 <Stepan> hmmm
20:54:46 <oxygene> not #300 of course ;)
20:54:52 <oxygene> something like #800 ;)
20:55:13 <Stepan> my current approach forsees a linked list in the package structure where all words defined by a package reside
20:55:18 <Stepan> hehe
20:55:39 <oxygene> eeks, pointer-madness!!!
20:55:56 <Stepan> this comes very close to it,... a word in the package always overwrites a word in the default table
20:56:20 <Stepan> why madness?
20:56:37 <oxygene> I have some pointerphobia ;)
20:56:42 <Stepan> :-)
20:56:50 <oxygene> esp. in that non-intuitive style of C
20:56:56 <Stepan> bla :)
20:57:05 <Stepan> it's just the most natural way
20:57:31 <Stepan> *giggle*
20:57:38 * oxygene is not natural ;)
20:58:04 * Stepan feels some forth c interference in the air
20:58:10 <oxygene> hehe :)
20:58:51 * oxygene rather stays with the core-packages et al.
20:59:32 <Stepan> this mapping,... how would you use that
20:59:52 <oxygene> it would also need a name-mapping
20:59:57 <Stepan> damnit.. it's both assembler in the end... it can't be that hard to find the best way :-)
21:00:25 <oxygene> so both /sbus/foo/bar/baz and /sbus/foo/bar/#800 point to the word in the fcode-stuff
21:00:33 <Stepan> tell me how a dictionary works in forth normally
21:00:47 <Stepan> you "compile a word into the dictionary"... for example
21:00:47 <oxygene> if any of these is requested, the scope is set that directory and the code is run
21:00:52 <oxygene> compile a word:
21:01:31 <Stepan> i mean, what is the dictionary... flat memory containing information? or does it take some additional information on each word in the dictionary itself?
21:01:39 <Stepan> or is that seperate in a lookup table?
21:01:58 <oxygene> the format is (at least similar to) the following:
21:02:09 <Stepan> I have to know more about these internals and i dont get a clue just by reading this4th, vnpforth, et al
21:03:28 <oxygene> len_of_wordname wordname statusbyte(immediate,smudge,...) link_to_previous_word link_to_handler(normally NEXT) pointers_to_words
21:04:50 <oxygene> so it's completely selfcontained - if may be different of course (eg. i440r does it in a different way)
21:07:29 <Stepan> pointers_to_words is the compiled program?
21:07:44 <oxygene> yep
21:07:48 <Stepan> what is smudge?
21:08:08 <oxygene> a new word gets the smudge-bit set
21:08:14 <oxygene> it gets cleared when the word is closed
21:08:30 <oxygene> has to do something with saneness or something
21:08:41 <Stepan> so the dictionary is a mixture between a linked list and a stream
21:09:00 <Xuz> It's so it's not visible to dictionary searches until it hits the ;
21:09:02 <oxygene> right... you could also split out the stream by placing a second link to the streams
21:09:03 <Stepan> yepp. cool.. so smudge is deleted when ; is encountered?
21:09:10 <Xuz> So you could (if you wanted) redefine . so it called the old .
21:09:16 <oxygene> Xuz: ah, ok...
21:09:27 <oxygene> Xuz: and to prevent unclosed definitions, right?
21:09:58 <Stepan> Xuz: how?
21:09:59 <Xuz> Yes.  Though I think most systems simply forget the word if the compilation errors out or something.
21:10:17 <Stepan> by placing the pointer to the old word into the stream of the new .?
21:10:22 <Xuz> Well, let's say you wanted . to print all the numbers in yellow.
21:10:46 <Xuz> You could do something like : switch-to-yellow . switch-to-white ;
21:11:11 <oxygene> ok...
21:11:22 <Stepan> ah. i get it.. because the new . is not visible yet the old one gets used when . is encountered
21:11:49 <oxygene> Stepan: right, as the dictionary is searched by using those linked-list between words...
21:12:28 <Xuz> And new definitions don't get REPLACED, they just get obscured.
21:12:45 <Xuz> So something that uses . will still use the old ., unless IT was defined after the new . was defined.
21:13:35 <oxygene> Xuz: and recursive (in the meaning of the /topic-definition) clears the smudge-bit from the beginning on...
21:13:44 <Stepan> hm.. when implementing fcode, what would speak against using the same scheme for fcode words instead of a fixed token_t dictionary[0x1000]?
21:14:16 * Stepan feels some warming light..
21:14:21 <oxygene> hmm... nice idea
21:14:39 <oxygene> that way we can FORGET newer, overlaying definitions when closing packages
21:15:03 <oxygene> with the difference, that there is no length and name but simply two bytes as identification...
21:16:02 <Xuz> Well, it depends.
21:16:15 <Xuz> Some words have 'recurse' instead of 'recursive' which I think is better.
21:16:31 <Stepan> an fcode word can have a name, too
21:16:39 <oxygene> Stepan: ahh, right...
21:16:46 <oxygene> then it gets an additional field
21:16:49 <Stepan> oxygene: why would it not have a len?
21:17:19 <oxygene> Stepan: the len is only for the name - as I thought we'd drop the name I also wanted to drop the len of course :)
21:17:43 * aaronl is back (gone 06:17:30)
21:18:51 <Stepan> yepp.. and whether that field is available can be triggered by a flag in the status byte
21:18:54 <Stepan> ?
21:19:19 <Stepan> yepp.. indeed...
21:19:28 <Xuz> Well, recurse doesn't give it an extra field, so much as just put the XT in the stream.
21:20:04 <Stepan> not recurse, rather whether it's an fcode word or a normal forth word
21:20:08 <oxygene> Xuz: of course... and it keeps the smudge-bit the way it should be
21:20:39 <Stepan> if it's an fcode word, it needs an additional field fcode# but may lack word name
21:20:41 <Xuz> Oh!
21:20:51 <Xuz> Sorry, I grouped that in with the wrong thread.
21:21:08 <oxygene> Stepan: hmm... the namespace of fcode# is restricted to 0xfff - so let's define 0x4fff or something like that as "this is a normal forth-word" designator
21:21:12 <Stepan> hehe.. multitasking discussion is hard at 6:20 in the morning
21:21:29 <Stepan> oxygene: sounds good to me
21:21:46 <oxygene> Stepan: so we have 2 bytes more for non-fcode words but no extra cases....
21:22:14 <Stepan> i wonder whether a word created by a package always has an fcode #
21:22:29 <oxygene> is that important?
21:23:14 <oxygene> I think export-only words (ie. not used from the package itself) may be name-only
21:23:20 <Stepan> i am not sure. just trying to complete the picture
21:23:44 <Stepan> yepp.. that would be all package methods probably
21:36:09 <Stepan> ok.. how is a defer word handled in the dictionary, and how a variable?
21:38:07 <oxygene> Stepan: see variable - it's a special type of creating a word
21:38:17 <oxygene> Stepan: defers *thinking* good question :)
21:40:16 <Stepan> defer words is something i really suppressed up to now, but unfortunately openfirmware is full of it
21:40:25 <oxygene> hehe
21:40:31 <oxygene> it could work with '
21:41:06 <Stepan> all the console functionality is a weird interaction of base defer words getting initialized by the display drivers and being used by the terminal emulation package
21:41:12 <oxygene> ie. a run-time search for that word
21:41:21 <Stepan> ' gets the execution token of a word?
21:41:24 <Xuz> How's it work as in "How do I use one?" "What kind of mechanics are behind it?" or "How do I implement DEFER/IS in ANS forth?"
21:44:11 <Stepan> Xuz: what i beliefe to know is that a defer word is an "empty" word that can be overloaded, and I've seen code snippets overloading/implementing defer words, but I don't know any more
21:44:30 <Stepan> so what i need to know is mostly the mechanism behind it..
21:44:38 <oxygene> Stepan: look into '
21:44:47 <Xuz> (1) You can't define DEFER in ANS Forth because ANS Forth sucks.
21:45:01 <oxygene> Stepan: it does a search through the dictionary from newest to oldest and stops at the first hit...
21:45:46 <oxygene> Stepan: so when calling a defer word called foo it does a search for foo and stops when it 1. got something, then runs it, 2. hits itself, then stops...
21:45:48 <Stepan> oxygene: but what does one need a defer word for then? 
21:46:05 <Stepan> ah
21:46:06 <Xuz> (2) You usually use something like NEW-WORD DEFER
21:46:06 <oxygene> Stepan: it hides that search-logic etc.
21:46:25 <Xuz> Then you have an XT on the stack and use IS NEW-WORD
21:46:58 <Xuz> The way I've seen it implemented is in systems where you have (for example) a NAME, BODY and CODE field in the dictionary.
21:47:30 <Xuz> Normally the CODE points to something with a name called DOCOL which handles a colon definition and whatnot.  And the BODY points to the XTs.
21:48:13 <Xuz> With DEFER you would have the BODY point to the XT of the word you want to run, then have the CODE field point to a routine that calls that XT's code section on its BODY.
21:50:39 <Xuz> And. . . . let's say you had a program that did a bunch of stuff and wanted to confirm each step by default.
21:50:39 <Stepan> on it's body? so defer word behaves as it is the defer word but another one is executed instead?
21:50:55 <Xuz> It's basically just pointing to the XT of the other word, yes.
21:51:10 <TheBlueWizard> gotta go...bye all (it was fun listening...)
21:51:21 <Stepan> bye TheBlueWizard :-)
21:51:25 --- part: TheBlueWizard left #forth
21:51:33 <Xuz> You could have a word called CONFIRM and make it a DEFER word.
21:52:15 <Xuz> By default you could do 'REALCONFIRM IS CONFIRM.  REALCONFIRM would actually prompt the user and whatnot.
21:52:34 <Xuz> But if the user decided to run it in batch mode or somethign and not have to confirm everything you coulde do ' SOME-NOOP-OR-OTHER IS CONFIRM
21:53:20 <oxygene> that's a nice hack :)
21:53:20 <Xuz> Then your functions like DANGEROUSDISKOPERATION could jsut call CONFIRM and not have to test any flag at all to see if they were supposed to ask for confirmation or not.
21:54:24 <Xuz> Forth is a beautiful thing :)
21:54:55 <Xuz> Consider it's small and fast and you can get almost-first-class-functions, almost-closures, and almost-continuations (supposedly, I'm not quite sure how) out of it.
21:55:06 <Xuz> You probably have to violate ANS :)
21:55:27 --- quit: Speuler2m (Read error: 113 (No route to host))
21:56:03 <Stepan> hehe.
21:56:19 <Stepan> Xuz: are you familiar with open firmware?
21:57:22 <Xuz> Or like he was saying with Open Firmware, you might have I/O functions like . and whatnot that need to do different things depending on hardware connected.  Make all of the words for it DEFERRED and just IS them after initializing hardware.
21:57:52 <Xuz> I was playing with it once, but then someone came in, yelled, "Get the hell away from my Sun!" and chased me off with a stapler.
21:58:34 <Stepan> yep with defer you can handle interaction between the drivers fast and easily
21:59:52 <Stepan> oxygene: while playing with that mandelbrot thingie i found another few bugs in smartfirmware from codegen
22:00:02 <Stepan> but i did not track them down
22:00:29 <Stepan> sad enough feval is not fully capable of do..loop constructs
22:00:29 <oxygene> Stepan: smartfirmware is so smart it even makes human-like mistakes ;)
22:00:38 <Stepan> :-))
22:00:47 * Xuz giggles
22:00:52 <oxygene> Stepan: yeah, the code looks strange
22:01:04 <Stepan> heh.. my code looks beautiful
22:01:05 --- mode: Stepan set mode: -n
22:01:05 --- mode: ChanServ set mode: +n
22:01:06 --- mode: Stepan set mode: -n
22:01:07 --- mode: ChanServ set mode: +n
22:01:11 <Stepan> argl
22:01:13 <Stepan> sorry
22:01:38 * Xuz snickers
22:01:39 * Xuz afks
22:04:39 <Stepan> g'night Xuz.. thanks a lot!
22:09:08 * Xuz unafks
22:09:11 <Xuz> Sleep well.
22:19:24 --- quit: Stepan ("[x]chat")
22:29:03 --- join: Stepan (~stepan@dialin-145-254-228-033.arcor-ip.net) joined #forth
22:29:06 <Stepan> re
22:29:38 <Xuz> Welcome back.
22:30:04 <Stepan> :) I moved over to my room
22:30:27 <Stepan> much nicer an warm and causy
22:30:43 <Xuz> Excellent.
22:32:52 <Stepan> so i guess ans forth is just like ansi c somewhat limited to no bells and whistles?
22:33:19 <Xuz> Well. . . . . 
22:33:56 <Xuz> One of the goals of ANS forth was to make existing forths have to do as little as possible to be conforming.
22:34:17 <Xuz> So, for example, unlike Forth-83 it didn't even specify what things like < and > would return to mean true.
22:34:46 <Xuz> Which takes away the ability to do things like use truth values in mathematical expressions.
22:41:54 <Stepan> what's a create word?
22:42:11 <Stepan> :) sorry for all these stupid questions..
22:42:50 <Xuz> It's a word that calls create :)
22:43:11 <oxygene> ":" "variable" "constant" "dictionary" ...
22:44:40 <Xuz> As well as anything you might do with CREATE/DOES>
22:44:54 <Stepan> ah 8)
22:45:46 <Stepan> hmm.. if a word is deleted from the dictionary, do normal forth engines reuse the dictionary space?
22:45:50 <Xuz> create/does> is one of the niftiest ideas that Forth has.
22:45:56 <Xuz> Words don't get deleated from the dictionary.
22:46:07 <oxygene> Xuz: forget ?
22:46:22 <oxygene> Stepan: you can only reclaim parts from the dictionary at the top
22:46:31 <Xuz> That's a special case :)
22:46:40 <oxygene> Stepan: ie. : a ; : b ; : c ; forget a removes a, b and c
22:46:46 <Xuz> If you forget "foo" you destroy everything from FOO on up.
22:46:47 <Stepan> so every package needs it's own dictionary
22:49:47 <Xuz> Depends on the size of the package.  I don't think it's really all that common to have a running program need to forget a word.  IIRC, it's mostly used in development.  Start coding, working, trying stuff out, and then 'forget' it later on if it's lousy.
22:50:47 <oxygene> Xuz: I think it's needed to be able for implementing OpenFirmware :)
22:51:12 <Xuz> Oh?  What do they do with it in there?  I'm curious?
22:53:54 <oxygene> Xuz: opening and closing packages all the time - that means installing instances of certain words from binary-representation (fcode) into something useful
22:55:58 <Xuz> That might be useful :)
23:01:39 * Xuz thinks it would be nice to have a Forth where you : would be threaded and :opt would do native-code-with-optimization.
23:07:15 <Xuz> Or even have :thread and :opt, with : vectored.
23:11:03 * Xuz hmmmms. . . . he should write another forth :)  Only one he's done was for the 65816 and it was just a straightforward one because Mad Apple Forth was atrocious.
23:26:00 * aaronl is away: early sleep
23:35:53 <Stepan> n8
23:35:56 --- quit: Stepan ("Client Exiting")
23:59:59 --- log: ended forth/01.12.30