00:00:00 --- log: started forth/12.06.09
00:22:12 <ttmrichter> fantazo: I was pretending I'd screwed up a parser and thus output "Forth" instead of "honk".
00:22:17 <ttmrichter> Stupid joke, I know.
00:22:42 <ttmrichter> "Sau," I thought, was German for "sow"?
00:24:45 --- join: I440r (~zhiming@213.sub-166-249-129.myvzw.com) joined #forth
00:24:45 --- mode: ChanServ set +o I440r
00:33:19 --- quit: I440r (Ping timeout: 245 seconds)
00:56:15 <fantazo> ttmrichter, both is true.
00:59:46 --- join: I440r (~zhiming@9.sub-166-249-130.myvzw.com) joined #forth
00:59:46 --- mode: ChanServ set +o I440r
01:08:26 --- quit: I440r (Ping timeout: 245 seconds)
01:34:47 --- join: I440r (~zhiming@186.sub-166-249-128.myvzw.com) joined #forth
01:34:47 --- mode: ChanServ set +o I440r
01:44:01 --- quit: I440r (Ping timeout: 256 seconds)
02:03:26 --- quit: DGASAU (Remote host closed the connection)
02:06:47 --- join: DGASAU (~user@91.218.144.129) joined #forth
02:06:47 --- mode: ChanServ set +v DGASAU
02:09:51 --- join: I440r (~zhiming@186.sub-166-249-128.myvzw.com) joined #forth
02:09:51 --- mode: ChanServ set +o I440r
02:18:49 --- quit: I440r (Ping timeout: 252 seconds)
02:45:14 --- join: I440r (~zhiming@166.249.130.68) joined #forth
02:45:14 --- mode: ChanServ set +o I440r
02:53:55 --- quit: I440r (Ping timeout: 265 seconds)
03:06:23 --- quit: DaDaDOSPrompt (Quit: Leaving)
03:19:51 --- join: I440r (~zhiming@98.sub-166-249-128.myvzw.com) joined #forth
03:19:51 --- mode: ChanServ set +o I440r
03:25:11 --- quit: ttmrichter (Quit: Leaving)
03:28:43 --- quit: I440r (Ping timeout: 265 seconds)
03:34:34 --- quit: DGASAU (Remote host closed the connection)
03:35:14 --- join: DGASAU (~user@91.218.144.129) joined #forth
03:35:14 --- mode: ChanServ set +v DGASAU
03:54:46 --- join: I440r (~zhiming@189.sub-166-249-131.myvzw.com) joined #forth
03:54:46 --- mode: ChanServ set +o I440r
04:04:00 --- quit: I440r (Ping timeout: 265 seconds)
04:29:42 --- join: I440r (~zhiming@106.sub-166-249-129.myvzw.com) joined #forth
04:29:42 --- mode: ChanServ set +o I440r
04:38:52 --- quit: I440r (Ping timeout: 260 seconds)
05:01:11 --- quit: fantazo (Remote host closed the connection)
05:04:43 --- join: I440r (~zhiming@232.sub-166-249-132.myvzw.com) joined #forth
05:04:43 --- mode: ChanServ set +o I440r
05:13:33 --- quit: I440r (Ping timeout: 244 seconds)
05:39:48 --- join: I440r (~zhiming@181.sub-166-249-131.myvzw.com) joined #forth
05:39:49 --- mode: ChanServ set +o I440r
05:48:43 --- quit: I440r (Ping timeout: 248 seconds)
05:56:21 --- quit: phirsch (Ping timeout: 245 seconds)
06:04:05 --- join: phirsch (~phirsch@xdsl-89-0-155-103.netcologne.de) joined #forth
06:04:09 --- mode: ChanServ set +v phirsch
06:14:43 --- join: I440r (~zhiming@232.sub-166-249-132.myvzw.com) joined #forth
06:14:43 --- mode: ChanServ set +o I440r
06:23:49 --- quit: I440r (Ping timeout: 244 seconds)
06:28:43 --- join: MayDaniel (~MayDaniel@unaffiliated/maydaniel) joined #forth
06:28:43 --- mode: ChanServ set +v MayDaniel
06:49:36 --- join: nighty^ (~nighty@69-165-220-105.dsl.teksavvy.com) joined #forth
06:49:37 --- mode: ChanServ set +v nighty^
06:49:47 --- join: I440r (~zhiming@106.sub-166-249-129.myvzw.com) joined #forth
06:49:47 --- mode: ChanServ set +o I440r
06:54:18 --- join: ttmrichter (~ttmrichte@61.184.206.221) joined #forth
06:54:18 --- mode: ChanServ set +v ttmrichter
06:57:31 --- quit: I440r (Ping timeout: 265 seconds)
07:12:50 --- join: I440r (~zhiming@127.sub-166-249-133.myvzw.com) joined #forth
07:12:50 --- mode: ChanServ set +o I440r
07:22:09 --- join: SplinterOfChaos (~soc@cblmdm24-52-84-142.buckeyecom.net) joined #forth
07:22:09 --- mode: ChanServ set +v SplinterOfChaos
07:35:25 --- quit: I440r (Ping timeout: 245 seconds)
07:35:49 --- join: RodgerTheGreat (~RodgerThe@71-13-215-128.dhcp.mrqt.mi.charter.com) joined #forth
07:35:49 --- mode: ChanServ set +v RodgerTheGreat
08:23:47 --- quit: MayDaniel (Read error: Connection reset by peer)
08:53:56 --- quit: SplinterOfChaos (Quit: Leaving)
08:55:16 --- join: SplinterOfChaos (~soc@cblmdm24-52-84-142.buckeyecom.net) joined #forth
08:55:17 --- mode: ChanServ set +v SplinterOfChaos
09:07:49 --- quit: ttmrichter (Quit: Leaving)
09:43:24 --- join: ASau` (~user@176.14.240.113) joined #forth
09:43:24 --- mode: ChanServ set +v ASau`
09:45:43 --- join: Onionnion (~ryan@adsl-76-230-151-120.dsl.milwwi.sbcglobal.net) joined #forth
09:45:44 --- mode: ChanServ set +v Onionnion
09:46:53 --- quit: ASau (Ping timeout: 252 seconds)
10:57:21 --- join: fantazo (~fantazo@91.119.75.149) joined #forth
10:57:21 --- mode: ChanServ set +v fantazo
11:08:59 --- join: _spt_ (~in@host-92-4-58-160.as43234.net) joined #forth
11:09:08 --- quit: _spt_ (Changing host)
11:09:08 --- join: _spt_ (~in@unaffiliated/-spt-/x-5624824) joined #forth
11:09:08 --- mode: ChanServ set +v _spt_
11:46:50 --- join: Monevii (~Monevii@adsl-64-237-234-175.prtc.net) joined #forth
11:46:50 --- mode: ChanServ set +v Monevii
11:46:57 --- join: Kumul (~Kumul@adsl-64-237-234-175.prtc.net) joined #forth
11:46:57 --- mode: ChanServ set +v Kumul
12:28:27 --- join: MayDaniel (~MayDaniel@unaffiliated/maydaniel) joined #forth
12:28:27 --- mode: ChanServ set +v MayDaniel
12:33:10 --- quit: MayDaniel (Read error: Connection reset by peer)
12:37:13 --- part: _spt_ left #forth
14:05:16 --- quit: Onionnion (Ping timeout: 265 seconds)
14:16:39 --- join: Onionnion (~ryan@adsl-76-230-209-91.dsl.milwwi.sbcglobal.net) joined #forth
14:16:39 --- mode: ChanServ set +v Onionnion
15:12:39 --- join: black_13 (425ad9a8@gateway/web/freenode/ip.66.90.217.168) joined #forth
15:12:39 --- mode: ChanServ set +v black_13
15:12:59 <black_13> anyone home
15:25:44 <RodgerTheGreat> I am
15:32:23 <RodgerTheGreat> what's up, black_13?
15:32:56 <black_13> RodgerTheGreat: i had some questions about forth or more about what it takes to make a forth
15:33:05 <RodgerTheGreat> I might be able to help
15:33:23 <RodgerTheGreat> I'm not expert but I've written some forth compilers and used the language a fair bit
15:33:32 <black_13> i found a great forth system at http://www.math.uiuc.edu/~gfrancis/illimath/audible/vowels/bbn.C
15:33:37 <black_13> this thing is wonderfull
15:33:44 <black_13> its small!
15:33:52 <RodgerTheGreat> nice
15:34:12 <RodgerTheGreat> that looks pretty compact
15:34:18 <black_13> and it works!
15:34:38 <black_13> i compiled it using vs 2010 
15:34:44 <black_13> with almost no change
15:34:55 <black_13> i was able to define new words
15:35:12 <black_13> for example ": square DUP + ;" 
15:35:33 <RodgerTheGreat> I think you mean : square dup * ;
15:35:39 <black_13> then run "2 DUP ." gives "4 ok"
15:36:04 <RodgerTheGreat> but yeah, that sounds like it's working
15:36:07 <black_13> you would think that but 
15:36:23 <black_13> the intrisic words like dup are uppercase 
15:36:41 <black_13> however there are some things i dont understand like nest or unnest
15:36:55 <RodgerTheGreat> my main point was that to square something you multiply it by itself, not add it to itself
15:37:40 <black_13> yeah that would be ": square DUP *;"
15:37:53 <RodgerTheGreat> and be careful with your whitespace
15:38:16 <black_13> sorry it would be ": square DUP * ;" 
15:38:25 <RodgerTheGreat> there you go
15:38:39 <black_13> so a couple of things
15:38:55 <RodgerTheGreat> so mainly you want to know how to learn about what words do?
15:39:04 <black_13> you read my mind
15:39:14 <black_13> and how "threading works"
15:39:29 <black_13> the nice thing about such a small system is you can understand it
15:39:33 <RodgerTheGreat> one of the first places I often go is the manual for GForth, which is a fairly well-documented ANS standard forth: http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/Word-Index.html#Word-Index
15:39:50 <RodgerTheGreat> when you say threading, do you mean as in "threaded code"?
15:39:52 <black_13> and then i could put micro controller
15:40:21 <black_13> i understand that if do the following "1 1 + ."
15:40:30 <black_13> i understand what happens when that is
15:40:32 <black_13> done
15:40:55 <black_13> 1 1 are not in the dictionary and are placed on the parameter stack
15:41:15 <black_13> "+" is in the well know dictionary and so is "." 
15:41:19 <RodgerTheGreat> they aren't in the dictionary and they parse as a number
15:41:26 <black_13> exactly
15:41:27 <RodgerTheGreat> yes
15:42:19 <black_13> if i was given an assignment in junior level comp science class on how to come up with stack machine calculator
15:42:21 <black_13> i could
15:43:07 <black_13> i would probably write stack that was an array of stucts and vector of functions mapped to character array
15:43:21 <black_13> essentiall i could figure out how make really nice calculator
15:43:36 <black_13> but the creation of new words is beyond me.
15:44:19 <black_13> however i will look at the link you sent
15:44:35 <RodgerTheGreat> have you had a look at Starting Forth? http://www.forth.com/starting-forth/
15:44:41 <RodgerTheGreat> it's a really good introductory text
15:45:15 <RodgerTheGreat> I think if you learn about a few words like HERE, ALLOT and , (COMMA) understanding the innards of : will be easier
15:45:37 <black_13> ok
15:45:53 <black_13> yeah i have been reading the starting forth text
15:45:55 <RodgerTheGreat> a dead tree copy is nice to have if you think you're really into learning about Forth, but the online edition is great too
15:46:05 <black_13> inbtween working
15:46:47 <RodgerTheGreat> chapter 9 goes into a great deal of detail about how the dictionary works and new words are created
15:46:50 <black_13> i really think that forth could be usefull on small systems the code that put in the link compiles to 26k release
15:47:17 <RodgerTheGreat> the precise implementation may be different in that C code you linked, but the basic principles are probably similar
15:47:28 <black_13> if i could get it to run on an msp430 or stellaris machine that would be fan frickin tastic
15:47:57 <RodgerTheGreat> I don't know as much about forth on microcontrollers, but I have heard it works out really spiffy
15:48:23 <RodgerTheGreat> I do know that many MSP430s have *really* restricted flash and ram space
15:48:56 <black_13> the one thats that i have have about 96k
15:49:09 <RodgerTheGreat> oh yeah, that should be plenty
15:49:45 <RodgerTheGreat> I was imagining something like the chips that come with the Launchpad dev kit that have 2k flash
15:49:47 <black_13> own thing i am curious about is word size that is 32 versus 16 
15:50:13 <RodgerTheGreat> usually forth implementations have a word called "CELL" which gives you the size of a word on the system
15:50:14 <black_13> oops you right yeah the lauchpad is SMALL
15:51:11 <RodgerTheGreat> fitting forth in 2k would be a challenge, but it all depends on what you're trying to do with it. An interactive system would be really tight, but if you just used a target compiler it could still work well
15:51:27 <Kumul> what assembly written forths are there?
15:51:40 <RodgerTheGreat> JonesForth is probably the best known one
15:52:10 <black_13> i was leaning to something that could host an interpreter
15:52:48 <RodgerTheGreat> well, 96k is plenty of rom space. If you have at least a few k of ram you should be good
15:53:03 <black_13> that would be the stellaris chips
15:53:08 <black_13> i have a few of those
15:53:15 <black_13> or the arduino
15:53:43 <black_13> i will look at the links your provided
15:54:12 <RodgerTheGreat> here's something like a Forth that runs on an arduino: https://github.com/lpereira/finf
15:54:41 <black_13> i saw that it was assembly based?
15:55:36 <RodgerTheGreat> if you check the source on that it appears to be written in arduino C
15:56:02 <black_13> i dont see the link there for the sourcde
15:56:39 <RodgerTheGreat> https://github.com/lpereira/finf/blob/master/finf/finf.pde
15:56:47 <black_13> oops sorry thats write
15:56:55 <black_13> or right
15:57:27 <black_13> thanks!
15:58:13 <black_13> wow i had seen that before and thought that was a hex file
15:58:21 <black_13> snorted and moved on
15:58:31 <black_13> that is small and small is good
15:58:48 <RodgerTheGreat> not nearly as compact as BBN.C, but hey
15:59:09 <black_13> still
16:00:27 <black_13> i had seen another interpreter called "wren" that used similar ideas but had used the __attribute__((packed)); this would not compile on visual studio at all
16:00:44 <black_13> its gcc only if im right
16:04:11 <black_13> ALLOT seems to take part in allocating memory
16:04:19 <RodgerTheGreat> yes
16:04:35 <black_13> have you heard of "nest" and "unnest"
16:04:35 <RodgerTheGreat> it's sort of the raw word that allocates some number of bytes
16:04:55 <RodgerTheGreat> I'm not familiar with those names
16:05:23 <black_13> yeah doing a search in the forth books does not bring up anything
16:05:41 <black_13> they are peculiarities of bbn.C forth
16:11:09 <black_13> whats the paster for this channel
16:12:21 <Kumul> there isnt!
16:12:42 <RodgerTheGreat> sometimes I use hastebin.com, but they don't do forth syntax highlighting. :/
16:12:54 <RodgerTheGreat> usually it assumes I'm using AVR assembly or something
16:13:57 <black_13> so i wonder if this this struct that is the "word": http://pastebin.com/s7HGAurf
16:15:26 <Kumul> why dont you use factor's? http://paste.factorcode.org/new-paste
16:15:31 <RodgerTheGreat> my guess would be that struct is what precedes the body of a word
16:17:09 <RodgerTheGreat> I often make my forth compilers unnecessarily complicated by supporting names of arbitrary length
16:18:23 <black_13> yeah this guy seems to have them be 27 chars long
16:33:22 <black_13> it seems that its related to creating memory
16:38:48 <RodgerTheGreat> when you create a word you generally allocate a header in the dictionary, populate it and then append to the end of the result as you build up the word definition
16:39:19 <RodgerTheGreat> what it means to "build up the word definition" varies based on what type of threading you're using (if at all)
16:44:02 <black_13> did the books you mentioned previously talk about the threading methods?
17:02:26 <black_13> RodgerTheGreat: thanks for the advice
17:02:33 <black_13> its dinner time
17:02:45 --- quit: black_13 (Quit: Page closed)
18:00:19 --- join: ttmrichter (~ttmrichte@61.183.22.194) joined #forth
18:00:19 --- mode: ChanServ set +v ttmrichter
18:07:15 <Onionnion> o/
18:07:38 <RodgerTheGreat> hi Onionnion 
18:08:19 * Onionnion just started a high resolution smoke simulation bake that goes for 220 frames >.>
18:08:41 <RodgerTheGreat> how long does a frame take?
18:08:53 <Onionnion> 1.5 minutes about?
18:09:04 <Onionnion> my cpu sucks
18:09:16 <RodgerTheGreat> dang
18:09:28 <Onionnion> eh maybe shorter
18:09:29 <RodgerTheGreat> what is this for?
18:09:43 <Onionnion> personal stuff, just playing around with Blender
18:10:11 <Onionnion> and a friend wants me to do some sfx for some small videos he's making over the summer, camera tracking stuff
18:10:28 <Onionnion> eh, shorter than 1.5 min. probably 3/4 of a min
18:10:31 <RodgerTheGreat> I wonder how terrifying it would be to integrate forth as a scripting language for blender
18:10:34 <Onionnion> sped up a bit
18:11:02 <Onionnion> uffda, let's stay with python there, please :P
18:11:15 <Onionnion> at least I'm on linux so it'll never crash
18:11:24 <RodgerTheGreat> ahaha
18:13:07 <Onionnion> or maybe I can have someone do a bake for me who has a better cpu
18:13:45 <Onionnion> oh wow this is awesome, they added info for what's going on in the terminal
18:13:55 <RodgerTheGreat> cool
18:14:10 <Onionnion> Baked for 6m 11s, current frame: 16/220 (27.288s^C ETC: 1h 46m 13s
18:14:11 <RodgerTheGreat> I presume this simulation stuff parallelizes well?
18:14:51 <Onionnion> blender simulations are comparable to leading professional and proprietary software
18:16:27 --- quit: phirsch (Ping timeout: 248 seconds)
18:16:40 <Kumul> stupid question, would there be a performance difference on a forth written entirely in assembly? and how much would that be? (jonesforth doesnt work on BSD)
18:17:02 <RodgerTheGreat> hm
18:17:03 <Kumul> screw it, ill just learn assembly and fix it
18:17:04 <Onionnion> isn't there always performance increase when using assembly?
18:17:19 <Kumul> yes, but by what margin?
18:17:37 <RodgerTheGreat> well I think the biggest factor is really whether you're using a forth which directly emits machine code and is capable of doing optimizations on that
18:18:02 <RodgerTheGreat> although there was some discussion earlier that on some architectures a threaded inner interpreter can actually be extremely fast
18:18:44 <RodgerTheGreat> doing simple optimizations like TCO and constant folding can have a pretty significant impact
18:19:28 <Onionnion> I never really got into forth..although I feel it's making me miss out
18:19:38 <RodgerTheGreat> you're a bit limited in what an optimizing compiler for forth can easily do, though, because much of the language is based around single-pass compilation
18:20:53 <RodgerTheGreat> and the compiler itself is generally expected to function with statically allocated storage
18:21:16 <RodgerTheGreat> you can bend both of those rules, but you have to start breaking down what you think of as "Forth"
18:21:43 <RodgerTheGreat> not having type information is also limiting in some ways
18:23:15 <RodgerTheGreat> I dunno if you guys have ever played with this, but inferring the stack effect of an arbitrary sequence of procedure calls and forward/backwards branches can get quite difficult
18:23:28 <RodgerTheGreat> in a fully generalized case you really can't
18:24:17 <RodgerTheGreat> if you have more restricted flow primitives, more like how Factor and Joy handle flow operators, it gets *much* easier
18:26:15 <Kumul> ill just ignore everything you said and keep thinking on the contrary :P
18:26:41 --- join: phirsch (~phirsch@xdsl-89-0-163-164.netcologne.de) joined #forth
18:26:41 --- mode: ChanServ set +v phirsch
18:26:41 <RodgerTheGreat> hey, I'm sure writing a forth in assembly is both educational and fun
18:26:47 <RodgerTheGreat> don't let me discourage you
18:27:43 <RodgerTheGreat> I just work with compilers at my "day job"
18:36:10 <Onionnion> RodgerTheGreat, so you have a career around computer science?
18:36:19 <RodgerTheGreat> yes
18:37:08 <Onionnion> just curious, because I'm asking people about this stuff as I'm looking into all this, did you get a degree for it or just learned and jumped in?
18:38:28 <RodgerTheGreat> I'm a PhD student
18:39:04 <RodgerTheGreat> and, yes, I have an MS and I've done some work with compilers
18:39:14 <RodgerTheGreat> no major publications as of yet
18:39:30 <Onionnion> awesome. don't know how far I'll go into it
18:39:37 <Onionnion> probably masters
18:39:58 <RodgerTheGreat> I spent some time in "the industry" between my BS and grad school, which I found highly educational
18:40:27 <Onionnion> most education comes from actually doing it
18:40:32 <RodgerTheGreat> agreed
18:41:42 <RodgerTheGreat> academia is good at motivating you to learn theory, practice constructing proofs and learn a broad base of algorithms. Practical software engineering is usually less "fancy", but you deal with the human element, project life cycles and you have to learn about tools and specific frameworks/libraries/etc
18:41:49 <RodgerTheGreat> both are extremely useful
18:43:12 <RodgerTheGreat> I think researchers can really benefit from some practical perspective
18:45:41 <Onionnion> I've gone over C
18:45:50 <Onionnion> trying to do problems at projecteuler.net
18:46:29 <RodgerTheGreat> forth can be pretty tricky for a lot of those because you often benefit from arbitrary precision math. I've made pretty good progress using Factor.
18:52:01 <Onionnion> got problems 1 and 2
18:52:07 <Onionnion> no idea why but 1 was hard to figure out lol
18:52:16 <Onionnion> then I realized it and I felt stupid
18:53:27 <Onionnion> a = b + c; c = b; b = a; loop
18:55:54 <Kumul> the other day, euler went offline and i copied it completely into an hg/git repo
18:56:37 <Kumul> kinda handy, just clone and start doing exercises on your own repo :)
18:56:50 <Kumul> just saying, if anyone is interested
18:57:17 <Onionnion> git hates me lol
18:58:48 <Kumul> Onionnion: i mostly use hg, its easier
18:59:29 <Kumul> Onionnion: git hates everyone
18:59:49 <Onionnion> never heard of hg and google gives me Mercury lol
19:00:11 <Kumul> i think its hard because its tailored for shellscripts
19:00:19 <Kumul> Onionnion: yeah, mercurial
19:02:41 <regnirps> Hey, just saw that Illyes Forth link. He did highly optimized for Apple II and Apple //gs back in the end of the 80's.
19:03:20 <regnirps> I have a disk and manual somewhere. He supported a frame grabber and gray scale card I made for IIe/gs.
19:06:38 <Onionnion> Kumul, I feel as if I want to jump back into debian
19:18:57 <Kumul> hopping distros is a losers game
19:19:20 --- join: black_13 (467c40e5@gateway/web/freenode/ip.70.124.64.229) joined #forth
19:19:20 --- mode: ChanServ set +v black_13
19:19:27 <black_13> hello cleveland
19:19:28 <Kumul> Onionnion: it is an inf loop
19:19:52 <Onionnion> but openbox..I missed so much
19:20:40 <Kumul> Onionnion: use BSD, and install openbox
19:20:45 <black_13> what does ": , HERE ! 1 ALLOT ;" do or rahter how does it work?
19:21:29 <Kumul> go to the last defined word on the dictionary and allot ?
19:26:15 <black_13> hum
19:26:41 <Kumul> starting forth explains that
19:27:30 <Onionnion> the only troubles I had was some laziness and something with packages as I was trying to do LFS and something about building was frustrating me to the point of wanting to blow it up
19:29:05 <Kumul> black_13: http://home.iae.nl/users/mhx/sf9/sf9.html
19:29:45 <black_13> thanks
19:29:55 <Kumul> Onionnion: use bsd, seriously bsd!
19:29:58 <Kumul> :)
19:30:09 <Kumul> i havent had a headache in a while
19:31:10 <Onionnion> what about repos?
19:31:31 <black_13> i found a forth written by Robert. F. Illyes its extremly small but some of the predefined words seem to be of his own
19:33:22 <Kumul> Onionnion: no need, everything is in the ports system
19:34:10 <black_13> what does nesting mean?
19:34:58 --- join: Onny (~ryan@adsl-68-254-169-141.dsl.milwwi.ameritech.net) joined #forth
19:34:58 --- mode: ChanServ set +v Onny
19:35:16 <Onny> blah, disconnect
19:35:27 * Onny is Onionnion 
19:35:52 --- quit: Onionnion (Ping timeout: 244 seconds)
19:36:01 <Kumul> xD
19:36:09 --- nick: Onny -> Onionnion
19:36:23 <Kumul> repeat Onionnion: no need, everything is in the ports system
19:36:34 * Onionnion is Onionnion 
19:36:38 <Onionnion> explain?
19:38:32 <Kumul> its basically a fs (not literally), you have a directory with the package name you cd into it, and make install, it will compile and everything will be up to date 
19:43:40 <black_13> do you all know of any very small forth interpreters written in c?
19:46:32 <regnirps> Nesting is some implementation tool not part of forth.
19:47:35 <Onionnion> I gotta ask, what's with all the large need of small or tiny interpretors of Forth?
19:48:20 <regnirps> It is convenient for interactive dev on new/small hardware.
19:48:45 <regnirps> Like having Python with direct access to memory and I/O registers.
19:50:04 <regnirps> Where did that : , HERE ! 1 ALLOt ; come from?
19:51:53 <regnirps> Definition of ","  Places top of stack at next location in dictionairy, called HERE and allost 1 (moves dict pointer ahead by 1).
19:53:19 <regnirps> Or you could say ALLOT increments HERE by the amount on TOS, 1 in this case.
19:55:10 <regnirps> I think ANS would say CELL ALLOT and Forth79 proabalby 2 ALLOT because there is C, that places a byte or char in the dict and it would use 1 ALLOT.
19:55:59 <black_13> Onionnion: that is really why i want it small hardware
19:56:18 <black_13> what is old is  now new
19:56:48 <black_13> thanks
19:56:57 <regnirps> Plus, once you overcome the overhead of the basic system, the code is very compact and you can get a lot into a small space.
19:58:16 <black_13> for instance a company i worked for used the atmel/msp430 chips in an electric field monitoring device 
19:58:33 <black_13> the engineer on the project told me how things often changed
19:58:59 <black_13> if you had a system that could be updated by forth firmware it would be extremely useful
19:59:33 <regnirps> Now with Java and Python popularity, they can fit a lot of byte codes into a small space. But I don't think they can get as compact as Forth where each new word defined is called like a bytecode.
19:59:49 <regnirps> Python overhead is too great.
19:59:54 <black_13> it is
20:00:23 <black_13> the forth i found i was able to compile it to 26k on win32
20:00:25 <regnirps> Java, perhaps in the right circumstances but it uses more stack manipulation being like C with stack frames.
20:01:10 <RodgerTheGreat> there were some "kilobyte virtual machine" JVM implementations at one point that could function on the order of 96-128k of ram
20:01:12 <regnirps> 6502 Fig-Forth fit the AIM-65 in less than 4K with heads and interpreter.
20:01:19 <RodgerTheGreat> but those were *very* restricted systems
20:01:51 <black_13> was that forth written in assembly
20:01:54 <regnirps> Same on Apple II's. 48K with lots of room left after Forth was loaded.
20:02:18 --- quit: SplinterOfChaos (Quit: Leaving)
20:02:20 <regnirps> It was in assembply in the sense it was written with a Forth assembler.
20:02:29 <black_13> ah
20:03:19 <regnirps> Yes, in assembly. The heads are constructed with text includes in the assembler.
20:03:59 <regnirps> After the basic words are defined, you write in "Forth" by stringing together the label names so that the execution addresses are laid down in order.
20:04:43 <black_13> regnirps: could you elaborate or show me a place that elaborates that idea
20:05:01 <regnirps> Find the Bill Ragsdale 6502 Fig Forth listing. It is the definitive implementation.
20:05:09 <black_13> ok
20:06:22 <black_13> is there still a "living" version of this ? something that could be run on apple emulator ?
20:07:46 <regnirps> Yes. MVPForth should be around.
20:08:25 <regnirps> Mountain View Press was the largest vendor of Forth books and disks and published the FIG journal.
20:08:35 <regnirps> FOrth Dimmensions
20:09:16 <regnirps> Ragsdales' RPN style 6502 assembler written in Forth is amazing and worth studying.
20:10:59 <black_13> a forth writting in forth?
20:11:05 <black_13> oroboros
20:11:13 <regnirps> Metacompiler.
20:11:17 <RodgerTheGreat> I've done something like that
20:11:44 <regnirps> The original Ragsdale 6502 FIG came as a printout and you typed it into your assembler. The Merlin IIRC.
20:12:18 <black_13> wow
20:12:30 <black_13> where would you find that?
20:12:42 --- quit: Psyclonic (Quit: Leaving)
20:12:43 <black_13> out of curriously
20:14:22 <regnirps> I have copies of all that stuff somewhere.
20:14:55 <regnirps> I used the assembler ideas to add floating point support of the AMD9511 FP chip.
20:17:58 <regnirps> http://www.forth.org/fig-forth/contents.html
20:18:46 <regnirps> This is from the Rockwell System-65 code also for AIM-65. Modified from Ragsdale by John Bumgarner and Dave Boulton I think.
20:24:19 <regnirps> Yep. That is it. Yu can see NEXT is fairly long in 6502 but the zero page instructions are only 1 or 2 cycle and there are clever forms of Z-page indirect addressing on 6502 as if the first 256 bytes of RAM is a table of 128 indirect addresses. Plus the stack is in zero page for fast access.
20:25:26 <regnirps> Ignore the Trace stuff. It was for debugging and never included later.
20:25:38 <black_13> wow i have no idea what your talking about
20:26:14 <regnirps> This is indirect threaded Forth, so it is like a byte code interpreter with 16 bit codes.
20:26:50 <regnirps> NEXT is the inner interpreter that moves along the execution codes or word addresses.
20:27:14 <black_13> would it be possible to "freeze" the state of forth machine
20:27:35 <regnirps> The outer interpreter is what they call the interactive compiler. Not needed in a finsihed program.
20:27:57 <regnirps> Yes, in the NEXT code you can halt or do whatever you want.
20:28:52 <black_13> i worked for a company that made slot machines the state of these devices had to be saved there was a fault
20:28:54 <regnirps> I modified one to increment a counter in whatever word was executing (I added an extra 16 bit word to the definitions) to see which words are executing most often.
20:29:43 <RodgerTheGreat> I think "Forth: Tools and Applications" mentions that approach to profiling
20:29:46 <regnirps> Yeah. Rules for slots are pretty strict.
20:30:06 <regnirps> Who write that?
20:30:16 <regnirps> Rather?
20:30:25 --- join: avenidadebelgica (~avenidade@67-5-152-121.ptld.qwest.net) joined #forth
20:30:25 --- mode: ChanServ set +v avenidadebelgica
20:30:56 <RodgerTheGreat> regnirps: Gary Feierbach and Paul Thomas
20:34:05 <black_13> Has anyone ever heard of "Robert F. Illyes"  it seems he wrote some articles in "forth dimensions"
20:35:52 <regnirps> Yes, he wrote a fast subroutine threaded Forth for Apple IIgs and supported image processing hardware I used to sell. I have the disks and manuals.
20:37:20 <regnirps> Believe it or not, a frame grabber and 8 bit gray scale adapter on and Apple IIe was the hotest thing going for electron microscopes in 1986.
20:38:20 <regnirps> The Apple II listing on http://www.forth.org/fig-forth/contents.html is probably easier to follow. Note for assemb;y you have to give names to things like +, it is plus in the listings.
20:38:54 <black_13> regnirps: i found a c implementation for about 3 different forths
20:39:17 <black_13> http://www.math.uiuc.edu/~gfrancis/illimath/audible/vowels/bbn.C
20:39:38 <regnirps> A guy named Dr. Ting did a slew of tiny forth stuff 10 or 15 years back.
20:40:06 <black_13> i wish i was an assembly guy but i can get buy on C/C++
20:40:13 <regnirps> Yes, that is Illyes. Very clever guy. We used to talk frequently.
20:40:20 <black_13> oh
20:40:25 <black_13> is he still alive
20:40:30 <regnirps> Don't kow.
20:40:45 <regnirps> I am, so he might be :-)
20:40:53 <black_13> a guy who was in his prime in 80s well that was 30 years ago
20:40:59 <black_13> sadly we die
20:41:34 <black_13> ok this is a tanget
20:41:37 <regnirps> Well, sometimes we are smiling when the plane hits the mountain in the dark.
20:41:48 <black_13> yeah good point
20:42:24 <regnirps> I'm looking for the Ragsdale assembler. It is such a great example, that I will have to post it somewhere.
20:42:39 <black_13> i remember the star trek animated from the 70s there was episode called "slaver weapon" basically its a found artifcat
20:43:15 <black_13> this think is like that a couple of things i understand 
20:43:28 <black_13> how to add numbers
20:43:33 <regnirps> I need a Forth for this http://regnirps.com/VolvoxStuff/Volvox.html
20:44:09 <regnirps> 144 Transputers in two boxes.
20:44:11 <black_13> beautiful hardware
20:44:31 <black_13> the wiring harness is really lovely
20:44:52 <regnirps> French Supercomputer from the 90's.
20:45:06 <black_13> i am going to name drop
20:45:11 <regnirps> English Transputer chips.
20:45:16 <black_13> i start working for AMD monday
20:46:06 <regnirps> Cool. I just got an AMD 6 core system from Tiger Direct. The multithread and compile Linux faster than the Intels.
20:46:32 <regnirps> Where?
20:46:32 <black_13> i gather that the graphics chips are essentially array process or they can do lots of mathmatical calculations
20:46:36 <black_13> austin
20:47:03 <regnirps> Nice. I stream a radio station out odf Austin. The Todd and Don show or some such thing.
20:47:18 <black_13> hum
20:47:38 <regnirps> I just hit them for an hour at noon for Niel Bortz.
20:47:40 <black_13> going back to robert illyes you have a manual?
20:47:59 <regnirps> Yes. In a shipping container full of old computers and books.
20:48:23 <black_13> no pdf
20:48:25 <black_13> oh well
20:48:46 <regnirps> It is for Apple II/IIgs which I have a dozen or more of. Even NIB.
20:49:10 <black_13> god i had a cuople of those i was given them and threw them out
20:49:23 <black_13> ages ago
20:49:28 <regnirps> http://regnirps.com/SEF/oddities.htm
20:49:28 <black_13> however
20:50:27 <regnirps> One of the guys from Apple II Dev tech support in th eold days made a card that takes a CF and fools the OS into thinking it has hard drives. Add an 8 MHz accelerator and they are amazingly usefull.
20:50:52 <regnirps> two or thrtee times faster thqan and arduino and they are popular.
20:51:31 <regnirps> I have a couple of the CF cards loaded to boot ProDOS and KIX, a UNIX-like system.
20:51:43 <regnirps> Boots in about a second.
20:52:28 <black_13> regnirps: could you look at http://www.math.uiuc.edu/~gfrancis/illimath/audible/vowels/bbn.C cod and give me some advice on what some of the predfined words do?
20:52:49 <regnirps> I have ti open already.
20:53:20 <regnirps> Which ones do you mean?
20:54:44 <regnirps> (Sorry I'm fascinated by my web site and my work from the 80's. Did I really do all that? ;-)
20:55:12 <regnirps> Yeah, give me an example and I'll see if I can tell what it does.
20:55:21 <black_13> sure
20:58:04 <black_13> " : ,        HERE !  1 ALLOT  ;"
20:58:24 <black_13> or what does "HERE" mean?
20:58:41 <RodgerTheGreat> Obtain the address of the first available word of memory
20:58:56 <RodgerTheGreat> comma takes a value from the stack, and stores it to HERE
20:59:02 <RodgerTheGreat> then 1 ALLOT increments here
20:59:48 <RodgerTheGreat> so you could write that less concisely as : ( n -- ) , HERE !  HERE @ 1 + HERE ! ;
21:00:03 <RodgerTheGreat> erm
21:00:18 <regnirps> HERE is a variable that hold the currect end of the dictionary.
21:00:18 <RodgerTheGreat> well not quite
21:01:05 <black_13> a question about "( -- )" are these comments?
21:01:09 <RodgerTheGreat> yes
21:01:10 <regnirps> yes
21:01:21 <RodgerTheGreat> ( starts a comment and ignores everything until )
21:01:36 <regnirps> ( stack before --- stack after )
21:02:06 <RodgerTheGreat> and the stacks are "written" bottom to top, left to right
21:02:16 <black_13> the forth has predefined array of stucts 
21:02:37 <RodgerTheGreat> presumably the built-in dictionary?
21:02:48 <black_13> it is
21:02:54 <black_13> it would have to be
21:03:01 <black_13> the find workds against
21:03:15 <black_13> but there is another thing called "ram" 
21:03:47 <black_13> and the ram is being "field as" i just add simple things
21:03:48 <regnirps> It is a struct to make it easy to define words I think. Ineed by c deconfusatrator.
21:04:25 <regnirps> Illyes is pretty eccentric code. I would get the source for gforth for an example of ANS in C.
21:04:47 <black_13> ans is big
21:05:02 <black_13> ficl was my original toy 
21:05:39 <regnirps> It is written by professional computer scientists and professors. The techniques for writing it in C will be more concise.
21:05:53 <black_13> which?
21:05:57 <regnirps> gForth
21:06:22 <regnirps> or Win32Forth, which has great OOP extensions.
21:07:11 <black_13> those are probably going to be to large
21:07:41 <RodgerTheGreat> I think his point is to try to understand a full-size one first, and then come back to small ones for your application
21:07:58 <black_13> oh 
21:08:13 <black_13> to try to find analogues
21:08:19 <regnirps> Ah. The Illyes uses seperate heads. This is more complicated and good for creating final "headless" applications that don't need the names for compiling.
21:08:42 <regnirps> But not so good to learn from.
21:09:24 <black_13> and sadly there was no manual for "words"
21:10:13 <regnirps> That is how it can generate very small applications, kind of like a metacompiler. You recompile your app "headless". Much more complicated system than plain Forth.
21:10:48 <RodgerTheGreat> I'm pretty sure he wanted to be able to debug/code interactively on the device, though
21:10:55 <RodgerTheGreat> which would seem to rule out a target compiler
21:11:34 <black_13> debug the forth code you mean
21:11:39 <regnirps> One moment...
21:12:18 <regnirps> http://www.ebay.com/itm/310358774791?ssPageName=STRK:MEWAX:IT&_trksid=p3984.m1423.l2649
21:12:42 <black_13> ill be
21:12:45 <black_13> dipped
21:12:58 <RodgerTheGreat> cute
21:13:52 <black_13> not open source
21:13:55 <black_13> looks like
21:14:10 <RodgerTheGreat> welcome to embedded systems
21:15:45 <regnirps> I wold liek him to do this one for me.  http://andahammer.com/armmiteproplus/
21:16:09 <regnirps> Though the compiled BASIC is very fast.
21:16:12 <RodgerTheGreat> "25 million LINES of compiled BASIC per second!"
21:16:23 <regnirps> Yeah. Pretty cool.
21:16:27 <RodgerTheGreat> that is cool
21:17:00 <RodgerTheGreat> it can't help but feel a little anachronistic as a measurement, though
21:17:24 <regnirps> I might do it myself. I have the ARM Forth79 code I wrote ages ago for a VLSI chip
21:17:42 <RodgerTheGreat> what would you do with it?
21:18:08 <regnirps> Put it on the boards as an option on the site.
21:18:35 <regnirps> regnirps = Springer = ARMWorks
21:18:46 <RodgerTheGreat> oh. OK
21:19:09 <RodgerTheGreat> I did recall you linking elsewhere on that site previously
21:19:39 --- quit: Monevii (Remote host closed the connection)
21:19:47 <regnirps> There is a French group that does a programming contest every year.
21:19:52 <RodgerTheGreat> http://andahammer.com/assets/Uploads/All2440/_resampled/ResizedImage483450-GeoDeath.jpg <- is that a geoduck?
21:20:17 <RodgerTheGreat> oh, nvm, read the caption
21:20:19 --- quit: Kumul (Quit: gone)
21:20:28 <regnirps> The last two they have used this http://andahammer.com/mini35-sdk/
21:20:35 <regnirps> Yes.
21:20:50 <regnirps> I dig the min front of the house.
21:21:04 <regnirps> I saw them in markets in Hong Kong for $60 US.
21:21:45 <regnirps> The contest has been start-up time for Linux.
21:22:03 <regnirps> I was thinking of a "bare metal" Forth contest.
21:22:30 <RodgerTheGreat> how fast can you boot to an OK?
21:22:35 <regnirps> Disable the MMU so there is a linear 64M RAM. No OS but Forth.
21:22:45 <regnirps> It woiuld be very fast.
21:22:59 <RodgerTheGreat> it'd be difficult to measure
21:23:03 <regnirps> Well under a second if it is FOrth only.
21:23:19 <RodgerTheGreat> you'd want to ask people to write something meaningful
21:23:36 <regnirps> The S3C2440 is loaded with times and PWM and all that stuff, so you could measure yourself with the hardware.
21:23:39 <RodgerTheGreat> or possibly compile + run a large, well known corpus of forth code
21:23:51 <RodgerTheGreat> possibly some of the forth scientific library stuff
21:24:11 --- quit: Onionnion (Quit: Leaving)
21:24:24 <regnirps> I think demonstrate a valid ANS or variant plus some benchmark for speed.
21:24:59 <RodgerTheGreat> write a benchmark application they must run, and design it to verify the correctness of their ANS implementation to some degree
21:25:03 <regnirps> Plus maybe points for the IDE. Eclipse? A simple FOth editor?
21:25:21 <RodgerTheGreat> Eclipse support for forth sounds absolutely bizarre
21:25:23 <regnirps> I wold even consider old fashioned screens of 1K. 16 lines by 64.
21:25:27 <RodgerTheGreat> a collision of worlds
21:25:49 <regnirps> Screens kept code well factored and tight.
21:26:20 <regnirps> There is 1G of NAND for the SSD plus up to 32G on an SD card.
21:26:43 <RodgerTheGreat> 33 million screens ought to be enough for everybody
21:27:12 <regnirps> Other things would be support for the LCD and touch pad and especially all the I/O. SPI I2C, GPIO, A/D, etc.
21:27:27 <regnirps> Ethernet?
21:27:29 <regnirps> USB?
21:27:40 <regnirps> It is a lot of work.
21:27:42 <RodgerTheGreat> at this point you could just open it up to be "make a cool tech demo that runs on this board, written entirely in forth"
21:28:34 <regnirps> Yes. I don't care if it runs under Linux, but that puts you back to needed Linux drivers for all the I/O not in userland.
21:29:02 <RodgerTheGreat> hm
21:29:14 <regnirps> The Linux version of gForth cold be pretty easily targeted.
21:29:32 <RodgerTheGreat> yeah, it has extensive facilities for creating bindings to native C libraries
21:29:48 <regnirps> We have Linux with Qt, Abdroid, and even Debian Squeeeze.
21:31:03 <RodgerTheGreat> so what would the prize be for this contest?
21:31:16 <regnirps> 64M is a lot of RAM for Forth. I'm pretty curious about performance of a bare metal FOrth and slowly add all the I/O like FTP, USB, etc. If they can do it for Arduino, ....
21:31:27 <RodgerTheGreat> sure
21:32:00 <regnirps> Somethng like store credit for X amount and a new Mini210S 1GHz A8 with 4.3" LCD.
21:32:28 <regnirps> And fame of course.
21:32:48 --- join: Monevii (~Monevii@adsl-64-237-234-175.prtc.net) joined #forth
21:32:49 --- mode: ChanServ set +v Monevii
21:32:58 --- join: Kumul (~Kumul@adsl-64-237-234-175.prtc.net) joined #forth
21:32:58 --- mode: ChanServ set +v Kumul
21:33:03 <RodgerTheGreat> very tempting
21:33:07 <regnirps> I cant think of any sponsors since we make the boards.
21:33:49 <regnirps> Maybe KingBird Quad Band MODEMS and EDUP Yaggi Antennas.
21:34:29 <regnirps> We have an 18 inch yaggi I can point across the bay and pick up 30 Wifi users systems from 3 miles.
21:34:48 <regnirps> 5 or 10 are always unlocked.
21:35:18 <regnirps> Great for anyone who lives within line of sight of a Starbucks or other hot spot.
21:35:52 <RodgerTheGreat> make a pen testing rig that identifies insecure networks, roots machines and installs forth on them
21:36:02 <regnirps> http://andahammer.com/wifiyagi/
21:36:55 <regnirps> I test with KisMAC, which is really a cracker but I don't try to crack.
21:39:20 <regnirps> A simplified version of this http://andahammer.com/mini210-w5/
21:39:29 <regnirps> will be $199 by Monday.
21:40:49 <regnirps> But the Mini35 with the S3C2440 is a good target for a contest. The ARMEL instruction set (no Thumb) can be specified, then it will compile or assemble for everything.
21:42:17 <regnirps> An interesting way to play around with Forth is to get an old G4 or G5 MAC. They all have Open-Boot in thyem, whcih is Forth and you can drop into a consoles window in Open-Boot. Same as SUN systems.
21:44:39 <regnirps> Gotta go -- Later.
21:46:02 <black_13> found some nice stuff at http://forth.sourceforge.net/standard/fst83/fst83-12.htm#here
21:53:50 <black_13> i found someone who knows Robert F. Illyes and he is going to contact him for me.
21:55:29 <black_13> interesting "HERE ." returns 162 
21:56:32 <black_13> : square DUP * ; then after HERE . returns 165
21:56:59 <black_13> is that 3 bytes or 3 words 
21:58:30 <RodgerTheGreat> 3 cells
21:59:04 <RodgerTheGreat> usually a word
21:59:15 <RodgerTheGreat> per cell
22:00:03 <black_13> i see
22:00:19 <black_13> i am begining to understand
22:00:21 <black_13> a bit
22:00:47 <black_13> it looks like his forth uses a subset of fig83
22:00:51 <black_13> if thats right
22:01:06 <black_13> is the correct term "fig83"?
22:04:37 <RodgerTheGreat> I think so
22:04:56 <RodgerTheGreat> gonna call it  a night. Catch you folks later.
22:10:07 --- quit: RodgerTheGreat (Ping timeout: 252 seconds)
22:32:32 <regnirps> F83
22:33:01 <regnirps> FIG-FOrth, Forth79, F83
22:36:27 <regnirps> That Illyes you are looking at has separate heads, so the space for the name "square" doesn't show up. It might be 3 byte tokens for HERE, *, and ; or it might be JSR instruction and 16 bit address. "Subroutine threaded".
22:46:19 <black_13> regnirps: still up?
22:47:35 <regnirps> For a bit.
22:48:04 <regnirps> I recall he liked subroutine threading for speed.
22:48:42 --- quit: ttmrichter (Quit: Leaving)
22:54:19 <black_13> reading wikipedia on call threading
22:55:46 <black_13> my limited assembly knowledge says to me that you have two function calls to push the arguments for the word "+" or plus then a call the "add" that pops off stack and saves results
22:55:59 <black_13> how is this different than another type of theading?
22:57:21 <black_13> i think i see how token threading works ... you need to have a lookup table that turns a string or hash to function call
22:59:13 <black_13> regnirps: if you read the wiki entry http://en.wikipedia.org/wiki/Threaded_code#Subroutine_threading they mention "nest" and "un-nest"
23:00:03 <regnirps> Ah. That must have to do with the way most subroutine calls put return addresses on the CPU machine stack.
23:00:36 <regnirps> It might just generate a JSR and a RET instruction.
23:01:15 <regnirps> ARM doesn't have subroutines. You do ir yourself by loading the program counter abd saving the current execution address - the "link address".
23:03:25 <black_13> i am going to get into my nest and sleep
23:03:32 --- quit: black_13 (Quit: Page closed)
23:55:35 --- quit: Kumul (Quit: gone)
23:55:46 --- quit: Monevii (Remote host closed the connection)
23:59:59 --- log: ended forth/12.06.09