00:00:00 --- log: started retro/09.12.31
04:11:18 --- quit: zbrown (farmer.freenode.net irc.freenode.net)
04:11:19 --- quit: retro-commit (farmer.freenode.net irc.freenode.net)
04:11:51 --- join: retro-commit (n=Karere@c-68-80-139-0.hsd1.pa.comcast.net) joined #retro
04:11:51 --- join: zbrown (n=suifur@rufius.xen.prgmr.com) joined #retro
05:27:34 --- quit: sixforty ("Leaving.")
05:41:52 --- join: crcx (n=Karere@c-68-80-139-0.hsd1.pa.comcast.net) joined #retro
12:42:36 --- quit: zbrown (farmer.freenode.net irc.freenode.net)
12:42:36 --- quit: retro-commit (farmer.freenode.net irc.freenode.net)
12:53:41 --- join: retro-commit (n=Karere@c-68-80-139-0.hsd1.pa.comcast.net) joined #retro
12:55:35 --- join: zbrown (n=suifur@rufius.xen.prgmr.com) joined #retro
13:02:51 --- join: erider (n=chatzill@unaffiliated/erider) joined #retro
14:28:20 <erider> whats up everyone
15:01:23 --- quit: zbrown (Remote closed the connection)
15:02:21 --- join: zbrown (n=suifur@rufius.xen.prgmr.com) joined #retro
15:27:37 <crc> just got home :)
15:44:20 <erider> hi
15:44:46 <erider> crc have you played with reva 
15:49:22 <crc> yes
15:49:37 * crc used to be semi-active in developing reva
15:49:55 --- quit: crcx (Remote closed the connection)
15:50:45 <erider> crc: its like retro right?
15:51:00 <crc> similar to the older retro system
15:51:07 <crc> but with some more advanced features
15:51:29 <erider> advanced features? 
15:51:46 <crc> contexts, turnkey, optimizing compilation
15:51:56 <erider> ah 
15:52:06 <erider> turnhey is a nice feature 
15:52:38 <crc> retro 10 allows for turnkey images :)
15:54:00 <erider> js version 
15:54:21 <crc> the js version does, depending on the browser 
15:54:31 <crc> (not all of them support saving the images locally)
15:58:46 <erider> crc: retro 10 is completely js implementation right?
15:58:51 <crc> no
15:59:19 <crc> retro's current implementation is a split vm / memory image
15:59:35 <crc> there are vm's written in c, c#, go, js, and java
16:00:45 <erider> ah ok 
16:01:10 <crc> the memory image can be used across the various implementations with only minor tweaks (e.g., the js implementation can't load a raw binary, so I have code to convert the raw binary into a js function for loading)
16:02:06 <erider> ok 
16:02:21 <erider> and that is the js version you have for chrome?
16:02:38 <crc> yes
16:04:02 <erider>  ah ok 
16:04:15 <erider> hey did you see my post about backspace 
16:04:17 <crc> bbiab; I have to get the kids ready for bed
16:04:20 <crc> yes
16:04:31 <crc> I'm investigating the cause currently :)
16:04:53 <erider> ok 
16:05:05 <erider> I will be here 
16:05:10 <erider> for most of the night 
16:10:24 <erider> crc: do you still have the retro interpreter on the your website to play with?
16:23:19 <crc> yes
16:23:37 <crc> try this one though: http://crcx.ath.cx:52850/
16:23:47 <crc> it's a testbed with the latest image + some extensions loaded
16:25:42 <erider> crc: are you looking at the backspace or delete 
16:25:56 <crc> backspace works in some browsers
16:26:08 <crc> chrome isn't passing the backspace to my keyboard handler :(
16:26:17 <erider> I ok 
16:26:27 <erider> I am using chrome 
16:27:00 <crc>  me too
16:27:24 <erider> ok 
16:27:42 <erider> I am playing around with reva right now 
16:28:11 <erider> reva 9.0
16:28:29 <crc> 9.0.8 is the most current
16:28:52 <erider> I have it on a windows image 
16:30:21 * erider is trying to remember how to use words
16:30:49 <crc> try "help wordname"
16:31:04 <crc> I think it still has an integrated help system
16:32:49 <erider> yes it does thanks youi 
16:33:10 <crc> no problem
16:34:40 <erider> nice 
16:34:50 <erider> it has examples too 
16:36:23 <erider> crc: I want to play with the address words (pointers) ! @ etc.. 
16:39:23 <crc> http://ronware.org/reva/wiki/Reva_Tutorial
16:40:19 <erider> cool!! 
16:41:05 <crc> also http://ronware.org/reva/wiki/Intermediate_Tutorial
16:42:20 <erider> crc: have you see the debugger example 
16:42:25 <erider> in reva 
16:43:12 <erider> it hooks into a running process but send 0xcc 
16:47:11 <erider> that would be cool "a pure forth debugger" that can debugger native win/linux executables 
17:41:50 <erider> crc: are you still hanging in there 
17:50:53 * docl just got home from work
17:51:05 <erider> hi
17:51:15 <docl> how ya doing?
17:51:25 <docl> happy new years eve
17:51:27 <erider> good and you
17:51:37 <erider> same to you
17:51:41 <docl> pretty good
17:52:39 <docl> seems like the biggest obstacles for ngaro portability are things like keypresses, timers, and gui stuff
17:52:55 <docl> basically it's all the stuff that guis generally take care of
17:53:59 <erider> yeah guess you need to tap into the browsers APIs 
17:54:13 <docl> right, for the browser version
17:54:47 * erider is not versed in javascript
17:55:03 <docl> js is pretty simple from what I recall
17:55:05 <erider> I don't know how hard it will be 
17:55:22 <docl> I haven't tried reading the retro javascript code though
17:55:45 <erider> there are some things that need to be done I guess 
17:56:40 <erider> but I think crc will figure it out 
17:57:42 <erider> docl: how is the block ed coming 
17:58:01 <docl> it's nice. haven't done anything in the last few days on it though
17:58:12 <docl> have you played with it yet?
17:58:25 <erider> no 
17:58:54 <erider> but I have just installed a forth implementation to play with it again 
17:58:58 <docl> it is in the forthlets package
17:59:19 * docl has forks of a bunch of crc's repos
17:59:45 <docl> http://github.com/crcx
18:00:29 <docl> ngaro is where the executable for retro comes from. retro10 is where the retroImage file comes from.
18:00:44 <docl> forthlets is where we put apps like rem and chorder
18:00:56 <docl> wheke is for libraries like strings and arrays
18:01:21 <erider> interesting 
18:01:32 <docl> wheke is a word for octopus... probably because it is all the arms of retro reaching out
18:02:50 <docl> if you want to share changes you make, you can either make gists or fork the projects and push your changes to the forks
18:03:19 <erider> until the backspace is working I will play with forth in the OS setting :) 
18:05:18 <erider> and not in browser mode 
18:08:31 <docl> yeah browser mode is a bit too quirky for me at the moment
18:12:20 <erider> docl: how do you use the editor 
18:12:51 <docl> go to forthlets and type "retro --with apps/rem.retro"
18:13:03 <docl> (assuming linux, and assuming retro is in the path.)
18:13:38 <erider> ok some you call it from the cli 
18:13:46 <erider> ok cool 
18:14:26 <erider> I thought maybe you needed to add it on the fly with "needs rem" 
18:14:35 <docl> you could make a shell script to call it for you I guess
18:14:46 <docl> not a way to do that at present :(
18:15:43 <erider> I see 
18:17:28 <erider> what are v, a, c == char? l == long int? maybe 
18:18:22 <docl> in the code there are comments you can read. 
18:18:54 <docl> v is view (it is part of the original block editor, short for view)
18:19:26 <docl> l = lines c = columns
18:19:54 <docl> for this program anyway :)
18:20:25 <erider> ah ok 
18:27:01 <erider> docl: I wonder if it will work in reva 
18:27:27 <docl> good question
18:28:04 <erider> nah 
18:28:09 <docl> I think reva may be like retro 9 or 8, which used counted strings and "parse" instead of zero terminated strings and "accept" like we use in retro 10
18:28:15 <erider> not without tweaking 
18:29:38 <erider> that is one thing the is crazy about forth. there are many forths 
18:29:52 <docl> yeah...
18:30:37 <docl> there's so many ways to solve a programming problem... not everyone is going to agree on one single way
18:31:14 <docl> like strings...
18:31:27 <docl> a string is just a bunch of chars in a row, right?
18:31:36 <docl> but how long is that row?
18:31:59 <docl> you can just say how long it is every time you use the string
18:32:18 <erider> yeah but to make forth a followed language there should be one standard cross implementations so you can move code from one forth to the next 
18:32:43 <docl> hmm
18:32:47 <docl> there is ANS forth
18:33:41 <erider> yeah 
18:34:18 <erider> each forth the is different is a different language in my opinion 
18:38:01 <erider> dialects 
18:38:11 <docl> true
18:38:23 <docl> the lure of forth is that it lets you make your own dialect
18:38:37 <docl> you make your own words, then make words out of those...
18:39:15 <erider> yeah but there still is syntax the you need to use 
18:39:26 <docl> and if you don't like the name of a word you just change it. or make another word that does the same thing
18:39:46 <docl> there's so many choices. swap drop or nip?
18:40:28 <erider> true
18:41:29 <erider> the only thing that I see that most forths follow is : ; 
18:41:41 <docl> hehe
18:41:54 <docl> words bye . : ;
18:42:12 <erider> yup :) 
18:42:42 <docl> of course you don't even need those :P
18:43:49 <erider> humm
18:43:50 <docl> ' bye is quit ' : is sub{ ' ; is } ' . is print-tos
18:46:25 <erider> that would be cool because that would be added to the dictionary 
18:47:07 <docl> yep
18:47:15 <docl> the ' word is part of retro
18:47:38 <docl> it takes the word after it and finds the address it points to, and places that on the stack
18:48:35 <docl> is makes a vector to the word. we used to have one called alias, I think it may not be in the dictionary anymore.
18:49:24 <erider> ( name -- xt ) 
19:08:00 <docl> : alias create ['] .word last @ dup d->class ! d->xt ! ; <- not sure why this does not work.
19:11:18 <docl> create makes a word. it is of the class .data initially
19:12:12 <docl> so to make it type .word we need to get the xt of .word, which is what ['] does when you are compiling. (['] is a macro that does at compile time what ' does at interpret time.)
19:13:06 <docl> last @ goes to the dictionary entry for the word that was just created. last is a variable that always points to the most recently made word.
19:13:20 <docl> oh I see my bug
19:13:31 <docl> I used ! right after dup
19:13:47 <docl> so it just saved the class address to itself, which is useless
19:14:36 <docl> what I needed to do was tuck
19:14:38 <docl> : alias create ['] .word last @ tuck d->class ! d->xt ! ;
19:14:39 <erider> ! is like assign or better yet "foo = 3" == 3 foo ! right? 
19:14:49 <docl> right
19:15:03 <docl> pronounced "store"
19:15:10 <docl> and @ is "get"
19:15:15 <docl> no wait, it's "fetch"
19:15:18 * docl calls it get
19:15:24 <docl> for some odd reason
19:16:13 <erider> but foo has to be declared first before you can store to it right? 
19:16:25 <docl> with that alias definition you can make a new word that is type .word, and yet points to the address you give it. with ' that lets you alias one word to another
19:16:35 <docl> right
19:16:43 <docl> variable foo
19:16:49 <docl> 10 foo !
19:17:00 <docl> you can also use 10 variable: foo
19:17:21 <docl> that is how you would initialize a variable
19:17:31 <docl> 10 constant bar is how you do a constant
19:17:48 <docl> constants do not need you to use @, but variables do
19:18:00 <docl> a constant is like a word with the stack diagram 
19:18:07 <docl> ( -n )
19:18:21 <docl> variables are more like ( -a )
19:18:28 <docl> a is short for address
19:18:35 <docl> n is for number
19:18:59 <docl> a variable is basically a pointer
19:19:50 <docl> "create" makes a pointer as well, but does not allocate any space
19:20:07 <docl> so it just points to "here"
19:20:13 <crc> back again
19:20:37 <docl> create foo variable bar would thus make foo and bar be aliases for the same variable
19:21:08 <erider> variable allocates space 
19:21:13 <docl> right
19:21:29 <docl> create foo 1 allot = variable foo
19:21:42 <docl> here = heap @
19:21:56 <docl> 1 allot = heap ++
19:24:41 <docl> heap ++ = heap @ 1 + heap !
19:25:21 <docl> there's lots of little labor-saving words in forth... basically that's the point, you get to write short words and make more words out of them.
19:26:02 <docl> sometimes you use create for arrays. for example:
19:26:11 <docl> mylist 0 , 0 , 0 , 0 ,
19:26:18 <docl> makes an array of 4 cells
19:26:23 <docl> oops
19:26:27 <docl> create mylist 0 , 0 , 0 , 0 ,
19:26:40 <docl> this is equal to: create mylist 4 allot
19:27:06 <docl> actually maybe not quite equal since the first example fills it wit 0s
19:27:30 <docl> allot only changes where here is pointing to
19:29:52 <docl> so maybe I want something that initializes the list with zeros...
19:30:00 <crc> docl: I could change that easily enough...
19:30:28 <docl> : zallot dup here swap 32 fill allot ;
19:30:39 <docl> (I forget if that's the right order for fill)
19:31:25 <crc> : zallot ( n- ) repeat 0; 32 , 1- again ;
19:31:28 <docl> another way of doing the exact same thing: : zallot for 0 , next ;
19:31:31 <crc> would be more efficient
19:31:32 <erider> and you can use @ and + to scale to array 
19:31:49 <crc> docl: but it wouldn't handle negative allotments
19:32:08 <docl> oh yeah, I forgot allot accepts negatives
19:32:40 <docl> the repeat example is nifty
19:35:08 <docl> : abs dup 0 <if -1 * then ;
19:37:36 <docl> hmm, how would I use that to do negative allotments?
19:39:11 <crc> better to have the general purpose allot, and a separate allot word for initializing memory if you need to
19:39:32 <docl> yeah
19:40:01 <crc> otherwise you'll need conditional inside the allot word
19:40:46 <docl> which complicates allot a lot :)
19:41:27 <crc> : allot ( n- ) dup 0 <if heap +! else drop for 0 , next then ;
19:41:33 <crc> or:
19:41:39 <crc> : allot ( n- ) heap +! ;
19:41:53 <crc> : zallot ( n- ) for 0 , next ;
19:42:06 <docl> erider: as you can see there's tons of ways to decide to do things... no wonder not all forths are like :)
19:42:20 <crc> the second is more words, but a cleaner separation IMO
19:42:32 * docl agrees
19:42:34 <erider> yeah 
19:42:55 <docl> seperating things like this is what forth is about IMO
19:43:27 <erider> I stick to the basics 
19:43:40 <docl> : array create allot ;
19:43:52 <docl> 7 array myarray
19:44:26 <docl> that does the same as create myarray 7 allot
19:45:35 <docl> note that "create" does the parsing for the string (myarray) at interpret time. when the compiler is active (after a : ) it does nothing.
19:46:46 <docl> there's a lot of power in distinguishing compile time from interpret time...
19:47:05 <crc> docl: remember the stack comments...
19:47:12 <docl> oops
19:47:28 <docl> : array ( "n- ) create allot ;
19:47:45 <docl> or would that be ( n"- )?
19:47:54 <crc> n"-
19:48:51 <docl> : array ( n"- ) create allot ;
19:49:21 <docl> : zallot ( n- ) for 0 , next ;
19:49:49 <docl> : array ( n"- ) create zallot ; ( might be better )
19:50:20 <crc> zallot is a good candidate for stage2
19:50:25 <docl> :)
19:50:37 <erider> hmm
19:51:23 <docl> any questions from the audience? ;)
19:53:00 * docl just noticed in my examples, one time I used 32 and the other time I used 0, for the same thing
19:53:21 <docl> 32 is the space character, which is good for initializing a string
19:54:06 <docl> 0 is number zero, also can terminate a string
19:54:53 <docl> : spaceallot ( n- ) for 32 , next ;
19:56:27 <crc> docl: ifExists and ifNotExists - would ifDefined and ifNotDefined be better names?
19:56:44 <docl> might be
19:57:03 <docl> is there a specific context where camelCaps is preferred?
19:57:25 <crc> nope
19:57:37 <docl> basically wherever there's more than one english word to the word name?
19:58:03 <crc> that's generally what I'm doing, except in a few cases (variable names)
19:58:12 <docl> ok
19:58:31 <docl> I noticed getLine, for example
20:00:07 <docl> defined !defined
20:00:27 <docl> hmm
20:00:47 <retro-commit> [crcx/retro10] e6630e: fast-render => fastRender
20:01:00 <crc> a few renamings, and I added zallot
20:01:36 <docl> I wonder if we should factor out something like blockIf, and use "defined blockIf" and "not defined blockIf"
20:03:01 <crc> possibly, but is there a good example of another place we need block conditionals?
20:05:24 <docl> maybe for compatibility issues. but with ngaro that shouldn't be a factor.
20:05:49 * docl will see if he can think of some
20:05:55 <crc> ok
20:17:47 <retro-commit> [crcx/forthlets] 3c5424: use ifDefined instead of ifExists
20:25:22 <erider> docl: you running retro 10 on linux 
20:29:22 <docl> yeah
20:29:46 <erider> you are not running the js version right 
20:29:50 <docl> no
20:30:03 <erider> you used git to get from the repo 
20:30:10 <docl> yep
20:30:29 <erider> crc: are you using svn too
20:30:38 <crc> erider: git, not svn
20:31:28 <erider> so you are not using svn too :( 
20:31:39 <crc> no
20:31:45 <crc> I gave up on svn
20:36:55 <erider> crc: I can use svn pretty good :) 
20:37:37 <crc> svn doesn't handle massive restructurings as well as git does
20:37:54 * erider is running linux mint now
20:39:46 <retro-commit> [crcx/ngaro] 471211: add stubs for canvas ports to graphical vm
20:40:06 <erider> crc: is it like svn in general ie git update etc .. 
20:40:15 <crc> git add <files>
20:40:20 <crc> git commit -m 'message'
20:40:28 <crc> git push
20:40:54 <crc> git clone <url>
20:40:56 <crc> git pull
20:41:04 <crc> would cover the basic commands
20:41:13 <erider> git pull "is to get the repo" 
20:42:49 <crc> pull latest changes from remote repo
20:50:36 <crc> erider: the fundamental difference between git and svn is that svn is centralized and git isn't 
20:50:54 <crc> each git repo is a full copy, with all history, etc stored locally
20:51:24 <crc> with svn, you can make a local copy, and push/pull from a single master repo
20:51:38 <crc> with git, I can pull from a master repo, or any other copy of the git repo
21:07:46 <retro-commit> [crcx/ngaro] 9111e1: graphical port: setting colors and drawing pixels ...
21:19:47 <retro-commit> [crcx/ngaro] f8c4ca: graphical port: added vertical and horizontal line...
21:25:46 <retro-commit> [crcx/ngaro] 6de88a: graphical port: added rect and solid rect
21:30:38 <crc> still buggy, but getting closer to being usable
21:36:46 --- quit: erider (Read error: 113 (No route to host))
21:50:48 <retro-commit> [crcx/ngaro] e9c120: graphical port: update after a draw operation
22:07:18 <docl> cool
22:07:47 <retro-commit> [crcx/ngaro] c14aab: fix color maps
22:08:24 <crc> docl: I should have this mostly complete by the end of the weekend
22:09:47 <retro-commit> [crcx/ngaro] c85798: match resolution of js canvas port
22:10:14 <docl> :)
22:19:47 <retro-commit> [crcx/ngaro] 48aca1: fix to rect and solidRect positioning
22:21:54 <crc> the two canvas demos are running now, with only minor display bugs
22:22:38 <docl> where are the demos located?
22:23:20 <crc> forthlets/apps/canvas and forthlets/games/canvas
22:24:51 <docl> ok  : (draw ( n- ) over 350 50 50 solidBox
22:24:51 <docl> Word Not Found
22:25:07 <docl> is there something else I'm supposed to load first?
22:25:29 <docl> that was apps/canvas/draw.retro
22:25:35 <crc> sorry
22:25:41 <crc> retro10/source/extras/canvas.retro
22:25:45 <crc> has to be loaded first
22:25:56 <docl> ahh
22:33:04 <docl> cool, it draws!
22:36:46 <retro-commit> [crcx/forthlets] df44ff: use "fw" and "fh" to obtain resolution info
22:36:47 <retro-commit> [crcx/ngaro] 733288: more rect fixes
22:39:33 <crc> I'll do circles later, then it should be all set :)
22:39:51 <docl> :)
22:40:42 <crc> the sdl-based implementation has a hybrid canvas/framebuffer. you can directly access the video memory starting at address 6000000
22:42:54 <docl> nice!
22:43:06 <docl> tictactoe is taking a long time to load
22:43:27 <docl> here it is
22:44:11 <crc> it's almost instant for me :(
22:44:44 <docl> it was faster this time
22:44:54 <docl> I wonder why
22:45:34 * crc will try to find out later today :)
22:46:37 <docl> ahh
22:46:37 <crc> I need to get some sleep now, but should be back in ~6-8 hours, or maybe earlier; depending on the kids
22:46:45 <docl> it has to do with the stdout I bet
22:47:07 <docl> it tries to inform you of all the pixels being written to... takes time to scroll by.
22:47:12 <crc> I removed that a little while ago
22:47:37 <docl> when I switch to a different screen it loads quickly
22:47:37 <crc> it was useful while debugging the rects
22:48:17 <docl> ah, now it is gone. instant!
22:48:56 <crc> good :)
23:59:59 --- log: ended retro/09.12.31