00:00:00 --- log: started forth/13.09.10
00:42:48 --- join: dessos (~dessos@c-174-60-176-249.hsd1.pa.comcast.net) joined #forth
00:43:36 --- part: dessos left #forth
00:45:57 --- quit: rixard (Quit: rixard)
00:50:25 --- join: epicmonkey (~epicmonke@188.134.41.114) joined #forth
00:56:25 --- join: rixard (~rixard@81-235-139-119-no63.tbcn.telia.com) joined #forth
01:05:02 --- quit: epicmonkey (Ping timeout: 264 seconds)
01:36:59 --- join: dys (~user@2a01:1e8:e100:8296:21a:4dff:fe4e:273a) joined #forth
02:12:05 --- quit: Backer (*.net *.split)
02:12:07 --- quit: ASau (*.net *.split)
02:12:07 --- quit: kludge` (*.net *.split)
02:12:07 --- quit: cataska (*.net *.split)
02:12:07 --- quit: nisstyre (*.net *.split)
02:15:34 --- join: nisstyre (~yours@oftn/member/Nisstyre) joined #forth
02:16:39 --- join: epicmonkey (~epicmonke@host-224-51.dataart.net) joined #forth
02:20:40 --- join: ASau (~user@p4FF97651.dip0.t-ipconnect.de) joined #forth
02:20:40 --- join: kludge` (~comet@unaffiliated/espiral) joined #forth
02:20:40 --- join: cataska (~cataska@210.64.6.233) joined #forth
02:20:40 --- join: Backer (~backer@user-387h39d.cable.mindspring.com) joined #forth
02:32:10 --- quit: kludge` (Ping timeout: 260 seconds)
02:34:52 --- join: kludge` (~comet@unaffiliated/espiral) joined #forth
02:59:51 --- join: true-grue (~quassel@95-25-48-238.broadband.corbina.ru) joined #forth
04:45:44 --- join: ASau` (~user@p5797FD11.dip0.t-ipconnect.de) joined #forth
04:49:21 --- quit: ASau (Ping timeout: 260 seconds)
04:52:20 --- quit: true-grue (Read error: Connection reset by peer)
05:01:09 --- join: nighty^ (~nighty@lns-bzn-49f-62-147-170-46.adsl.proxad.net) joined #forth
05:01:59 --- join: RodgerTheGreat (~rodger@97-88-148-161.dhcp.mrqt.mi.charter.com) joined #forth
05:31:14 --- quit: Bahman (Quit: Leaving.)
05:49:27 --- quit: epicmonkey (Read error: Operation timed out)
05:50:50 --- join: beretta (~beretta@74.135.121.153) joined #forth
05:50:53 --- quit: nisstyre (Quit: Leaving)
06:01:51 --- join: epicmonkey (~epicmonke@host-224-58.dataart.net) joined #forth
06:09:06 --- join: protist (~protist@47.224.69.111.dynamic.snap.net.nz) joined #forth
06:10:32 --- join: true-grue (~quassel@95-27-18-149.broadband.corbina.ru) joined #forth
06:35:45 --- quit: beretta (Ping timeout: 260 seconds)
07:14:38 --- quit: lazyden (Quit: lazyden)
07:25:45 --- join: _spt_ (~Jaat@host-92-12-217-129.as43234.net) joined #forth
07:25:45 --- quit: _spt_ (Changing host)
07:25:45 --- join: _spt_ (~Jaat@unaffiliated/-spt-/x-5624824) joined #forth
07:41:24 --- quit: dys (Ping timeout: 264 seconds)
07:43:40 --- quit: rixard (Ping timeout: 276 seconds)
07:48:16 --- join: rixard (~rixard@81-235-139-119-no63.tbcn.telia.com) joined #forth
08:19:10 --- quit: protist (Quit: Konversation terminated!)
09:02:03 --- join: Tod-Work (~thansmann@50-202-143-210-static.hfc.comcastbusiness.net) joined #forth
09:08:55 --- join: nisstyre (~yours@oftn/member/Nisstyre) joined #forth
09:23:58 --- quit: nisstyre (Quit: Leaving)
10:13:18 --- quit: true-grue (Remote host closed the connection)
10:13:57 --- join: true-grue (~quassel@95-27-18-149.broadband.corbina.ru) joined #forth
10:58:32 --- nick: ASau` -> ASau
11:41:22 --- quit: _spt_ (Ping timeout: 256 seconds)
11:53:30 --- quit: kludge` (Remote host closed the connection)
11:57:07 --- join: kludge` (~comet@unaffiliated/espiral) joined #forth
12:27:48 --- quit: epicmonkey (Ping timeout: 240 seconds)
12:57:54 --- quit: true-grue (Read error: Connection reset by peer)
13:35:23 --- join: epicmonkey (~epicmonke@188.134.41.114) joined #forth
14:04:46 --- quit: koisoke (Remote host closed the connection)
14:04:54 --- join: koisoke (xef4@epilogue.org) joined #forth
14:29:45 --- quit: nighty^ (Quit: Disappears in a puff of smoke)
15:02:00 --- join: itsy (~digital_w@200.79.125.91.dyn.plus.net) joined #forth
15:11:04 --- quit: epicmonkey (Ping timeout: 264 seconds)
16:01:28 --- quit: Eth|cal (Ping timeout: 256 seconds)
16:35:52 <tangentstorm> So I'm working on that tree-based forthlike (or at least concatenative) language I was talking about.
16:36:15 <tangentstorm> I think it's going to be pretty handy for meta-programming.
16:36:34 <RodgerTheGreat> in what way is it tree-based
16:38:35 --- join: lazyden (~lazyden@58.185.121.38) joined #forth
16:42:18 <tangentstorm> RodgerTheGreat: in that you can build and operate on trees. 
16:42:42 <tangentstorm> it's actually sort of a blend of forth and lisp.
16:43:34 <tangentstorm> so you have cons cells garbage collection, but you can say  1 2 cons
16:43:46 <tangentstorm> and that'll leave a reference to a cons cell on the stack.
16:43:49 --- join: Eth|cal (~sam@ppp59-167-172-238.static.internode.on.net) joined #forth
16:44:00 <RodgerTheGreat> I actually have a vocabulary that does that in forth
16:44:01 <RodgerTheGreat> with gc
16:44:02 <tangentstorm> where the stack is really just a list, since they're nested.
16:44:15 <RodgerTheGreat> oh, hm
16:44:15 <tangentstorm> oh? where at?
16:44:33 <RodgerTheGreat> do you want a version written in my forth or a version that works in gforth?
16:49:21 <tangentstorm> RodgerTheGreat: i'm writing this in pascal and not trying to maintain compatability with either lisp or forth, so... either :)
16:50:03 <RodgerTheGreat> alright, then have the pithy and mostly portable gforth version: https://gist.github.com/JohnEarnest/4522067
16:50:21 <RodgerTheGreat> this is only a pair allocator but can be extended to be a general purpose GC fairly easily
16:50:51 <RodgerTheGreat> pair, first, rest are essentially cons, car and cdr
16:52:58 <tangentstorm> wow that's tiny :)
16:53:05 <RodgerTheGreat> forth!
16:54:36 <tangentstorm> oh wow this makes total sense now.
16:54:47 <RodgerTheGreat> what part?
16:54:53 <tangentstorm> cheney's algorithm ;)
16:54:58 <RodgerTheGreat> neat
16:55:04 <RodgerTheGreat> glad I could clarify something
16:55:12 <RodgerTheGreat> cheney's algorithm is *really* simple
16:55:45 <tangentstorm> i guess i kind of glossed over it in the past because i never needed it, but i remember looking through your code before. (maybe the mako version)?
16:56:09 <RodgerTheGreat> possibly
16:58:14 <tangentstorm> the way i laid everything out in this pascal version, the cons cells are just stored in a big array that grows (rather than creating them with new() and sticking them in the heap somewhere)
16:58:50 <RodgerTheGreat> ah
16:59:18 <RodgerTheGreat> and then you just compact that array as cells are freed and do some sort of reference following thing sort of like what I do?
16:59:22 <tangentstorm> the stack would just be a similar dynamic array of values.
16:59:31 <tangentstorm> well i don't do anything yet ;)
17:00:27 <RodgerTheGreat> ah, the simplest GC of them all
17:00:28 <tangentstorm> but yeah, i think i will use your code as a guide in implementing my gc. thanks :)
17:00:34 <RodgerTheGreat> cool
17:01:24 <tangentstorm> i'm digging through the mako repo.. where would i look for that version?
17:01:41 <tangentstorm> ah in Loko?
17:02:48 <RodgerTheGreat> loko uses it
17:03:03 <RodgerTheGreat> https://github.com/JohnEarnest/Mako/blob/master/lib/Algorithms/Garbage.fs
17:03:09 <bluekelp> RodgerTheGreat: you at M-Tech? (github stalking)
17:03:12 <RodgerTheGreat> yes
17:03:35 <RodgerTheGreat> tangentstorm: lib/Algorithms/Curry.fs might also be interesting
17:03:41 <bluekelp> nice
17:03:53 <RodgerTheGreat> and lib/Algorithms/Lazy.fs is an example of something you can do with currying
17:04:04 <RodgerTheGreat> bluekelp: do you know people who went to MTU
17:04:28 <bluekelp> i almost went there - a bunch of me classmates did.  no one recently or curently though
17:04:34 <bluekelp> my*
17:05:27 <RodgerTheGreat> it's a small school and it's in the boonies but it's pretty good
17:11:34 <tangentstorm> RodgerTheGreat: thanks for all this. i will be adapting some of it. :)
17:12:28 <RodgerTheGreat> no problem man; I'm curious to see where you'll go with it
17:13:05 <RodgerTheGreat> lemme know if the currying mechanism makes sense to you
17:16:37 <RodgerTheGreat> the thunks are a bit more complicated than may seem necessary but partly it is because I must keep pointers to other thunks in a form that will allow the GC to find them
17:17:33 <RodgerTheGreat> both to follow them and to update them when compaction occurs
17:57:21 --- join: beretta (~beretta@74.135.121.153) joined #forth
17:58:12 --- join: beretta_ (~beretta@74.135.121.153) joined #forth
18:53:30 <ttmrichter> RodgerTheGreat: I'd just like to say that I'm really enjoying reading your code (except for that stack comments over at the right thing).
18:54:06 <ttmrichter> There's an old gag about how Forth is a programming amplifier: a bad programmer becomes terrible, a good programmer becomes great.
18:54:16 <ttmrichter> Your code amplifies in the right direction.  :)
18:54:31 --- join: true-grue (~quassel@89-178-130-65.broadband.corbina.ru) joined #forth
18:54:46 <beretta_> hehe
18:55:13 <RodgerTheGreat> ttmrichter: aw, shucks. :)
18:56:59 <beretta_> yeah... I've pondered some of RodgerTheGreat's code to... it didn't take much pondering as it was well factored.
18:57:22 <RodgerTheGreat> I do try
18:59:23 <ttmrichter> RodgerTheGreat: Seriously, that GC code is nice to read.  Rarely would I use the word "nice" to describe memory management code because it's a fiddly field to begin with.
18:59:56 <RodgerTheGreat> it's pretty important to have allocators available though. Somebody has to write them.
19:00:40 <beretta_> yup.. I've written a bunch of allocator in a bunch of lanuages.
19:01:35 <beretta_> "Stop playing with your stack words and make a dyn mem alloc already!" Is what I usually tell myself at a certain point.
19:01:50 <RodgerTheGreat> it should be noted that a certain amount of care must be used with garbage collectors built like mine, since it is always possible to have a value on the stack that fools the GC into thinking it's a pointer
19:02:21 <RodgerTheGreat> I've written complex programs which use the GC (like my Logo environment) though, so it obviously is quite usable
19:02:43 <tangentstorm> My values are all typed.
19:02:57 <RodgerTheGreat> that makes things much easier
19:03:01 <tangentstorm> They all have little tags on them that say what they are. :)
19:03:20 <RodgerTheGreat> my GC would be simplified even further by having an actual tagged architecture with meta-bits
19:03:20 <tangentstorm> I'm not too worried about speed since this is meant more for meta-programming.
19:04:36 <tangentstorm> i'm sort of copying the design of picolisp.
19:05:23 <tangentstorm> in picolisp, the working memory is also just a big expanse of cons cells.
19:06:07 <tangentstorm> or rather to 64-bit sequences.
19:06:44 <tangentstorm> for cons cells, you treat them as 2 28-bit pointers to these cells.
19:06:57 <tangentstorm> and the extra 4 bits are like a little tag that explain what they are.
19:07:34 <tangentstorm> i think 2 bits are used for types (there are only 3 types: string,pair,int) and the other 2 bits are used for the garbage colletor in some way.
19:08:01 <RodgerTheGreat> "is this a pointer" and "has this pointer been copied" maybe
19:09:24 <tangentstorm> hrm. that doesn't sound right. maybe the numbers aren't pointers?
19:09:50 <beretta_> this is interesting.
19:11:19 <tangentstorm> well, hrmm.. my impression was that every value was a pointer to a cons cell, but the tag describes how to interpret that cons cell.
19:12:44 <tangentstorm> i think numbers are just lists of digits, where the digits are in base 2**28
19:13:23 <tangentstorm> so 0 is (0 . nul) and  2**28 is  (1 . (2**28 . nul))
19:14:02 <tangentstorm> if so, i guess it would make sense to have to mark them as pointers or not during collection.
19:14:21 * tangentstorm does not know enough about this to be talking about it though.
19:14:25 --- part: beretta_ left #forth
19:20:46 <RodgerTheGreat> tangentstorm: perhaps Loko's type system would be worth reading over
19:20:59 <RodgerTheGreat> Logo is by any reasonable definition a lisp
19:21:18 <RodgerTheGreat> https://raw.github.com/JohnEarnest/Mako/master/demos/Loko/Loko.fs
19:21:38 <tangentstorm> already had that page open :)
19:21:47 <RodgerTheGreat> haha
19:22:08 <tangentstorm> i wish i had a nice browser for reading and making notes on people's code.
19:22:19 <RodgerTheGreat> the environment structure is way more complex than it needs to be because I wasn't initially sure if it was going to be dynamically or lexically scoped
19:26:21 --- quit: itsy (Read error: Connection reset by peer)
20:05:26 --- join: nisstyre (~yours@oftn/member/Nisstyre) joined #forth
21:25:49 --- quit: true-grue (Read error: Connection reset by peer)
21:31:55 --- quit: RodgerTheGreat (Quit: RodgerTheGreat)
21:56:38 --- quit: beretta (Ping timeout: 245 seconds)
22:30:49 --- part: lazyden left #forth
22:31:48 --- join: lazyden (~lazyden@58.185.121.38) joined #forth
22:43:13 <ttmrichter> http://i.imgur.com/WQieH7y.jpg
23:02:57 --- quit: c00kiemon5ter (Read error: Connection reset by peer)
23:49:42 --- join: epicmonkey (~epicmonke@188.134.41.114) joined #forth
23:59:59 --- log: ended forth/13.09.10