00:00:00 --- log: started forth/02.01.23
02:31:48 --- join: junk ([6zMZZw82n@njd.paradise.net.nz) joined #forth
02:32:21 <junk> does i440r still come here?
02:34:49 <junk> ...
02:34:50 <junk> i see
02:45:49 * junk is away. Automatically set away [SZon]
03:00:34 --- quit: junk ("That's it for today")
03:31:00 --- join: qless (~qless@clgr000977.hs.telusplanet.net) joined #forth
03:31:05 --- quit: qless (Client Quit)
08:18:20 --- join: futhin (Havoc36@ab-cal-a52-03-30.look.ca) joined #forth
08:51:33 --- quit: futhin ("-HAVOC- bye")
11:47:19 --- join: futhin (thin@24.64.174.54) joined #forth
13:22:27 --- part: futhin left #forth
17:54:51 --- join: kholmes (~kholmes@client1135.sedona.net) joined #forth
19:29:37 * kholmes is away: somewhere else
19:29:46 * kholmes is back (gone 00:00:06)
19:51:03 * kholmes is away: bbiam
19:55:20 * kholmes is back (gone 00:04:17)
20:54:35 * kholmes is away: gonna put socks on
20:56:51 * kholmes is back (gone 00:02:15)
21:52:41 --- join: futhin (Havoc36@ab-cal-a52-02-41.look.ca) joined #forth
21:53:36 <futhin> hello kholmes
21:53:46 <kholmes> hey
21:53:53 <kholmes> how goes?
21:53:54 <futhin> what's up? :)
21:54:02 <futhin> oh, goes good.  reading books
21:54:06 <kholmes> heh
21:54:08 <futhin> daytrading books :P
21:54:16 <kholmes> trying to learn things...thats all
21:54:22 <kholmes> uh oh...you're into stocks?
21:54:26 <futhin> lol
21:54:31 <futhin> why not? :P
21:54:44 <kholmes> I suppose its a good time to buy :)
21:54:54 <futhin> maybe :)
21:55:11 <kholmes> hmm
21:55:23 <kholmes> do you know what makes forth reflective?
21:55:31 <futhin> do you?
21:55:43 <futhin> tell me what reflective means
21:55:47 <futhin> and i'll try to explain heh
21:55:47 <kholmes> no...I think do> has something to do with it
21:55:51 <kholmes> oh
21:55:55 <futhin> does> you mean ?
21:55:59 <kholmes> yeah
21:56:24 <futhin> does reflective mean that you can access any part of forth or something ??
21:56:25 <kholmes> AFAIK, reflection means a program that is smart about itself
21:56:49 <kholmes> it can examine itself and change its own code during run time
21:56:55 <futhin> eh, need a better explaination..
21:56:56 <futhin> hmm
21:58:28 <futhin> sry, afk
21:58:30 <futhin> um
21:58:44 <kholmes> like
21:58:50 <kholmes> it could optimize itself
21:59:29 <kholmes> such as look for 1 + and change it to 1+
21:59:44 <futhin> too bad nobody else is on here, they could probably explain it better than i can.  just about everything inside forth is accessible from within forth..  
21:59:44 <kholmes> but thats a simple example
22:00:02 <kholmes> ahh...okay
22:00:50 <futhin> well, everything is accessible, i'd think.  but a lot of the core primitives are coded in assembly, but if you wanted to access them and modify them, i suppose that's possible
22:01:18 <futhin> yeah, you could code something that'll look for 1 + inside forth and change it to 1+
22:01:50 <futhin> it's low-level so yeah, you can find the stuff inside the memory that forth is at, modify that, save that to disk or something
22:02:07 --- join: [9of7] (~l@c38038.upc-c.chello.nl) joined #forth
22:02:15 <kholmes> which I think is an optimization since the assemply inc operation is faster than addition
22:02:28 <[9of7]> hi
22:02:34 <kholmes> hello
22:03:46 <futhin> kholmes: the very fact forth is interactive and places no restrictions on what you can do, makes it reflective
22:04:02 <futhin> hi 9of7
22:04:19 <kholmes> futhin: well...I don't think we mean the same thing
22:04:28 <[9of7]> hi futhin
22:04:37 <futhin> 9of7: i440r gets on fairly frequently some weeks, less freqently other weeks..
22:04:40 <kholmes> I'm sure a lot of languages can read over their own memory
22:04:50 <[9of7]> ah
22:05:08 <futhin> 9of7: read the logs at http://tunes.org/~nef/logs/forth/  :)
22:05:30 <[9of7]> just coding ...
22:05:43 <futhin> you are a forth coder?
22:05:57 * [9of7] alias Speuler
22:06:14 <[9of7]> nick is in use
22:06:23 <[9of7]> from other machine
22:06:29 <futhin> oh right
22:06:31 <futhin> forgot
22:06:35 <futhin> i thought you were somebody else
22:06:39 <futhin> aka Junk
22:06:54 <futhin> he was wondering if i440r comes here
22:07:20 <futhin> speuler: can u explain how forth is reflective? i'm not quite sure..
22:08:40 <futhin> kholmes: aren't all interactive languages reflective :P
22:08:54 <futhin> languages that aren't interactive must have a hard time being reflective ??
22:08:58 <kholmes> I don't think so
22:09:06 <futhin> hm
22:09:18 <kholmes> I don't think interactivity has to do with it
22:09:21 <futhin> need a better definition of reflective
22:09:26 <futhin> i'll check the web
22:09:37 <kholmes> read the tunes site
22:09:44 <kholmes> under papers
22:09:47 <[9of7]> good idea
22:09:51 <kholmes> www.tunes.org
22:10:36 <futhin> tunes.org doesn't necessarily offer the best and/or most understandable definition
22:11:43 <kholmes> yeah...I know
22:11:50 <kholmes> but there isn't a lot of stuff on the web
22:12:03 <futhin> find reflective on tunes for me lol :P
22:13:28 <futhin> i found http://lists.tunes.org/archives/tunes/1996-March/000869.html
22:13:48 <futhin> it sucks
22:13:48 <futhin> nevermind
22:14:37 <kholmes> In Computer Science, Reflection is the domain of programs that
22:14:37 <kholmes>        (effectively or potentially) describe and manipulate "themselves",
22:14:37 <kholmes>        or other related programs. This notion extends to programs the    
22:14:37 <kholmes>        philosophical notion of Reflection of human thought that can apply
22:14:37 <kholmes>        to itself. The idea is not quite new, and has been used by the    
22:14:39 <kholmes>        founding fathers of formal logic and computer science in their
22:14:41 <kholmes>        early theorems on the power and limits of reasoning and       
22:14:43 <kholmes>        computation (Cantor, Gödel, Turing, etc).
22:14:45 <kholmes> eh...bleh
22:14:47 <kholmes> sorry
22:14:58 <kholmes> In Computer Science, Reflection is the domain of programs that
22:14:58 <kholmes> (effectively or potentially) describe and manipulate "themselves", or
22:14:58 <kholmes> other related programs. This notion extends to programs the
22:14:58 <kholmes> philosophical notion of Reflection of human thought that can apply to
22:14:59 <kholmes> itself. The idea is not quite new, and has been used by the founding
22:15:01 <kholmes> fathers of formal logic and computer science in their early theorems
22:15:03 <kholmes> on the power and limits of reasoning and computation (Cantor, Gödel,
22:15:04 <futhin> reflection: ability to modify self
22:15:05 <kholmes> Turing, etc).
22:15:08 <futhin> reflection: ability to modify self
22:15:09 <kholmes> there...somewhat better
22:15:30 <futhin> yeah
22:15:35 <futhin> hm
22:15:41 <futhin> you didn't have to post twice
22:15:52 <futhin> it wasn't that bad, especially since i'm on a huge resolution :P
22:15:52 <kholmes> sorry
22:16:01 <kholmes> oh...heh
22:16:12 <kholmes> I reformatted it in emacs :)
22:16:17 <kholmes> (emacs rulez)
22:16:20 <futhin> the lline for me doesn't wrap until it gets to here ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>
22:16:32 <kholmes> :)
22:16:37 <futhin> how about u?
22:16:38 <kholmes> <-- 800x600
22:16:41 <futhin> where does your line wrap?
22:16:57 <kholmes> ----------------------------------------------------------------------------------------------------->
22:17:09 <futhin> lol my arrow is bigger than your arrow :P
22:17:14 <kholmes> now that its maximized
22:17:21 <futhin> heh
22:17:42 <futhin> yeah, forth is reflective
22:17:46 <futhin> it can modify itself
22:18:00 <kholmes> okay
22:18:10 <kholmes> take the word see
22:18:28 <futhin> not all languages are reflective.   C isn't.  C has a compiler with no support for code that modifies the compiler..
22:18:32 <kholmes> is there anyway of making see into data instead of just onto the screen?
22:19:13 <futhin> do SEE SEE and modify that code to your purposes
22:19:24 <kholmes> futhin: you don't need to modifiy the compiler unless you are writing the compiler
22:19:25 <futhin> copy the code and modify it
22:19:33 <futhin> C isn
22:19:51 <futhin> C isn't reflective if you can't modify the compiler. if you could, it'd be reflective wouldn't it ?
22:20:02 <kholmes> well...you need to be able to automate it
22:20:22 <kholmes> well...no
22:20:24 <[9of7]> cr tib 14 type         
22:20:31 <[9of7]> would that be a legal quine ?
22:20:42 <kholmes> let me try that
22:20:43 <futhin> CR TIB 14 TYPE let's u type 14 chars
22:20:49 <futhin> and then returns
22:20:52 <futhin> er
22:20:57 <futhin> and prints out 14 chars?
22:20:59 <futhin> naw
22:21:05 <futhin> nevermind, that should be legal..  
22:21:17 <futhin> TIB returns address?
22:21:35 <[9of7]> i feel it is not quite honest ... but it prints itself
22:21:49 <futhin> yeah
22:21:54 <futhin> :)
22:21:55 <[9of7]> so i wonder whether it qualifies as quine or not
22:22:06 <futhin> hmm, need definition of quine
22:22:44 <[9of7]> quine is a serious of instructions when executed outputs itself
22:22:48 <[9of7]> series
22:23:03 <futhin> yeah, it should qualify, you are just lucky that forth is leet :P
22:23:25 <futhin> try making it a word?
22:23:32 <[9of7]> hehe
22:23:38 <kholmes> how does it print itself? doesn't seem to work in gforth
22:23:38 <futhin> : blah cr tib 4 type ; 
22:23:43 <[9of7]> tib 11 type         
22:23:46 <[9of7]> shorter 
22:24:06 <kholmes> ahh...that works
22:25:16 <kholmes> wait
22:25:26 <kholmes> in forth...you have access to the dictionary, right?
22:26:04 <futhin> yeah, i think so
22:26:22 <futhin> if there's not already a built in word, you can hack it yourself
22:26:33 <kholmes> well...yeah
22:27:38 <[9of7]> futhin: you can also define a word if it exists already
22:27:53 <futhin> forth isn't like a C compiler you know, the compiler isn't a separate program that parses a text-file.  forth is all there
22:28:11 <[9of7]> depends
22:28:16 <[9of7]> not with a forth compiler
22:28:23 <[9of7]> not necessarily
22:28:50 <[9of7]> i mean, a target compiler. source in , object out
22:29:24 <[9of7]> like forthcmp (earlier cforth)
22:29:34 <[9of7]> or tcom
22:30:16 <[9of7]> there's not much left of the interpreter in cforth/forthcmp
22:31:14 <kholmes> even so...it doesn't matter if it is compiled or not
22:31:46 <kholmes> the idea is that the program needs to be able to manipulate itself, not the implementation of the language its written in
22:32:33 <[9of7]> so if the program is an os, and os tools, and a compiler ...
22:32:49 <[9of7]> using the tools to modify the sources
22:32:54 <[9of7]> and recompile ...
22:33:11 <[9of7]> you still kind of modify the system with itself
22:33:15 <kholmes> I suppose thats a form of reflection
22:33:26 <[9of7]> (with different components of it)
22:33:28 <kholmes> but the goal of TUNES is for that to be automated
22:33:55 <kholmes> (I think)
22:33:56 <[9of7]> you can automated modification of sources using sed
22:34:12 <kholmes> [9of7]: somewhat
22:34:16 <[9of7]> and recompilation can be automated too
22:34:37 <[9of7]> kind of static reflection :)
22:34:42 <kholmes> you can certainly do string-replacement
22:35:11 <kholmes> but...the language is supposed to smart about this
22:35:35 <kholmes> it should be able to see the program components
22:36:22 <[9of7]> the process which schedules sed and compiler sees those
22:36:41 <[9of7]> and may be smart about it'
22:37:05 <[9of7]> ah.
22:37:14 <[9of7]> its not "the language" anymore
22:38:09 <[9of7]> is a quine reflective ?
22:38:25 <[9of7]> i think it has to be
22:38:37 <kholmes> and data structures
22:38:40 <kholmes> it codes itself
22:39:03 <kholmes> hmm
22:39:23 <[9of7]> so, if a quine is useless
22:39:31 <[9of7]> is reflectiveness useless too ?
22:39:46 <kholmes> I doubt
22:39:57 <kholmes> since quine is a subset of reflection
22:41:04 <[9of7]> quine is more than reflective. it is useless to. so at can't be a subset of "reflection" :)
22:41:19 <kholmes> okay
22:41:24 <kholmes> so they overlap
22:41:32 <kholmes> same conclusion
22:42:08 <[9of7]> unless reflection and uselessness are the same ...
22:42:22 <kholmes> >:)
22:42:24 <[9of7]> then quine can be subset ...
22:44:33 <[9of7]> anyone interested in a 15 lines brainfuck compiler and executor ?
22:44:45 <kholmes> not i
22:44:48 <kholmes> :)
22:44:53 <[9of7]> (NOT an interpreter :)
22:45:01 <kholmes> whats it written in?
22:45:06 <[9of7]> forth
22:46:16 <[9of7]> all lines < 64 chars
22:50:59 <[9of7]> heard anything about a forth kernel using messaging to call words ?
22:51:11 <kholmes> no
22:51:25 <kholmes> i'm new to forth myself
22:51:51 <[9of7]> i use forth since about 1980
22:52:22 <[9of7]> but there are so many forth systems
22:52:30 <kholmes> cool...so it seems you like it
22:52:36 <[9of7]> i know only a fraction of those
22:53:07 <kholmes> especially with the many developments in software development since then
22:55:28 <[9of7]> one thing i like about forth is that you can run it on about anything
22:55:42 <kholmes> microwave ovens?
22:55:45 <[9of7]> if its knows 0 and 1, it should run forth
22:55:49 <[9of7]> hehe
22:56:10 <kholmes> I take it "no"
22:56:19 * kholmes thought that would be cool.
22:56:43 <[9of7]> and, if not 0 and 1, one could probably implement an analog forth 
22:57:01 <kholmes> heh...uh oh
22:57:13 <kholmes> that transcends my understanding
22:57:44 <[9of7]> i think i mentioned a freak experiment i'm occasionally wasting some time with
22:57:52 <kholmes> what is it?
22:58:22 <[9of7]> getting an idea of where the problems would arise when trying to 
22:59:01 <[9of7]> implement some kind of forth, using only     1 +!   -1 +!   1+   1-
22:59:24 <[9of7]> and one control flow contruct
22:59:27 <kholmes> isn't that a turing machine?
22:59:47 <[9of7]> it is supposed to be turing complete
23:00:09 <kholmes> well...I mean a real turing machine
23:00:25 <kholmes> just sliding up and down the tape, storing and placing values
23:00:36 <[9of7]> no store ...
23:00:40 <[9of7]> only increment
23:00:43 <[9of7]> decrement
23:00:44 <kholmes> oh
23:00:59 <[9of7]> and pointer up and down , by one too
23:01:25 <[9of7]> the control flow looks like this:
23:01:59 <[9of7]>    begin c@ while               
23:01:59 <[9of7]>   repeat
23:02:49 <[9of7]> (all atomic)
23:03:03 <kholmes> heh
23:03:11 <kholmes> if you implement it
23:03:23 <kholmes> then you got to write a full forth implementation in it
23:03:24 <kholmes> ;)
23:05:04 <[9of7]> (means, you can't put anything between   begin  ,  c@,  while
23:05:04 <[9of7]> and, to round it up,   key  and  emit
23:05:04 <[9of7]> that wasn't really the idea
23:05:04 <[9of7]> but, it may be the outcome ...
23:05:04 <[9of7]> as far, everything could be solved
23:05:09 <[9of7]>   inner interpreter  "next"  is possible
23:05:55 <[9of7]> using pointer as stack, positioning it, and returning to a known position too
23:06:09 <[9of7]> (i.e. two stacks feasable too)
23:06:57 <[9of7]> 2/ took me 64 operations ...
23:07:39 <kholmes> heh :)
23:07:48 <[9of7]> invert took 15
23:08:49 <[9of7]> or is about 350 instructions, and still a bug in it ...
23:09:14 <kholmes> you already wrote this?
23:09:46 <[9of7]> about 35 primitives i got now
23:10:09 <[9of7]> (including constants 1, 2, -1 ) ...
23:10:10 <kholmes> you're writing a forth in mini-forth?
23:10:48 <[9of7]> that mentioned instruction set is the instruction set of the earlier mentioned brainfuck compiler
23:11:03 <[9of7]> that 15 lines things
23:11:06 <kholmes> ahh
23:11:40 <kholmes> now you need to make a processor to accept them commands as its instruction set
23:12:13 <[9of7]> the forth written emulator is sufficient
23:12:26 <[9of7]> i'm just adding some optimising to the compiler
23:12:34 <kholmes> alright...going to bed now
23:12:36 <kholmes> tired
23:12:39 <kholmes> good night
23:12:43 --- quit: kholmes ("sleep")
23:59:59 --- log: ended forth/02.01.23