00:15:20 <sdsd> sorry in another window
00:15:28 <sdsd> yah i think we spoke a couple times
00:15:31 <sdsd> on this channel
00:15:40 <water> ok
00:30:50 [QUIT] _ruiner_ quit: destroy what destroys you
00:43:36 <sdsd> getting late here in EST
00:55:01 [QUIT] MysticOne quit: I'm outta here!  Catch everyone later!
00:57:32 <sdsd> gotta run
00:57:33 [QUIT] sdsd quit: Leaving
01:59:52 <Ghyll> good morning water
02:04:54 [QUIT] downix quit: downix has no reason
03:13:15 [QUIT] I440r quit: Ping timeout for I440r[purplecoder.com]
03:13:23 I440r joined #tunes
03:35:20 [QUIT] I440r quit: Excess Flood
03:35:27 I440r joined #tunes
03:53:14 smoke joined #tunes
04:07:01 [QUIT] I440r quit: Ping timeout for I440r[purplecoder.com]
04:10:49 I440r joined #tunes
05:43:00 [QUIT] water quit: Ping timeout for water[tnt-10-128.tscnet.net]
05:43:13 thomas joined #tunes
05:55:42 [QUIT] thomas quit: Ping timeout for thomas[rits1.rits.idcomnet.no]
06:25:05 morton joined #tunes
06:28:08 [QUIT] morton quit: Leaving
08:30:49 ult joined #tunes
09:08:02 [QUIT] ult quit: Hey!  Where'd my controlling terminal go?
09:17:39 ult joined #tunes
10:19:52 [QUIT] abi quit: Ping timeout for abi[bespin.dhs.org]
17:22:26 Brianna joined #tunes
17:53:32 [QUIT] lar1 quit: [x]chat
17:58:27 ult joined #tunes
18:05:24 Lindril joined #tunes
20:01:08 CiA joined #tunes
20:01:48 CiA left #tunes
20:40:36 lar1 joined #tunes
20:48:36 ult joined #tunes
22:05:11 eihrul joined #tunes
22:22:22 [QUIT] lar1 quit: Yeah, yeah
22:31:29 [QUIT] MysticOne quit: Ping timeout for MysticOne[porpoise6.panama.gulf.net]
22:42:38 water joined #tunes
22:43:29 <water> hi all
22:44:25 <water> hm
22:44:33 <water> hello lindril
22:57:12 [QUIT] Odyrithm quit: Leaving
22:58:00 lispbliss joined #tunes
22:58:27 <water> hey lb
22:58:57 <lispbliss> hi water
23:00:29 <lispbliss> anything interesting happening?
23:00:38 <water> still working on slate
23:01:04 <water> i'm doing more and more research, and eihrul's working on the implementation
23:01:06 <lispbliss> is slate a filesystem?
23:01:12 <water> heh
23:01:26 <lispbliss> or a programming language?
23:01:28 <water> http://www.tunes.org/~water/slate-home.html
23:01:33 <water> both :)
23:01:48 <lispbliss> sorry,. no webbrowser
23:01:54 <water> oh
23:02:02 <water> not even lynx?
23:02:09 <lispbliss> nope
23:02:22 <water> why not, may i ask?
23:02:42 <lispbliss> new install
23:02:54 <lispbliss> I'm updating to debian 2.2 right now and then I'l install w3m
23:02:59 <water> i see
23:03:19 <water> abi: slate?
23:03:20 <abi> slate is a unifying/hybridizing of self/beta/lisp at http://www.tunes.org/~water/slate-home.html
23:03:35 <lispbliss> I hope this works.  I installed corel and am going to try and update to debian 2.2.
23:03:51 <lispbliss> lisp syntax?
23:03:55 <lispbliss> I've never seen self or beta..
23:03:55 <eihrul> not anymore
23:03:58 <water> nope, more like forth
23:04:15 <eihrul> and its not quite a file system, but the idea is that objects can be inspected in a way that is similar to a file system
23:04:43 <water> eih: and a persistent store of slate objects would therefore be...? :)
23:04:44 <lispbliss> hmm, does it have any special networking features?
23:04:45 <eihrul> so in theory, it is good for interactive programming :)
23:04:55 <eihrul> water: an object system, silly
23:05:32 <water> "special" hmm
23:05:48 <water> well the concurrency mechanisms should be distribution-friendly
23:06:03 <lispbliss> Slate sounds familiar, wondering if it has anything to do with LinuxNOW
23:06:12 <eihrul> water: look at the ground first, please :)
23:06:15 <water> no, it's in-house right now
23:06:38 <water> of course, there's M$ Slate :P
23:06:44 <water> eih: eh?
23:07:01 <eihrul> water: don't pressure me into making concurrency when we don't even have a working programming system :)
23:07:13 <water> eih: i wasn't trying to
23:07:14 <lispbliss> hmm, can you do me a favor and go to slashdot and take a look at the answers to Ian something's interview a day or so ago.  he mentioned something and I could have sworn it was slate or something similiar
23:07:27 <water> Piumarta?
23:07:53 <lispbliss> umm, founder of debian
23:08:02 <water> oh that one
23:08:10 <water> hadn't looked at it, but i will
23:08:25 <lispbliss> thanks
23:08:27 <water> ah ian murdock
23:08:28 <lispbliss> tell me what you see
23:09:00 <lispbliss> seems like it was a filesystem by berkeley named Slate
23:09:14 <water> eih: it was my intention to create the concurrency mechanisms in the pidgin environment first
23:09:28 <water> eih: on top of the implementation
23:09:53 <water> lisp: grepping "slate" turned up nothing
23:10:08 <lispbliss> hmm,grep for berkeley
23:10:12 eihrul goes off to take a nap.
23:10:20 <lispbliss> it is under the question about LinuxNOW
23:10:27 <water> yeah i see it now
23:10:28 [QUIT] kc5tja quit: [BX] Get your free warez from ftp://127.0.0.1!
23:11:21 <eihrul> water: hmmm, just occurred to me...
23:11:44 <eihrul> water: since the meta-object can make slots appear that are not necessarily slots
23:11:50 <water> lisp: the sprite fs
23:11:58 <lispbliss> ahh
23:12:00 <lispbliss> thanks
23:12:00 <eihrul> this also affects mechanisms that attempt to view the object
23:12:12 <water> yep
23:12:19 <eihrul> as they will see under the meta-object
23:12:24 <eihrul> is this desirable?
23:12:45 <water> probably both yes and no
23:13:02 <water> i.e. both views will probably be desired
23:13:26 <eihrul> one would require meta-object cooperation though
23:13:27 <water> do you have a particular example in mind?
23:13:36 <water> right
23:14:08 <eihrul> so there should probably be parts of the protocol
23:14:15 <eihrul> that do things like enumerate all the slots of an object
23:15:42 water nods
23:15:55 <water> just like a mirror, you think?
23:16:05 <eihrul> in fact, yes
23:16:07 <water> or do you suggest an iterator of sorts
23:16:09 <water> ?
23:16:21 <water> like a lazy stream of slots
23:16:27 <eihrul> well, at the very least, just a function in the meta-object that returns a list of slots :)
23:16:36 <water> ok
23:16:42 <eihrul> well, or something similar
23:16:50 <eihrul> because yeah, there could be a lot of generated slots
23:16:51 <water> what about the case of non-coutnable collections of slots?
23:16:54 <eihrul> so a stream might be desirable
23:17:37 <eihrul> or could go with the mirror scheme
23:17:44 <eihrul> a meta-object could be queried for a mirror
23:17:52 <eihrul> which is then used for things like displaying the object
23:18:19 <water> which iirc was what the self people used mirrors for :)
23:18:28 <eihrul> okay then
23:18:32 <water> except they only had one MO called the VM :)
23:18:34 <eihrul> reinventing the wheel, isn't it grand?
23:19:10 <water> you know, you could subscribe to the self mlist and ask the original people yourself :P
23:19:24 <eihrul> ask what?
23:19:29 <eihrul> this wasn't a question :)
23:19:45 <eihrul> i only made statements
23:19:49 <water> well maybe you should start asking questions, then ;)
23:20:00 <eihrul> i got the solution without asking though :)
23:20:14 <water> ah the pleasures of epi-cycles
23:20:29 <water> oh, btw
23:20:56 <eihrul> though, mirrors are not necessarily important
23:21:03 <eihrul> when you have the meta-object
23:21:12 <water> this IF logic book points out the similarity between godel's arguments using his formula-enumerating mechanism and quoting
23:21:23 <water> and therefore meta-programming
23:21:48 <water> because the MO provides the mirrors? :)
23:21:58 <lispbliss> either of you read Principia Mathematica by Whitehead?
23:22:04 <water> lisp: yes
23:22:04 <eihrul> well, the MO provides the ability to examine the contents of the object
23:22:13 <eihrul> the only thing you need is a way to iterate over the slots
23:22:16 <water> lisp: it's online, btw
23:22:25 <lispbliss> water, you've surely not read it all?
23:22:35 <lispbliss> water, really? the whole thing? AWESOME!
23:22:56 <water> yeah, although i don't recall the url... do a google search
23:23:29 <lispbliss> cool, from what I've heard about it it sounds quite interesting
23:23:52 <water> it's okay, but it's also open-ended
23:24:08 <water> and i don't think they had the right answers
23:24:21 <water> it's almost 100 years old, you know
23:24:55 <lispbliss> by any chance do you know why if you take a number and multiply it by two and then multiply that number by two on and on and then lkook at the first digit of each number there is a repeating pattern every 10 numbers?
23:25:13 <water> hm
23:25:30 <water> provably so?
23:25:53 <lispbliss> I can't prove it
23:26:03 <lispbliss> try it though
23:26:04 <water> no, has someone proven it
23:26:10 <water> ?
23:26:23 <lispbliss> also works for 5, since it goes into 10
23:26:28 <lispbliss> I don't know, I just noticed it theo ther day
23:26:54 <lispbliss> the other
23:27:19 <lispbliss> a similiar thing happens for 25.  except that pattern is 5 digits long
23:27:33 <water> i'd bet there is a simple proof of it using groups and representations
23:28:20 <lispbliss> where would I find one
23:28:33 <water> a proof? :)
23:28:34 <lispbliss> I asked the profs at this college (ricks in idaho) and not a single one could tell me why
23:29:00 <water> then they're lame
23:29:34 <water> but then again, some apparently simple things to prove can be really difficult
23:29:44 <lispbliss> probably so..
23:29:45 <ult> hmm
23:29:49 <ult> I don't remember the exact proof
23:29:59 <ult> but I believe lispbliss that your thing works for every number
23:30:10 <ult> its just a differnet length inbetween repetitions
23:30:13 <lispbliss> I'm not sure what a proof constitutes, I'm not really into mathematics much, I haven't even taken calculus..
23:30:21 <water> yes it has to be independent of the base number
23:30:27 <ult> yeah its weird
23:30:54 <ult> its easy to calculate because theres a pattern that involves the radix too
23:31:17 <lispbliss> radix?
23:31:21 <ult> base
23:33:46 <lispbliss> this is what one guy told me, I did not understand it
23:33:55 <lispbliss> 2(100n + 20) = 200n + 40
23:34:07 <lispbliss> 2(200n + 40)=400n + 80
23:34:09 [QUIT] air quit: http://www.qzx.com/ :: sleep
23:34:21 <lispbliss> 2(400n + 80)=800n+160
23:34:37 <lispbliss> 2(800n + 160) = 1600n + 320
23:34:43 <lispbliss> 100(16n+3) + 20
23:34:53 <lispbliss> 3+16 times old n becomes new n
23:34:57 <lispbliss> any ideas what the heck that means?
23:35:33 <ult> yes
23:35:35 <ult> see the pattern there
23:38:05 <lispbliss> ahh, I think I begin to see it, but I'm not quite understanding it
23:39:10 <lispbliss> does this explain why there is a patern when doubling the numbers?
00:24:53 <water> hum game-theoretical semantics