IRC log started Tue Feb 15 00:00:02 2000
[msg(TUNES)] permlog 2000.0215
-:- smoke [smoke@16dyn80.delft.casema.net] has joined #tunes
-:- SignOff smoke: #TUNES (One day sheep will rule the world)
-:- smoke [smoke@16dyn80.delft.casema.net] has joined #tunes
-:- water [water@tnt-9-8.tscnet.net] has left #tunes []
-:- smokie [tw026024@zaalf15.twi.tudelft.nl] has joined #tunes
-:- AlonzoTG [Alonzo@216-164-128-206.s206.tnt1.lnhva.md.dialup.rcn.com] has joined #tunes
-:- thomas [thomas@193.217.63.152] has joined #tunes
-:- SignOff smokie: #TUNES (BitchX-75+Deb1an -- just do it.)
-:- Kaufmann [kaufmann@jobim.fluid.impa.br] has joined #tunes
<Kaufmann> foo
<AlonzoTG> bar
<Kaufmann> where can I find RFCs?
<AlonzoTG> some .mil sites with low IP numbers...
<AlonzoTG> I have some links in my unix manuals....
07:00am
<Kaufmann> Ha-ha. Virginia passed UCITA. Now you're all screwed. Ha-ha.
* AlonzoTG/#tunes is a virginian.
<Kaufmann> well, Alan, you're screwed.
<AlonzoTG> =(
* AlonzoTG/#tunes wants ops and someone called "VA HOUSE" to join so I kan kick the SOB...
<Kaufmann> the senate is still considering it. So go write your representatives. Make a big fuss about it. Take a bus to the state capital and start shooting people's asses.
<AlonzoTG> yeah, I'm only a 2 hour's drive away from richmond...
<AlonzoTG> =\
<Kaufmann> 2 hours? Oh, stop being a wuss. I spend 2 hours on cross-town bus trips every single day, twice a day.
07:10am
<AlonzoTG> okay, so I drags my carcass down there; then what?
<Kaufmann> then you rent yourself a room near the House of Representatives, and start putting up flags and banners everywhere, and distributing pamphlets at the door.
-:- SignOff AlonzoTG: #TUNES (Read error to AlonzoTG[216-164-128-206.s206.tnt1.lnhva.md.dialup.rcn.com]: Connection reset by peer)
-:- AlonzoTG [Alonzo@216-164-128-206.s206.tnt1.lnhva.md.dialup.rcn.com] has joined #tunes
07:20am
<Fare> !c
<Kaufmann> if you say so...
07:50am
-:- SignOff Kaufmann: #TUNES (Ever notice how the only people who say "it's never too late to change your mind" are the undecided?)
-:- rares [rares@wtrb-sh2-port141.snet.net] has joined #tunes
-:- SignOff rares: #TUNES (Read error to rares[wtrb-sh2-port141.snet.net]: EOF from client)
-:- hcf [nef@me-portland-us321.javanet.com] has joined #tunes
-:- NetSplit: carter.openprojects.net split from sterling.openprojects.net [09:14am]
-:- BitchX+Deb1an: Press Ctrl-F to see who left Ctrl-E to change to [carter.openprojects.net]
-:- Netjoined: carter.openprojects.net sterling.openprojects.net
-:- smkl [sami@glubimox.yok.utu.fi] has joined #tunes
-:- SignOff smkl: #TUNES (changing servers)
-:- thomas [thomas@193.217.63.152] has joined #tunes
-:- Closing Link: TUNES[bespin.dhs.org] by devlin.openprojects.net (Ping timeout for TUNES[bespin.dhs.org])
-:- Connection closed from irc.us.openprojects.net: Success
-:- Connecting to port 6667 of server irc.us.openprojects.net [refnum 0]
-:- BitchX+Deb1an: For more information about BitchX type /about
-:- Welcome to the Internet Relay Network TUNES 
-:- Your host is devlin.openprojects.net, running version u2.10.05.18.(ipcheck4-5) 
-:- This server was cobbled together Wed Apr 28 1999 at 12 02:19 EDT
-:- devlin.openprojects.net u2.10.05.18.(ipcheck4-5) dioswkfcg biklmnopstv 
-:- [local users on irc(7)] 1%
-:- [global users on irc(292)] 43%
-:- [invisible users on irc(385)] 57%
-:- [ircops on irc(17)] 3%
-:- [total users on irc(677)]
-:- [unknown connections(1)]
-:- [total servers on irc(29)] (avg. 23 users per server)
-:- [total channels created(224)] (avg. 3 users per channel)
!devlin.openprojects.net Highest connection count: 112 (109 clients)
!devlin.openprojects.net Welcome to Open Projects!  You are on 4 ca 1(2) ft 14(14) tr.
-:- Mode change [+f] for user TUNES
-:- Mode change [+iws] for user TUNES
-:- JOIN activated by "TUNES #tunes tunes@bespin.dhs.org "
-:- TUNES [tunes@bespin.dhs.org] has joined #tunes
-:- Topic for #TUNES: TUNES, Free Reflective Computing System @ http://www.tunes.org || slate @ http://www.tunes.org/~water/slate-home.html
-:- topic set by hcf [Mon Feb 14 09:14:39 2000]
-:- [Users(#tunes:8)] 
[ TUNES     ] [ thomas    ] [ hcf       ] [ AlonzoTG  ] [ smoke     ] 
[ Plundis   ] [ abi       ] [ Fare      ] 
-:- Channel #tunes was created at Sun Feb 28 08:48:06 1999
-:- BitchX+Deb1an: Join to #tunes was synced in 8.676 secs!!
-:- Mode change [-ws] for user TUNES
-:- Netjoined: lackey.openprojects.net devlin.openprojects.net
-:- AlonzoTG [Alonzo@216-164-128-206.s206.tnt1.lnhva.md.dialup.rcn.com] has joined #tunes
-:- rares [rares@wtrb-sh1-port79.snet.net] has joined #tunes
-:- rares [rares@wtrb-sh1-port79.snet.net] has left #tunes [Segmentation]
-:- SignOff smoke: #TUNES (Ping timeout for smoke[16dyn80.delft.casema.net])
-:- SignOff thomas: #TUNES ([x]chat)
-:- smoke [smoke@16dyn80.delft.casema.net] has joined #tunes
-:- SignOff smoke: #TUNES (brb)
-:- kc5tja [kc5tja@garnet.armored.net] has joined #tunes
-:- SignOff hcf: #TUNES (Leaving)
-:- smoke [smoke@16dyn80.delft.casema.net] has joined #tunes
-:- SignOff smoke: #TUNES (Read error to smoke[16dyn80.delft.casema.net]: EOF from client)
-:- ult [noone@user-38lc6fa.dialup.mindspring.com] has joined #Tunes
-:- smoke [smoke@16dyn80.delft.casema.net] has joined #tunes
-:- SignOff ult: #TUNES (bbiaf)
-:- NetSplit: wang.openprojects.net split from irc.linux.com [02:23pm]
-:- BitchX+Deb1an: Press Ctrl-F to see who left Ctrl-E to change to [wang.openprojects.net]
-:- Netjoined: wang.openprojects.net irc.linux.com
-:- Plundis [plundis@130.238.23.252] has joined #tunes
-:- ult [noone@user-38lcn4i.dialup.mindspring.com] has joined #Tunes
-:- SignOff smoke: #TUNES (Ping timeout for smoke[16dyn80.delft.casema.net])
-:- smoke [smoke@16dyn80.delft.casema.net] has joined #tunes
-:- SignOff ult: #TUNES (Read error to ult[user-38lcn4i.dialup.mindspring.com]: Connection reset by peer)
-:- lar1 [larman@1Cust50.tnt31.sfo3.da.uu.net] has joined #tunes
-:- mibin [mibin@an1-573.tiscalinet.it] has joined #tunes
-:- smkl [sami@glubimox.yok.utu.fi] has joined #tunes
-:- lar1 has changed the topic on channel #tunes to: TUNES, A Free Reflective Computing System @ http://www.tunes.org
<Fare> hum
* Fare/#Tunes is writing a paper on the architecture of computing systems
-:- rares [rares@wtrb-sh5-port35.snet.net] has joined #tunes
<Fare> the paper is currently titled "Six Steps of Structural Sophistication in System Software", although I'm looking for another word than "Steps" (if possible, beginning with S) because these "Steps" are not strictly hierarchically dependent.
03:10pm
<rares> i'm still not convinced!
<rares> hehe
<rares> abi, rares is not convinced
<abi> ...but rares is addicted to politics...
<kc5tja> Fare: !!
<rares> no, rares is not convinced
<rares> abi: no, rares is not convinced
<abi> okay, rares.
<Fare> kc5tja: cheers!
<Fare> ok, so the steps correspond to the following classes of system components:
<rares> incidentally I use aboute 4-6 steps to prove code is free speech in the dvd-discuss ml
-:- air [brand@p0wer.qzx.com] has joined #tunes
<Fare> runtime libraries; resource monitors; compilers; admission controlers; code verifiers; code synthetizers
<kc5tja> Fare: Long time no see.  :-)
<Fare> which in turn correspond to incremental programming; concurrent programming; dynamic programming; high-level programming; contract enforcement; metaprogramming
<Fare> wassup w/ dolphin?
<lar1> Fare: #dolphin or #osdev
<kc5tja> Is water here?
<kc5tja> Oh good.  Dolphin is now on SourceForge.
<lar1> Yay
<kc5tja> Though I can't seem to upload the source to them yet -- their CVS servers are royally crocked.
<kc5tja> 0.5 is _almost_ done (technically, it's Dolphin 0.48, since it has all the features of 0.5 except support for multiple address spaces).
03:20pm
<Fare> multiple address spaces are nice for efficient untrusted code (like, emulators, including self-emulators), but not strictly necessary
<kc5tja> Fare: The _sole_ reason it's there is to do stuff like memory mapped files (which is a big help in some applications I'm interested in developing), software development, and so on.  The idea is to run only untrusted code in a separate space.  The bulk of the system is in a single address space, however.
<Fare> I suppose some kind of same-processor code-morphing could bring better security with less hardware cost.
<lar1> Fare:  How do you reccomend implementing security?
<kc5tja> Fare: Only if the machine language for the hypothetical processor has enough semantics assigned to it that you can guarantee type safety.
<Fare> lar1: by using the latter high-level components in my "six steps": compilers, trust brokers, code verifiers.
<Fare> lar1: certainly NOT at the lower library or monitor levels.
<Fare> security is a high-level concept. Trying to solve it with low-level tools is a doomed abstraction inversion.
-:- eihrul [lee@usr5-ppp150.lvdi.net] has joined #tunes
<lar1> Hey eihrul
<rares> water is an abstraction inversion
<Fare> :)
<rares> it is when it gets cold it expands
<lar1> abstraction inversion?
<abi> abstraction inversion is described in ftp://ftp.netcom.com/pub/hb/hbaker/CritLisp.html
<rares> abi, up is down
* Fare/#Tunes expanded just a bit on the uK section of the Glossary, once again
<rares> abi?
<abi> yes, rares?
<lar1> How is the Glossary currently maintained?
<rares> abi: up is down
<abi> i already had it that way, rares.
<Fare> lar1: not much
<rares> abi, down?
<abi> wish i knew, rares
<rares> abi's a bit limited
<lar1> Fare:  Should the Glossay be DBifyed?
<Fare> should, yes
<lar1> My I have your holy blessing to do that?
<Fare> sure, and have had for some time
<lar1> I have your blessing to DBify anytihng on the tunes page?
<Fare> as long as you respect the README.contribute; and if possible, what I proposed about this DBification on the list
03:30pm
<lar1> Fare:  Where is the README.contribute?
<Fare> root of the tunes CVS hierarchy
<Fare> as for comments on DBification, look to my initial replies to prof Shapiro on the list...
<lar1> How do I access the tunes CVS in win32?
<Fare> "protection" in operating system kernels is really just like "protection" in human societies' governments
<Fare> we shall get rid of it
<rares> Fare the only way to do it is:
<Fare> lar1: install cvs for win32; or ssh into a computer with real system software.
<lar1> Fare:  Ok
<rares> The depth of abstraction is such that bothe coder, the user, and even the computer can block bad code
<rares> here's how you do it:
<rares> make security a module
<rares> then have the security module scan the program every once in a while 
<rares> the secmodule would be a user
03:40pm
<rares> Okay
<rares> explain why Linux/Borland survey is getting 2.5 x the attention UCITA is
<lar1> Could a thread preproccess the code to see if its naughty?
<rares> UCITA 500 Lin/Borland 1200
<rares> comments that i
<rares> s/i/is
<smkl> rares: borland discussion is spammed mechanically
<kc5tja> lar1: Not without actually executing it.
<rares> kc: actually it should be possible
<lar1> kc5tja:  Why must the code be executed?
<kc5tja> lar1: Because it's impossible in current computer architectures to unambiguously identify code from data.  For example, many, many, many compilers will optimize switch() and case: statements into a jump-table which usually resides fairly close to the switch code.  How does one interpret this jump-table?
<Fare> UCITA 500 ?
<Fare> smkl! did you solve your problems with cybernethics@foo subscription?
<kc5tja> Fare: It's a bill in the U.S. that will make it legal for companies to misuse their customers, and it will give software companies the equivalent of a communist regime over what people can do with their software.
<lar1> kc5tja:  Follow the flow of execution?
<Fare> is mrsmkl@bar a valid email address?
<kc5tja> lar1: How do you do that though?
<Fare> (fscking slow keyboard)
<smkl> Fare: hrrm what kind of problems did i have?
<Fare> email to mrsmkl@bar was returned to me
<smkl> mrsmkl@saunalahti.fi should be disabled now
<lar1> kc5tja: start at the top of the code and evaulate what happens... emulate it if you wish
<kc5tja> lar1: Emulation is the only way to do it.  Because that switch code can be executed IRL innumerable times, each taking a different path.
* rares/#tunes thinks it's time for a regular flood about now cheap clean tools to totally scare the fuck out of the market and to add the kill UCITA banners
<Fare> well, shall I replace it by smkl@tunes.org where applies?
<rares> i don't mean cracking
* kc5tja/#tunes thinks it's high-time for an outright armed revolution in this country.
<lar1> kc5tja:  Emulation is proccessor intensive though... I think the multi memory space is still faster
<lar1> rares:  Whats UCITA?
<abi> it has been said that UCITA is Uniform Computer Information Transactions Act
<lar1> Whats that?
<kc5tja> lar1: Elucidate on your algorithm, if you will.'
03:50pm
<smkl> Fare: i already have smkl@tunes for cybernethics ... and i hope that i remembered to remove it from other places
<lar1> kc5tja:  Elucidate?
<kc5tja> lar1: To enlighten, (from Lucht, or Light).
<rares> I'm saorry u have failed to pay for the mandatory upgrade of software in your computers your machine at Cetral Medical Emergency Room Cyber Surgeon shall be sh... Oooo...*
<lar1> kc5tja
<Fare> "security as a runtime module" is no better than security in the kernel
<lar1> oops
<lar1> Fare:  Do you sugeuest that all code be trusted
<lar1> kc5tja:  I haven't designed it or anyhing, just a quick thought I had
<Fare> security should certainly have modules at meta^n runtime, for all n, not only n=0 (as little as possible at expensive n=0)
<Fare> but to be effective, there needs be a centralized trust broker
<lar1> YABL, no?
<Fare> and THAT is the essential point about security
<air> lar1: when written in a sage language then yes all code is trusted
<Fare> YABL?
<abi> i think YABL is Yet Another Burden Layer
<air> s/sage/safe/
<rares> Fare I suggest something else
<lar1> air:  sage language?
<rares> collapsing all interfaces to nomore than thre levels
<lar1> air: Oh, heh ;)
<lar1> How does a 'safe language' ensure all code can be trusted?
<kc5tja> lar1: Think about it for awhile...you'll eventually see that it's just not possible with the computer hardware we have today.  :)
<kc5tja> lar1: Type and semantic safety is explicit in the language.
<air> yes it is
<Fare> rares: why three, and not four? why not 3.14159 ?
<air> a safe OO language
<lar1> How does that protect against apps scribbling on eachothers memory?
<kc5tja> lar1: If you don't have a reference to an object, how can you use it?  How can you destroy it?
<air> lar1: if u cant define a pointer than how can u write on another apps memory
<eihrul> Fare: do you know of any (good) garbage collector benchmarking programs?
<rares> Fare 3: 1st machine-dependent, 2nd job dependent, 3rd moron dependent 
<lar1> So pointers must be assigned a value before useage in a safe language or you can't have pointers at all?
<kc5tja> lar1: A safe language technically doesn't have `pointers'.  Instead, they have references, which is a more abstract concept.
<lar1> kc5tja: Couldn't a thread see if an app is about to write out of its memory area?
<kc5tja> lar1: Nope.  Not unless the location is a constant that is well-known throughout the program.  Take for instance, the following C code:
<kc5tja> int strlen( const char *s )
<kc5tja> {
<kc5tja>    int length = 0;
<air> lar1: a safe language not only prevents an app from writing out of its memory but it ensures that the app only writes to the location it was suppose to write to
<kc5tja>    while( *s++ ) length++;
<kc5tja>    return length;
<air> lar1: which prevents bugs
<kc5tja> }
<Fare> eihrul: no. All the less since a GC is only part of a whole
<Fare> eirhul: to test GCs independently from the rest is VERY difficult
04:00pm
<eihrul> Fare: i know, that's my problem
<lar1> kc5tja:  thats infinite, no?
<kc5tja> lar1: The C code is perfectly valid, and works perfectly fine.  But what if the end of string is never found?  This can only happen if the function receives a wild pointer.
<Fare> it's a bit mine, too
<kc5tja> lar1: Nope.  That's precisely how the C function strlen() is implemented.
<eihrul> i've been testing them in allocation and collection speeds with a little random allocation patterns thrown in to try and emphasize some fragmentation
<Fare> eihrul: what application/language/compiler/foo are you interested in?
<Fare> what allocation style do they lead to?
<lar1> kc5tja:  How could *s++ return false?
<rares> ... /0
<eihrul> Fare: well, i have three sets of benchmarks for randomly sized objects, large objects, small objects, that are intensely allocated and freed...
<kc5tja> lar1: So while the library code is known-good (well, as far as ANSI is concerned), what the client calls into it could be complete garbage.  Ergo, when loading the library function into memory, how can the OS/security module know that the code will ever reference out-of-bounds memory?
<Fare> the typical X11 app will have different storage allocation than a typical postscript document, which will behave differently than a Haskell script, etc
<lar1> kc5tja: Hmm, I see...
<eihrul> Fare: but i'm trying to think of a slightly more fair test that will model more closely the "average" programs allocation/work patterns :)
<kc5tja> lar1: *(s++) is how it's interpretted in C.  Remember s is a character pointer.  *s dereferences the pointer to return the current character.  s++ post-increments the pointer.
<smkl> it is possible to typecheck ASM
<eihrul> abi: tal?
<abi> i think tal is typed assembly language at http://www.cs.cornell.edu/talc/default.html
<lar1> kc5tja: Ah, ok
<Fare> it's about size, frequency, but also about locality, pointing backwards in time, etc, etc
<eihrul> Fare: well, i'm not trying to be thorough, just fair :)
<lar1> Is multi memory the only way to provide security while executing untrusted code?
<Fare> about "bursts" of allocation/deallocation, circularity in structures, and much more
<eihrul> Fare: this is just a school project, so i don't have to examine everything :)
<Fare> also, do you use finalization, etc
<Fare> eihrul: I suppose the authors of Great Circle have a lot of data, but it might be proprietary.
* eihrul/#tunes will just build a tree and walk around in it...
<Fare> Boehm & Wilson may have a lot of data, too, and freely available
<eihrul> since i don't have more than a night to get this done :)
<Fare> finally, the right place to look for help is gclist@iecc.com
<kc5tja> lar1: Nope.  Use of a singular programming language is another way.  Consider the original LISP environments -- these are systems that are fully garbage collected, etc.  There was no way to muck with stuff you didn't own without relying on an external C extension to the language.
<eihrul> Fare: already subscribed :)
<eihrul> Fare: read all the archives
<Fare> kc: original LISP systems didn't have external C extensions.
<kc5tja> Fare: I meant changes to the LISP interpretter's source code.
<Fare> On the other hand, their assembly implementation was open, and LISPers often used LAP (LISP ASSEMBLY PROGRAMMING)
<lar1> kc5tja:  How about in an unsafe language envrioment?
<Fare> lar1: unsafe wrt what?
<kc5tja> lar1: Two methods are used there.  First, run-time profiling (basically emulation).  This, as you indicated, is abhorently slow on any processor except the Transmeta (TM was designed for this purpose, so naturally, it's going to rock at it).  The second is multiple address spaces.  The latter works because it's a hardware enforced sand-box within which the program runs.
<Fare> kc: why abhorrently slow?
<lar1> BRB
<Fare> "code morphing" is exactly how Executor works
-:- SignOff lar1: #TUNES (Leaving)
<Fare> or maybe even FX!32
<Fare> and also the PowerMac's m68k emulation
04:10pm
<Fare> and IBM's 3x0 stuff, too
<kc5tja> Fare: They work because of two reasons.  First, they both rely on outside MMU management to enforce a sandbox.  Second, since applications of those environments never touch the hardware, it's possible to avoid such decisions as, "If this MOVE.L instruction is trying to reference I/O registers, go here.  Otherwise, just store the data."
<Fare> and some Java JITs
<kc5tja> Fare: And none of them even come close to native speeds.
<Fare> I guess the Transmeta codemorphing doesn't come that close to VLIW native speed, either
<rares> I can't see how transmeta pulled it off though they said straight code runs slower than morphed...
-:- hcf [nef@me-portland-us909.javanet.com] has joined #tunes
<kc5tja> No, but the architecture is designed to perform I/O emulation trapping in hardware.  Read some of the patents on it.
<kc5tja> rares: That's a lie.  Since straight code is, by definition, what makes up the morphed instructions, it can't possibly be true.  :)
<Fare> efficient I/O trapping is handy, but not that useful for morphing of safe high-level language code
<kc5tja> And then there's the issue of emulating CPU flags, the CPU's target memroy management architecture (e.g., segmentation, paging, etc).  It all adds up.
<Fare> I'd have preferred efficient trapping for type tags and read/write barriers
<kc5tja> Fare: Now that's different.  Lar1 and I were talking about assembly code, not high-level code.  I agree that morphing semantic trees is perhaps the best way to distribute software.
<Fare> kc: sure, the Transmeta can emulate a X86 pretty fast, that's what it's designed for; I'm still convinced that the emulated code is significantly slower than "native" underlying VLIW
<smkl> with TAL, it's possible to send native code, and have it typechecked
<Fare> DMacs?
-:- hcf has changed the topic on channel #tunes to: TUNES, Free Reflective Computing System @ http://www.tunes.org || slate @ http://www.tunes.org/~water/slate-home.html
<kc5tja> Fare: Not according to the reports I've heard.  70 to 80% is what I've been told.  The explanation is that the way the VLIW instructions are packed are optimized for one VLIW instruction block per x86 instruction.
<kc5tja> Of course, it doesn't actually realize that goal in all cases, but for most operations, it seems to succeed.
<rares> Dolphin eMacs
<kc5tja> rares: AHH!!  No No NO!  Emacs will not sit on any Dolphin installation of mine.  Long live JED!  :)  Emacs -- on a diet!
* kc5tja/#tunes doesn't like the concept of a text editor that is its own operating system, complete with a suite of applications.  :-)
* kc5tja/#tunes giggles
<rares> like StarOffice?
* Fare/#Tunes does like it; but hates an OS w/o multiprogramming
<kc5tja> Hmm...  Dolphin JED -- DED?  ;)
<rares> Dude here's the problem
<kc5tja> Fare: I like Emacs too.  I'm being a bit facetious(sp?).  But still -- 20MB for a text editor is insane.  :)
* kc5tja/#tunes wants a scriptable text editor, preferably through a standardized object interface (like CORBA).
* smkl/#tunes removed Emacs so he could install StarOffice
<rares> all you need to do is split emacs into pieces and add the interface on top
<rares> LOL smkl
<Fare> CORBA sucks
<kc5tja> Fare: Like hell.
<hcf> Fare: another word than "Steps", stages
<kc5tja> Fare: CORBA kicks butt.
<rares> CORBA programmers suck, CORBA rules
<Fare> hcf: actually stages was what I used first
<smkl> i need SO to read MS Word docs :/
<Fare> hcf: but it kind of implies that the steps don't commute
04:20pm
<hcf> degrees
<Fare> degrees ain't better
<Fare> Axes might be good, but doesn't begin by an "S"
<hcf> theres just no pleasing u is there?
<smkl> Sexes ?
<rares> heh
<Fare> lol
<Fare> (especially the sequence between hcf's and smkl's comments)
<kc5tja> Sections?
<rares> try Signs
<Fare> Stigmatas
<rares> Signs
<Fare> but there are more than three
<kc5tja> Stalemates.
<kc5tja> :)
<Fare> Sources?
<rares> what tf does 3 have to do w/ this
<rares> Signs
<kc5tja> And why are we looking for words that start with an S?  ;)
<Fare> rares: 3 shall be the number and the number shall be 3
* kc5tja/#tunes must have missed something.
<kc5tja> Five is RIGHT ... OUT.
<Fare> \title{Six Sources of Structural Sophistication in System Software}
<kc5tja> Ehh...that sounds good enough as it is.. ;-)
<rares> use the word Signs
<rares> Sophistication is bad
<kc5tja> Sets?
<rares> nop[e
<kc5tja> As in, "Six Sets of Structure in System Software"
<rares> Structure in software
<rares> or Book on Structure
<rares> Book two Software
<air> what the hell are u guys doing? :)
<rares> i do not know
<kc5tja> Brainstorming.  My, what loud weather we're having!
<rares> Microsoft aka SourceFudge.com
04:30pm
<kc5tja> Hey, I use SF primarily for its task managemen and bug management interface.  I don't have the time to set up one of my own.
<Fare> why is sophistication bad?
* kc5tja/#tunes likes the sophistication word in that title.  It adds just the right amount of syllables.
<Fare> and there should be six words in the title, too
<smkl> you could have Seven, and then SSSSSSS somewhere so it would be recursive
<rares> Seven Evaluates Very Elegantly, Not?
<Fare> anyway, I haven't found a suitable plan for the article
<Fare> the goal was an architectural description of key components in a system architecture
<Fare> for TUNES as well as for PHENIX
-:- SignOff rares: #TUNES (Read error to rares[wtrb-sh5-port35.snet.net]: Connection reset by peer)
<Fare> darn! this life of brian sciprt on the net hasn't got "three shall be the number..."
<kc5tja> Fare: That's because that quote is from The Holy Grail.
-:- rares [rares@wtrb-sh9-port14.snet.net] has joined #tunes
<Fare> oh!
<kc5tja> Specifically, the Holy Handgrenade of Antioch.
<kc5tja> :)
* Fare/#Tunes hits head against wall
<Fare> sure
<Fare> Bard's Tale 2 had Holy Handgrenades, too
<kc5tja> Why not?  They're imminently useful.
<hcf> Fare: how about suites?
<Fare> suits go to hell!
<Fare> anyone wearing a tie should go to a psychiatrist
<hcf> not suits, suites
04:40pm
<Fare> ok, gimme the presidential suite
* eihrul/#tunes nods.
<rares> well I gotta go
-:- SignOff rares: #TUNES (KVirc 1.0.0 Millennium BETA 3)
-:- SignOff smoke: #TUNES (z!)
04:50pm
<eihrul> mmm
<eihrul> quicksort worked well enough as a metric...
<eihrul> since the time that itself takes dwarfs the allocation time (and that's what i wanted to prove in the first place :>)
<eihrul> s/allocation/allocation\/collection
05:00pm
-:- ult [noone@user-37kbamr.dialup.mindspring.com] has joined #Tunes
-:- water [water@tnt-10-142.tscnet.net] has joined #tunes
<water> hey full house
* water/#tunes has decided to add re-write systems to his shameless plug list :)
<water> hello?
<abi> rumour has it hello is a multi-threaded operating system written in Standard ML and can be found at http://www.ics.hawaii.edu/~esb/prof/proj/hello/
<water> heh
<ult> rofl
<water> hm. i can't just depend on eihrul for interaction about slate
* ult/#Tunes nods
<ult> eihrul is untrustworthy
<AlonzoTG> om
<eihrul> eh?
<water> well he seems to be busy at least
<water> oh n/m :)
<AlonzoTG> Water: lets start our own school where the only language class is an elective in Lojban. =)
<water> screw lojban
<AlonzoTG> Got anything better than lojban?
<water> eihrul: got time to talk?
<water> atg: yep <> :)
<AlonzoTG> is that the symbol for slate?
<eihrul> water: hold, need 5 minutes to compile my science project :)
<water> although it's not as nearly as well developed as lojban
<water> abi <>?
<abi> <> is Modality or a diamond symbol or your Arrow-like human language idea
<AlonzoTG> okay... /me starts searching his hard drive for the recient arrow update...
<water> i'll web doc it over the next few days
<water> you know, i had no idea yesterday was st valentine's until someone mentioned it today at work :)
<AlonzoTG> Is it the Arrow System Philosophy, Jan 6, 2000 ?
<AlonzoTG> is that version worth printing?
<water> well, it's mostly the same content as the earlier version, but it's more legible
<water> i haven't put in the time needed to re-engineer it
06:10pm
<water> unless someone's willing to help :)
<water> bleh. i think that even if i lived to see 3000 AD, i wouldn't have time to fully explain all my ideas
<eihrul> ok
<eihrul> my science project is compiled
<water> what is it, if i may ask?
<eihrul> garbage collectors... i'm evaluating them against the elusive explicit memory management
<AlonzoTG> rats, GSVIEW 32 is trying to talk direct to my printer instead of using the 'doze print subsystem. =(
<kc5tja> Garbage collectors are very cool.
<water> hm
<AlonzoTG> GC is more of a language/library issue, not neccessarily an OS issue....
<water> eihrul: rewrite encompasses mem-mangement spectrum (manual, stacks, gc's of various types...)
<kc5tja> AlonzoTG: Correct.
<AlonzoTG> Just let the program waste its own memory and then kill it when if it takes too much...
<kc5tja> AlonzoTG: Not acceptable in a high-availability environment.
<eihrul> water: well, that's not necessarily what my science project is trying to prove, but yes, i still need to look over rewrite :)
<AlonzoTG> Water: is there a new arrow paper coming out soon?
<water> eihrul: dude rewrite as a spec language is really powerful
<water> atg: when i get time (i.e. someone help please)
<eihrul> and so far
<eihrul> while GC collection mechanisms are slower in microbenchmarks versus explicit management
<AlonzoTG> Okay. I'll take a gander at it...
<eihrul> as a whole they seem to make programs run faster :)
<AlonzoTG> I can't print it from here unless I find myself a better PS viewer....
<water> eih: sure, because they *automate*
<eihrul> well, that's what my science project was conducted to examine :)
<kc5tja> eihrul: Someone did a test of that theory by linking an X window server with a Boehm conservative GC library.  It was reported that the X server was about 2 to 3 times faster, and produced zero memory leaks.  :)
<water> oh
<eihrul> yep, it was even kind of surprising to me :)
<eihrul> i expected neglible slow-down, but not necessarily a speed-up :)
-:- SignOff mibin: #TUNES (Ping timeout for mibin[an1-573.tiscalinet.it])
06:20pm
* eihrul/#tunes really needs to catch up on rewrite.
<kc5tja> What is rewrite (in this context)?
<water> well it's not vital
<water> rewrite logic
<eihrul> sure
<water> the logic of substitution of expressions as groups of terms
* kc5tja/#tunes isn't familiar with it.
<eihrul> but doesn't mean i shouldn't learn more about it
<water> it derives from the process of solving equations
<kc5tja> water: Just curious -- isn't that like EBNF?
<water> so you can specify things algebraically
<water> kc: not quite
<water> rewrite allows for non-determinism in semantics, which a rewrite system as meta-logic can dis-ambiguate dynamically
<water> in other words, reflection allows you to tweak search-strategy :)
<kc5tja> water: ahhh...algebrae...  And since most algebrae follow the same basic set of rules (e.g., composition of functions and such), it's possible to simplify complex systems of "equations" (interactions) by "short-circuiting" the algorithm, as you would simplifying an equation (e.g., using quadratic formula to solve a 2nd order polynomial)
<water> sure that's the basic idea
<water> abi tell kc5tja about maude
<eihrul> does anyone know of good graphing software that can spit out images?
* kc5tja/#tunes will check it out as time permits.  For now, it's bookmarked.  :)
<water> hm the squeak guys are discussing new syntaxes
<kc5tja> eihrul: libgd1 is used by PHP3 for drawing graphs and such.
<kc5tja> eihrul: It spits out .GIF files IIRC>
<eihrul> kc5tja: url?
<kc5tja> None available -- I just know it exists.  I know about it because it's a Debian Linux package.
<water> heh. maybe i should post up my slate syntax ideas :)
<kc5tja> Try going to www.google.com and search for it there.
<eihrul> water: perhaps >:)
<eihrul> but without the meta behind the syntax
<eihrul> it's just syntax 
<water> sure
<kc5tja> And without the syntax behind the meta, it's just meta...
<kc5tja> ;)
<water> btw, eihrul, you don't object too much to having slate math operators being non-method objects, do you?
<eihrul> okay, so have you come to any more conclusions on the naming issue? 
<eihrul> well, it's somewhat diverging from the idea that numbers are objects &c
<eihrul> that most OO languages use...
<water> hm well namespaces seem to solve most of the problems with naming
<water> i know
<kc5tja> brb
<water> it'll need work to make it usable
<eihrul> rmm, not that... the 'directory' thing :)
06:30pm
<water> hm?
<water> what directory thing?
<eihrul> relative addressing of objects/namespaces
<water> (heh maybe we should stick to one thread at a time to avoid confusion :)
<water> well the directory thing is dynamic, you realize
<eihrul> .., ., /, &c
<water> it's based on the current method-context stack
<eihrul> well, there's ambiguity...
<water> that's the only way it works and you avoid inconsistency
<eihrul> of whether that stack is of activations, or is of objects :)
<water> oh well right
<water> hm
<eihrul> or rather... i mean by objects looked up by the enclosing expression
<water> well it should be obvious what .. is supposed to select
<eihrul> well, it's not quite obvious what / selects...
<eihrul> as i see it as a stack of stacks
<water> uh
<eihrul> you have a stack of frames
<water> ok i follow that
<eihrul> and each frame itself has a stack of objects resulting from an expression :)
<water> eek
* water/#tunes finds it a bit hard to swallow, but ok
<eihrul> well, i had though yesterday that was what you had inferred
<eihrul> i mean to say that the stack within the frame itself is inconsequential :)
-:- lar1 [larman@sdn-ar-008casfrMP088.dialsprint.net] has joined #tunes
<water> oh
<water> whew :)
<eihrul> so it was more of a question of why you wanted...
<eihrul> but it was just a miscommunication it seems :)
<water> hm so the question still remains what / should mean
<eihrul> kc5tja: yeah, but that's what i mean :)
<eihrul> oops, wrong channel
<water> perhaps / should be a reference point, sort of a relatively-defined namespace root
<water> heh
<eihrul> hmmm, libgraph is nice
<eihrul> pie charts, bar graphs, line graphs... it does it all
<water> that's nice
<water> (i wonder how much gnumeric handles?)
<eihrul> seemed as if it graphed functions
<eihrul> whereas i'm graphing values
<eihrul> and graphing lots of constant functions doesn't sound quite fun
<water> heh
06:40pm
<water> what do you think of the idea i mentioned for / ?
<eihrul> hold
<water> k
<eihrul> well...
<eihrul> sounds similar to what i was thinking
<eihrul> although i was merely thinking of having relative roots and absolute roots to model both activations and the namespace
<eihrul> (and wasn't particular imagining any uses beyond that, but :>)
<water> hm
<water> ultimately the question is where does / fit into user code, and what should it mean?
<eihrul> well, i was thinking of having it as the absolute root
<eihrul> and : as the relative root
<eihrul> though how relative roots get bound is another subject...
<water> well, if : is the relative root, then what's the syntactic assigner?
<eihrul> yes
<eihrul> that is the question...
<eihrul> since : needs to be bound to the enclosing cloned method object
<water> well it doesn't really matter what keyord/symbol we use really
-:- ult_ [noone@user-37kbat3.dialup.mindspring.com] has joined #Tunes
<water> perhaps even <-
<eihrul> well, that's particularly why it is not aesthetically pleasing
<eihrul> because you have this notion of 'assignment' :)
<water> but even : denotes assignment or at least binding
<eihrul> i see it as denoting redirection...
<water> hm -> suggests advancing
-:- SignOff ult: #TUNES (Ping timeout for ult[user-37kbamr.dialup.mindspring.com])
<water> which suits the stream-of-values idea
<water> as in "a->b" => "a takes on value b"
<water> or "...moves on to value..."
06:50pm
* kc5tja/#tunes needs to go.  A friend of mine is having car problems, and I need to go and pick him up.
-:- SignOff kc5tja: #TUNES (I'll be back soon, I hope...)
<water> kc: ok nice seeing you
<water> eih: does this jive? :)
<lar1> jive?  Sweet... I am not the only one that uses that word!
<water> i use whatever words i find appropriate
<water> and i like exercising vocabulary
<lar1> I as well
<lar1> Unfourtnally, I can't spell most of it right ;)
<eihrul> i gues...
<eihrul> i'm still not sure about the whole relative addressing scheme here, though :)
<water> neither am i
<water> the problem is that an absolute scheme doesn't work either, afaik
<eihrul> yes, anythign absolute is somewhat evil :)
<water> because then you lose the explorative metaphor
<water> well, i suppose / could be dropped, but even so it would appear in namespace selection expressions
<water> e.g. ../otherContext
<water> so maybe this directory metaphor won't work
<water> e.g. another syntax for managing namespaces
07:00pm
<water> hm
<water> nothing seems intuitive
<water> perhaps the static namespace directory metaphor should be kept
<water> with / being the root or system namespace
<water> (and also the root of the gc :)
<eihrul> perhaps...
<eihrul> but you still have the "self" namespace
<eihrul> that somehow needs to be accounted for
<water> ./ ?
<abi> zero
<water> abi: bah
<eihrul> well, i'll let you know if i think of anything more intuitive :)
<water> okay
<water> and we already seem to need two "directions" for namespace access
<ult_> Why?
<water> one for the ordinary structural dimension, the other for behavior-meta dimension
<water> er meta-behavior
<eihrul> ... /methods, /meta :)
* ult_/#Tunes pokes eihrul
<water> hm
<water> ../meta
<eihrul> the ... was just so my irc client
<eihrul> doesn't interpret those as commands :)
<water> oh
<ult_> hmm
<ult_> /meta
<ult_> /maybe your client just sucks.
<water> all irc clients suck
<water> 'cause they ain't based on tunes ;)
07:10pm
<water> er what was /methods supposed to access?
<eihrul> the stack
<water> oh great i just considered that namespace access should be subject to some reifiable and modifiable protocol
<eihrul> but
<eihrul> i still don't think it's quite elegant
<water> no not yet
<water> we should consider the context in which code is actually used
<water> i.e. we need to understand the computational model wrt the stack
<ult_> why on earth does Netscape insist on reloading pages when I click 'back'?
* ult_/#Tunes wonders what goes through the mind of the AOL devs...
<water> no proper caching?
<ult_> nope
<ult_> I've never had a single version properly cache anything
<water> yuck
<ult_> And every version I've used for some reason always downloads usenet articles twice.
<ult_> (Just on Linux, mind you)
<water> eih: so how do we use the stack?
<ult_> Will slate make the stack[s] directly accessable?
<water> ultimately the stack starts by executing a method entered by the user on a command-line for instance
<water> ult: well we're probably going to get into that
<water> ult: i've been working out continuations, but it's not ready yet
<ult_> Hmm.
<water> but executing a method results in cloning the thing
<water> the activation context itself is the thing on the stack, right?
07:20pm
<water> hm since we're (at least i am) considering concurrent threads and processes within the language, we should consider the stack as one of many
* ult_/#Tunes nods
<water> and as we discussed many days ago, the activation context's 'parent' is the enclosing (calling?!?) context
<water> i just realized there may be a big difference in slate over enclosing vs calling correspondence
<water> ult: having the context inherit from its enclosing context is what enables nested variable scoping
<water> hmmm
<water> there's something important there
<water> hm i should draw out this whole model to be sure of what's going on
<water> i'll put it online too
<water> damn i've been getting behind on the web docs
<water> eihrul: afk?
<abi> i guess afk is Away From Keyboard
<water> grr
<hcf> water: was ur discussion of <> on usenet only in the thread of; grup: alt.language.artificial, subj: High Order Language ?
<water> i wish he'd let me know when he stops paying attention
<water> hcf: yes
07:30pm
<water> i got 2 replies, though
<water> (private ones)
07:40pm
<ult_> g'nite
-:- SignOff ult_: #TUNES (Leaving)
-:- rares [rares@wtrb-sh5-port8.snet.net] has joined #tunes
<rares> hey
<water> hey
<eihrul> water: sorry... i'm trying to get this science project done (due tomorrow morning)
<water> eihrul: well let me know when you're busy ok
<water> it's called netiquette :)
* rares/#tunes gives eihrul some crack
<eihrul> okay, i sometimes forget though...
<water> just write "afk"
* eihrul/#tunes apologizes profusely.
<eihrul> afk
<water> no sweat, just try to let me know when you're too busy
<water> k
* water/#tunes ponders the syntax/semantics relationships of objects as state-accessors
<eihrul> water: yes, the cloned activation record is what is actually the frame on the stack
07:50pm
<AlonzoTG> om 
* AlonzoTG/#tunes contemplates founding a monestary.
<water> hm and the 'result' of each record contains the code as its slots
<water> it seems we've placed the actual code one layer away from the actual context at all times
<eihrul> 'one layer away'?
<water> yeah you have to ../ to get the record's state
<water> from within the code
* eihrul/#tunes ponders the need for a lisp version of libgraph.
<rares> yup we don't Optical Ram Char Recognition
<eihrul> hmmm
<rares> Or OROR Optical RAM Object Recognition
<water> ordinary oo does the same thing
<eihrul> technically...
<water> it just has different syntax
<eihrul> ./ could be the records state
<water> it implicitly selects ../ within methods
<eihrul> where it just inherits the scope of receiver object itself
<water> and ./ within objects
<eihrul> so any selectors not defined on the activation route to self :)
<water> hm?
<eihrul> though that's somewhat trickier...
<water> hold on you lost me
<water> how could ./ be the record's state?
<water> we're not in the record, but the code itself, right?
<water> or maybe i'm confused
<eihrul> well, i thought {../}*{./}* just accesses activation records?
<eihrul> as we had established earlier?
<water> which one?
<water> ../ or ./?
<abi> zero
<water> gr
<water> btw, i don't think we need to have explicit access to previous activation records, because they're linked by delegation
08:00pm
<eihrul> water: yes...
<eihrul> though
<rares> umm try to come up with something clearer than perl as a syntax pls :)
<water> rares: heh we're trying
<eihrul> water: i don't know if dynamically scoped methods are really desireable for a default :)
<water> hm
<eihrul> as dynamic scoping doesn't serve much use wrt methods
<water> ok i can see that
<water> so inheritance among activation records will serve the usual purpose, i guess
<eihrul> which is perhaps a different between blocks and activation records :)
<eihrul> s/different/difference
<water> instead of scoping
<water> er
<water> i don't distinguish blocks from records
<water> i don't want to
<eihrul> well... they behave differently...
<water> exactly i want the same behavior
<water> less complexity
<eihrul> i think it creates more complexity
<water> maybe we're talking about two different things
<eihrul> because methods usually do not access the calling method's activation
<eihrul> though...
<eihrul> actually
<eihrul> the semantics of methods and blocks even in this respect
<eihrul> can be somewhat unified
<water> i don't care about *usually*
<eihrul> by noting that blocks and methods access the scope in which they're *defined*
<water> usually happens to be usually due to heterogeneous language ideas
<eihrul> (for sake of argument, but not implementation, we'll pretend methods are defined in an object)
<eihrul> blocks (as closures) are defined within other closures
<water> i don't care where they're defined, though
<eihrul> and so can access state in the defining closure, even outside of it
<eihrul> and a method is *conceptually* defined within an object
<water> i want blocks to be independent
<eihrul> and so can access state in the defining object
<water> otherwise we'll have lameness
<water> are you listening??
<eihrul> you already have it... :)
<rares> a suggestion:
<eihrul> IT IS NOT INTUITIVE THAT METHODS CANNOT ACCESS THE CALLING METHOD! :)
<eihrul> nor is it desirable
<water> i didn't say they couldn't
<eihrul> er
<water> jerk
<eihrul> s/CANNOT/CAN
<eihrul> :)
<water> oh
<eihrul> brain fart
<water> geez
<water> BIG brain fart dude
<AlonzoTG> om
<AlonzoTG> =\
<AlonzoTG> ToPiQuE?
<water> but methods always access the calling method via arguments
<rares> have a way to change the point of view of the hierarchy
<water> rares: yes?
<rares> object.member
<water> arguments *are* the way for this to happen in usual programming languages
<rares> member.object
<water> rares: YUCK!
<water> rares: doubly so
<eihrul> water: but, i don't see any practical benefits to it...
<eihrul> i see a method as delegating to the receiving object
<eihrul> not as delegating to the calling method
<water> eihrul: i'm saying it's done all the time though
08:10pm
<water> no not delegation
<water> geez you really weren't listening
<hcf> namespace:object/member ? ;)
<eihrul> shrug
<eihrul> i believe i was listening
<water> argggggg
* AlonzoTG/#tunes contemplates the amazingness of my 16 hour uptime...
<water> atg: shut up!
<rares> oh brother
<eihrul> i'll review the logs
<water> god i'm trying to explain something and all i get back is crap
<AlonzoTG> you don't own windows 3.11, 16 hours is a big deal for me!
<AlonzoTG> =P
<water> atg: thx for more crap
-:- SignOff hcf: #TUNES (Leaving)
-:- hcf [nef@me-portland-us1041.javanet.com] has joined #tunes
* rares/#tunes listens :)
<AlonzoTG> yeah yeah, You and your ivory tower....
* water/#tunes sighes
<water> time for a vacation
<AlonzoTG> I gotta get my grins where I can....
<eihrul> water: you talk about "inheritance of activation records"
<eihrul> but...
<water> yeah atg right while i'm working at my second job
<eihrul> while activation records are linked in a stack like fashion
<AlonzoTG> =\ Okay......
<eihrul> they do not use this for "delegation" purposes as you say in the log
<water> i know i realized that the dynamicness of delegation would be a problem
<water> no wait!!!!
<water> duh!!!
<water> big duh
<water> 'parent' happens to be a slot like any other
<water> you can have static scoping by making activation records clones of an object whose 'parent' stays immutable once set
<eihrul> yes, but what is the parent?
<water> er... just have an immutable parent slot
<water> the enclosing record
<eihrul> i think that's confusing
<water> why?
<water> it works the same as in oberon or modula
<AlonzoTG> I never bothered with all that terminology in designing my OS... I just said 'I want something that does this' And didn't bother giving it a name as names don't relate directly to their capabilities...
<AlonzoTG> now I just have a design but no imp. =(
<eihrul> well, it just causes one to think of a call tree instead of a call stack...
<water> well shift your thinking
<eihrul> guess its an apples to oranges things
<AlonzoTG> okay if you design anything, write a manual and mail it to me....
<eihrul> s/things/thing
-:- AlonzoTG [Alonzo@216-164-128-206.s206.tnt1.lnhva.md.dialup.rcn.com] has left #tunes []
<water> (thank god)
08:20pm
* water/#tunes sighs
<eihrul> water: problem?
<water> just stressed out
<water> s/just//
<water> i just can't figure out how to make the stack work right
<water> and the syntax for accessors seems baffling
<water> (myObject (setVar1 : ../foo))
<water> what : does seems vague and incoherent
-:- SignOff eihrul: #TUNES (Ping timeout for eihrul[usr5-ppp150.lvdi.net])
<water> :P
<rares> nacho day eh?
<water> not my decade
<water> heh make that two
<water> i really need help
<water> this schedule's killing me
<rares> at which stage is tunes?  does it know the meaning of no :)
<water> no my personal schedule
<water> navy + commute + slate + arrow + <> + tunes
<water> and oh yeah it'd be nice to fit a personal life somewhere between all that
<hcf> water: what <>, tunes stuff r u doing atm?
<water> grrrrr
08:30pm
<water> info access'll cost you
<hcf> k, n/m
<water> because it costs me
* water/#tunes feels like his own web server
<lar1> heh
<rares> not to sound like I'm peddling rosewater elixirs but if I could just get some cash I'd be able open up the coder recruiting market at like age 15+
<water> lar: info sucker that you are would know
<lar1> water:  I gotta suck info from somwhere, right? ;)
<water> rares: i have $22k cash in one account alone
<water> lar: i'd prefer you go elsewhere or at least keep your trap shut
<lar1> water:  About what?
* rares/#tunes hides
<water> maybe i should hire someone part-time
<rares> might work
<water> i'd have to meet them every day irl
<lar1> water:  Hire me! ;)
* rares/#tunes hides
<rares> :)
<water> lar: shut the flying fsck up
<lar1> Sorry
<hcf> lar1: stop poking the dragon
<water> heh
<water> i'd like to think that there's something i could do tonight to help myself, but i seem to have run out of options
<water> hell, i'm mostly driven by lonliness lately
<water> er loneliness
08:40pm
<water> well, it's certainly quiet now :)
<water> maybe all accessors should use the same protocol
<rares> accessors?
<water> so that : automatically seeks one slot
<rares> (just in case it doesn't mean what I think it means)
<water> messages that set/get object state
<rares> gotcha
<rares> i don't see why not
<water> yeah well how much do you grok self or slate?
<water> if you don't grok self, don't opine
<rares> I know self pretty well
<rares> (I generally don't memorize it irks me but I understand models I was born with models in my head :))
<water> so why no problems with all accessor objects having the same protocol?
<rares> because an accessor needs only a few details: the object, the slot, the state, and permission (if any)
<water> permission .is meta
<water> the object .is implicit to the execution semantics: it's the namespace returned to
<water> hcf: can you turn off the option for abi to pick up indirect comments?
-:- eihrul [lee@usr5-ppp72.lvdi.net] has joined #tunes
<water> wb
<eihrul> re
<hcf> water: give an example
<water> shingles are things that cover roofs
<water> abi shingles?
<abi> shingles are things that cover roofs
<water> abi forget shingles
<abi> water: I forgot shingles
<water> it would save me a lot of /msg-passing to abi to have her not pick up anything just casually mentioned
<water> and because she hangs out on #osdev, she picks up a LOT of crap
<hcf> it would save the same if u used #modtunes
08:50pm
<water> sigh
<hcf> abi: part #tunes
<abi> goodbye, hcf.
-:- abi [nef@bespin.dhs.org] has left #tunes []
<rares> so if I say bounce, state=high the object is automatically a ball
<rares> ?
<water> huh?
<rares> <water> the object .is implicit to the execution semantics: it's the namespace returned to
<water> that's not what that means
<water> the execution semantics means *after* the message has been looked up
<water> if the look-up is unsuccessful, no execution
<water> hence, no coersion
<water> however, you could give an object a special bmo that could allow coersion by trying to dynamically adapt the object's protocol, perhaps given some framework like category theory
<water> (which is how you could do fp within slate)
<water> :P i'm too depressed now
<rares> breathe man breathe
<water> hell, i've cried four times this past hour
<water> just imagining what my life's gonna be like if i don't get out of this rut
<lar1> You will get out though
<water> wow. words of encouragement from a 14-yr-old
<rares> water actually that's quite common these days
09:00pm
<water> what life in a rut?
<rares> both rut + 14-year old encouragement
<water> hell yeah it's common, but i don't deserve to have to struggle with it
<rares> you know why it's common?
<water> no, but you're going to tell me ;)
<lar1> heh
<rares> we're at a point where those who know what the next 5 years hinge on are getting ready to kick some serious arse
<water> what the hell does that mean?
<rares> there's a huge gaping hole in the markets and someone is going to fill it
<water> um
<water> speak english, please
<rares> heheh
<water> we're not quite as intune with the spirit realm as you are, i guess, otherwise we'd understand
<rares> major companbies don't want to deal w/ customers, the future, nor markets they're getting weary they are scrambling to just find astable revenue stream
<water> wait a sec
* water/#tunes tries to figure out why he gives a rat's a** about this
<water> no, i don't
<water> eihrul: where were we?
<rares> it worked :)
<water> it doesn't matter if i don't get any good conversation here
<water> and eihrul's about as polite as a bot
<water> hm
<water> well, annoying me seemed to result in a dead channel once again
<rares> <water> you can have static scoping by making activation records clones of an object whose 'parent' stays immutable once set
<rares> that's about where you were
<water> gee thanks
09:10pm
<water> unless you have questions, that's useless
<rares> i guess i'm chronically trying to fix my compass :)
<hcf> water: how u rate the usefulness of the initial posts u did?
<water> hcf: which posts?
<hcf> beta, self, lisp, etc
<water> er well they were helpful in getting the people who are now on the slate mlist aware in the first place, but that's about it
<hcf> has anyone on the list been non-passive besides eihrul?
<water> no
<hcf> i know the list has been dead, i mean personal email, etc
<water> again no
<hcf> so bringing in new ppl seems useless
<hcf> how about reusing existing ppl, like witten?
<water> i don't even remember how much he knows
<hcf> wasnt he the one working on something sim. to slate?
<water> god i must know 150 people through tunes at least
<water> hell if i recall
<hcf> called something like tensor
<water> oh god no
<water> not that
<water> now i recall
<water> no, his ideas were lame
<hcf> found it, torsion
<hcf> ok
<water> that guy i met at work who knew lisp turned out to be a lame programmer as well
<water> and a bit mentally-unstable
09:20pm
<hcf> heh
<hcf> like u ;)
<water> no, much worse
<lar1> Heh
<water> as in physically dangerous to be around
* rares/#tunes hands water a bouncy ball
<water> whatever
<hcf> what about fufie?
<water> he's too busy even for tunes
<water> as is tril or beholder
<hcf> fare? ;)
<water> yeah like he'd actually help
<water> we'd be stuck in the formalization process for decades
<hcf> need any more papers? ;)
<water> depends on the subject matter
<hcf> i dont have any urls atm
<water> good
<hcf> i'l find some if u wish
<water> now is anyone going to help me with the slate spec or what?
<rares> what's missing?
<water> geez
<water> if i knew how to describe it, it probably wouldn't be missing
<water> mostly the virtual machine stack
09:30pm
<water> i can't figure out how the damned thing should work
<rares> hmm... gimme a minute
* water/#tunes watches a minute of his time disappear into eternity
<water> slate as sure as hell better not need any work from me after the year's out
<water> otherwise i'll drop it like a rock for arrow
<water> arrow needs to get done.... slate can go screw itself if people don't get interested
<water> hell i thought slate would get attention since anyone who groks tunes would see slate as an obvious way to go
<water> but of course tunesers are useless slobs, as they've proven many times
<rares> okay here goes:
<water> (heh i just realized that slate's ":" = "in in in in ....")
<rares> does it? I thought you had anti-infinty loop protections in the design
<water> for other cases, yes
<water> not so for assignment without :
<water> otherwise you have to set the input of the function which sets the input to your accessor
<water> which naturally recurses
09:40pm
<water> you grok?
<water> and where's that question of yours?
<rares> not questions yet more an outlining process
<water> so?
<water> DIALOG
<water> :)
* eihrul/#tunes un-afks.
<water> good, trialog works too :)
<water> heh of course i could spell my constructed words correctly, but oh well
<rares> oo at work :)
<water> eihrul: so what are the arguments for/against having activation records delegate to surrounding records?
<water> besides arguments of "it's non-intuitive"
<eihrul> i really don't see a reason for it :)
<water> duh
<rares> a cascading message miss delegation?
<water> without it you don't get block-scoping
* eihrul/#tunes sighs.
<eihrul> i think munging two ideas with disimilar behavior in this case is the wrong way to go about things...
<water> i'm not munging
<water> they belong together
<eihrul> and i don't even think you're correctly modelling block behavior...
<rares> you mean like start the car could be expressed as start the ignition or start the car
<water> who cares?
<eihrul> or atleast not as closures
<water> i break two models
<water> and make a single better one
<rares> i can see the point of being able to tunnel like that
<eihrul> and replace them with one that's less clear
<eihrul> and less useful
<water> well explain what else inheritance among records is good for
* eihrul/#tunes shrugs.
<eihrul> it's your proposal
<eihrul> you explain
<water> exactly
<eihrul> *you're convincing me*
<water> just great
<eihrul> not the contrary :)
<water> that's exactly what i need is to have people ask more info of me
* eihrul/#tunes wonders where this strange notion of making others prove one's own ideas arose from.
<eihrul> especially when they don't happen to support them :)
<water> i've already filled 80% of today's logs
<eihrul> wrt closures
<water> well otherwise we use the namespace system or something else to provide the functionality
<water> hey wait a sec!!!!
<rares> i definitely think the function tunneling support is useful
09:50pm
<water> eihrul you clod!
<water> you forget that i already spelled out my intention to unify self with beta
<water> and you don't grok beta, which explains your confusion entirely
<eihrul> no
<water> go read beta
<eihrul> i have no confusion
<eihrul> all i have is disgust at this particular moment
<eihrul> i think the confusion lies on the other end
<water> well explain how beta does it
<water> beta doesn't need blocks, btw
<water> smalltalk and self DO need blocks
<eihrul> well, i think the two can be unified
<eihrul> but in a different manner
<water> having blocks separate from closures is a problem
<water> how?
<eihrul> a closure accessing external state to me is no different than a method accessing a 'self'
<water> uh
<eihrul> they're both largely the same
<water> no they're trivially the same
<eihrul> except that the particular delegatee may is modified (self)
<eihrul> whereas in one its constant
<eihrul> -may
<water> that conflicts with mutability
<eihrul> 'modified' not necessarily meaning assignment in this case
<water> then use another word
<eihrul> suggest one, then
<water> lol
<water> i don't even distinguish what you're saying from assignment
<water> how can i know what's in your noggen?
<eihrul> just the notion that 'self' is somehow bound to the appropriate receiver
<eihrul> however that's expressed is irrelevent to me
<water> vague
<eihrul> atleast for the purpose of this particular concept
<eihrul> shrug
<water> that's all i need right now are vague concepts
<water> just say the receiver of the message
<water> that's what you want self to be, right?
<eihrul> yes, it's bound to 'self'
<water> virtual binding
<eihrul> whatever
<eihrul> as i said
10:00pm
<eihrul> i could care less how its bound in this case :P
<water> so get to the point
<eihrul> <eihrul> a closure accessing external state to me is no different than a method accessing a 'self'
<eihrul> <eihrul> except that the particular delegatee may is modified (self)
<eihrul> <eihrul> whereas in one its constant
<eihrul> the closure delegates to some other enclosing namespace
<eihrul> just as the method does (to self)
<water> <water> that conflicts with mutability
<water> :)
<water> what you're saying is still baloney
<eihrul> not really
<eihrul> how you're interpreting it is
<water> how i interpret it is what the statement is
<water> otherwise you're just talking to yourself
<eihrul> i might as well be
<water> heh
<water> well you're not making it clear what the difference is
<water> explain why what you're talking about is NOT about mutability
<water> that help?
<eihrul> perhaps a better analogy is to look at it through inheritance of scope...
<water> lol
<eihrul> a closure may inherit the scope of another closure OR
<eihrul> it may inherit the scope of a method
<eihrul> a method inherits the scope of the receiving object
<water> uh
<eihrul> the object inherits the scope of the 'namespace'
<water> slow down
<eihrul> the method DOES NOT inherit the scope of the calling method...
<water> explain each statement dude
<water> structurally
<rares> you have two things setting a variable /me listens
<rares> scratch that
<eihrul> that is the structure, defined by single relation of 'parent'
<water> sigh
<water> gggrrrrrrrrrrrrrrrrr
<water> no, make the structure ridiculously explicit
<rares> let me see if I can't explain it
<eihrul> i can find no other way to explain it than as a lineage of namespaces
<rares> okay I'm a robot and my methods are my arms and legs
<eihrul> as *commonly* found in most languages
<eihrul> where you have some namespace encompassing representing the global world
<water> you're not explaining, because your previous statements i cannot parse disambiguously
<rares> I can tell another robot to move his arm up or down 
<water> and you wrote them in quick sequence so i couldn't address them individually
<water> so you suck at explaining
<rares> that's an object taking the scope of another object
<eihrul> look, this is merely a hierarchy of namespaces found in every damned language known to man!
<water> wow i can't sort these threads out at all
<rares> I can just grab his arm and move it up and down
<eihrul> i do not see why the concept is so particularly challenging
<rares> hello
<water> eihrul: you're obfuscating
<water> that's why
<eihrul> it's just now represented as objects that use delegation to inherit their scopes
<rares> guys shhhh I'm explaining
<water> eihul: wow!!!! that sounds familiar
<eihrul> but, in a way that more closely models how other languages use scopes! :P
10:10pm
<eihrul> in a way that actually happens to be *useful*
<water> yeah, but it means you can't delegate to anything else
<eihrul> why so?
<water> we're talking past each other
<water> only one parent slot
* eihrul/#tunes nods.
<water> oh did you forget that?
<eihrul> not at all
<water> well you're not explaining your argument at all
<water> you gave me 5 sentences in a row without letting me ask questions
<water> very non-friendly
-:- rares [rares@wtrb-sh5-port8.snet.net] has left #tunes [Segmentation]
<eihrul> closures inherit scope from other closures... *or* (continued)
<eihrul> questions?
<water> yes i had questions you asshole
<water> i don't even care now
<water> btw, we are using different terms here
-:- rares [rares@wtrb-sh5-port8.snet.net] has joined #tunes
<eihrul> you said you had questions, so ask them... i'm willing to answer, if you're willing to ask
<water> you use closures for what i was calling activation records, which was a term YOU brought into the discussion
<water> so clarify the difference between a closure and an activation record first
<water> precisely
<eihrul> ok... to clarify
-:- witten [witten@un.torsion.org] has joined #tunes
<eihrul> thinking of a system in terms of objects
<eihrul> (rather than in terms of methods)
<water> and?
<eihrul> an object sends a message to another object, which interprets the message and responds
<eihrul> nowhere in this transaction
<eihrul> do i see an 'intuitive' nesting of exactly how that message is interpreted and responded to
<water> wtf does this have to do with closures vs activation records?
<water> you're just about useless
<eihrul> it has to do with the notion that there is not one giant stack of activation records
<eihrul> ok, you know what?
<eihrul> fine
<eihrul> how about i just quit?
<water> hold on
<water> doesn't the smalltalk vm have a stack?
<water> a *single* stack?
<eihrul> i am really trying here, but i'm only being met with insult after insult...
<eihrul> this is not entertaining in the least
<water> well, you're not being direct
<eihrul> yes, but i do not warrant insult!
<water> answer the question!!!
* rares/#tunes pulls the universe out of his ass
<water> doesn't smalltalk have a stack?
<eihrul> a stack of frames
<eihrul> the stack merely serves as an efficient way to allocate frames
<water> yes which gets modified by method execution
10:20pm
<eihrul> and model computation on a sequential computer
<eihrul> i see a frame as an individual stack used for the computation in a particular method
<water> i don't
<water> so there :P
<eihrul> well, i dare say that's more functional than object-orientated :)
<water> you think so? :)
<eihrul> yes
<water> well i'm not surprised
<water> because i wanted it that way
<water> :P
<eihrul> why contradict yourself?
<water> i'm not :)
<eihrul> what happened to pure object-orientation?
<water> it's not contradictory
<water> explain why i need a stack of frames
<eihrul> as i said before
<rares> a method is like a virus it needs and object to live
<eihrul> the stack need not be considered to exist
<eihrul> it merely serves to allocate frames in my mind
<water> what does that mean?
<water> explain it to me, i don't understand
<rares> me?
<water> no rares shush
<eihrul> hold, trying to find an adequate way to explain this
<water> i thought you'd find it hard
<water> but continue please
<eihrul> ok
<eihrul> it is more intuitive (for me) to think of objects acting in parallel...
<eihrul> each one has its own stack (or frame) to maintain the state of its behavior
<eihrul> sending a message opens an interactive stream between two objects
<eihrul> through which inputs are sent
<eihrul> and then outputs are finally sent
<eihrul> so that a particular object that has been sent a message to
<eihrul> is not enclosed by the object that sent the message
<witten> why must it be a stream?
<rares> what would you call it/
<eihrul> the previous object is enclosed within the particular world/namespace
<water> others: shush
<eihrul> so that its particular behavior (and its state) exists in isolation
<eihrul> from the state of the object sending the message
<water> i think you haven't explained anything to anyone
<water> the comments from rares and witten make this clear
<witten> bah
<eihrul> sigh, i give up
<water> try again, please
<witten> eihrul: i know what you're saying, if it matters
<water> well, you need to explain the difference between the models
<water> explain why one stack doesn't work
<eihrul> your model assumes that the particular behavior *do not* exist in isolation of eachother
10:30pm
<water> behavior=?
<rares> i think i get it
<eihrul> and that a particular message'd object may access the state of behavior of the object interacting with it
<water> i don't
<eihrul> whereas the only relation between the object should be the stream itself... inputs and outputs
<eihrul> there is no delegation here allowing the message'd object to know the internal state of the sending object
<rares> okay I'm going to try again:
<water> can someone please explain this?
<water> ok rares
<eihrul> it merely knows how the other object has interacted with it...
<water> eihrul: shuch
<water> shush
<rares> I'm a robot (the object) my arm is the method
<rares> there is another robot
<rares> I can tell the robot to move its arm up and down (obj scope to obj scope)
<eihrul> **in summary**, following this model, the enclosure for a particular objects state of behavior (method) is not another objects state of behavior, but the object itself
<rares> I can mopve his arm myself (obj scope to method scope)
<eihrul> and hence the enclosure being what is delegated to...
<water> eihrul: i said shush
* eihrul/#tunes sighs.
<rares> but my arm cannot move the orobot on its own
<rares> that's not a good thing
<witten> eihrul: that doesn't make it clear
<eihrul> witten: does it make sense to you that a called method can access any of the variables of the calling method?
<eihrul> witten: or that instead it accesses the particular variables of the object the method resides in?
<water> rares: well, i get oo principles, but what does this mean about implementation
<witten> eihrul: i can comprehend that concept, yes
<eihrul> well, water is suggesting the previous, i'm suggesting the latter
<witten> eihrul: i think i'd have to agree with you, then
<rares> water I'll get you a report later on that I gotta go it's late
<water> i still haven't seen a proof that one stack per thread is not enough
<eihrul> as i explained, this stack is merely a way to allocate frames...
<water> maybe you're thinking about multi-threading of objects
<eihrul> it is merely an implementation concept
<water> wtf is a frame dude?
<water> frame=frog afaik
<eihrul> the activation record and other closures inheriting its scope
-:- SignOff rares: #TUNES (KVirc 1.0.0 Millennium BETA 3)
<water> and what are those?
<witten> what's an activation record?
<water> YES
<water> explicate
<water> be really fscking precise
<witten> not just precise, but try to avoid terminology
<witten> because if we're all talking in different terms it makes things dificult
<water> right no jargon
<eihrul> an activation record is the state of a method (the particular values/variables it uses and the other values needed to return to the calling method, etc)
<witten> okay
<water> eihrul: how would i make an object that models an activation record
<water> ?
<witten> so a frame is a method's state?
<witten> or state variables?
<eihrul> yep
<water> answer my god damned question
<witten> okay. so now water seems to think you need a single stack of these frames. what's your take on that, eihrul?
<water> um no
<eihrul> no...
<eihrul> water thinks you need a single stack, period
<witten> okay, nevermind then
-:- SignOff smkl: #TUNES (Ping timeout for smkl[glubimox.yok.utu.fi])
<witten> okay
<water> no one stack per thread
<water> get a clue
10:40pm
<witten> get a stick out of your ass
<water> well i stated that we were talking about one thread before you got here
<eihrul> yes, but what is the granularity of a single thread
<eihrul> that is equally vague
<eihrul> does a thread correspond to a single object?
<water> threads aren't implementational to me
<water> yes
<eihrul> or a whole system of communicating objects?
<water> same thing
<water> a.k.a. namespace
<witten> namespace == thread == object?
<water> no
<water> but they correspond
<witten> well, okay
<witten> one-to-one correspondence
<eihrul> perhaps another explanation that will draw ridicule, the scope enclosing a method (and thus its 'parent') is the object which does that method, and there is no direct relation between methods (where one call the other), save a continuation that defines
<eihrul> how to return to the calling method
<eihrul> and that a 'parent' relationship between the two methods is useless
<water> the problem i see is that in slate, methods are objects
<eihrul> and
<eihrul> what is the problem?
<water> so you have to make a stack for stacks for stacks
<water> etc
<eihrul> not really, no
<water> since every method needs its own state, sends and receives messages
<water> so methods don't have state? :)
<eihrul> they do, but the particular implementation doesn't regress like that :)
<water> are you saying i can't synchronize my messages?
<eihrul> eh?
<water> i mean synchronize stuff between two concurrent messages?
<water> eihrul: the implementation should regress like that
<eihrul> ok, then let it...
<water> no, that's if your model is used
<witten> the rubber has to hit the road at some point
<eihrul> i don't see the problem
<eihrul> lisp, c, smalltalk, etc, use the particular model :)
<water> well eihrul hasn't proven to me that he understands what i want for slate
<water> until he does i have to assume he's using usual oo crap
<eihrul> i only understand what you want so far as you've told me what you want
<water> i know, but even so i can't guarantee we're on the same page
<witten> what's wrong particularly with the usual oo crap's approach to all this?
<water> because usual oo can't deal at all with messages being real first-class objects
10:50pm
<witten> why not?
<water> because usual oo can't deal with methods except as parts of other objects
<eihrul> uh, why not?
<water> and you therefore can't send messages to messages
<eihrul> answer first question
<water> ok
<eihrul> before basing further assumptions upon it
<witten> you can send a function pointer to a function
<water> no not functions
<water> not like that
* eihrul/#tunes points to the question.
<witten> oh, full messages, arguments and all?
<water> i'm saying that an object defines its protocol, but it's protocol can't be re-used except by name
<witten> protocol meaning.. interface?
<water> yes
<water> it's slots
<water> s/it's/its/
<eihrul> whereas your vision contrasts this and betters this by how, exactly?
<witten> so what does an object's interface's reuse have to do with messages getting passed to messages?
<water> eihrul: i thought so
<eihrul> answer the question
<eihrul> i've answered quite a lot
<water> witten: know the syntax in <insert favorite oo lang here> for getting methods via selectors?
<eihrul> many times over
<eihrul> it's your turn, man
<witten> water: what's a selector?
<water> eihrul: no, you spat out a lot of garbage without waiting for response
<water> witten: the name of a slot
<water> eihrul: just a sec
* water/#tunes ponders how to answer this best
<witten> water: are you talking about getting methods via selectors at compiletime or runtime?
<water> witten: why should there be a difference?
<witten> water: in most OO languages, there is
<water> witten: exactly
<witten> so you want to be able to do that at "runtime" too, i presume
<witten> is that your point?
<water> not quite
<witten> what is your point?
<water> hold on, i'm trying to write up an answer to eihrul
<water> eih: i'm looking for two different kinds of extensions
11:00pm
<water> one involves algebraic or top-down style of protocol spec
<water> which could be done by re-write but there mgith be lots of other ways
<water> the other way is to modify the "lookup" of the bmo
<water> so that it doesn't just go through a mechanical search of slots
<water> instead it derives the protocol from a set of rules
<water> and i'm also trying to figure out how to keep slot-objects as separate from their "containers" as possible
<witten> separate how?
<water> independent
<witten> meaning what?
<water> you destroy the container but the part isn't gc'd if it's used somewhere else
<witten> oh, that's easy
<water> and where it can be used in other ways thatn as a value
<water> no listen
<witten> what else would you want to use it for?
<water> LOL
<water> anything
<water> particularly as a method
<witten> like?
<witten> oh
<witten> i wasn't sure of what you meant by value
<water> i think eihrul's done his afk thing again
<eihrul> no
<water> oh sorry, i guess i'm used to it :P
<eihrul> now...
<eihrul> wheere does the 'better' part come in...
* water/#tunes sighs
<witten> yeah, what's it in for me?
<witten> er, in it
<eihrul> that was the question...
<eihrul> we were discussing the particular limitations of OO
<eihrul> which you had hinted at
<water> yes
<eihrul> and the particular question was how all this was actually solved these particular limitations...
<water> i'm saying you could overlay e.g. category theory to share methods as functions
<witten> what's the difference?
<water> using bmo's lookup protocol
<water> man what a wasted night
<water> i didn't want to argue at all
11:10pm
<water> i see now that i should never have let eihrul introduce activation records into discussions of stacks last week
<water> among other things
<water> now tomorrow i get to go back to my fscking job and waste another day of my life
<water> while you jerks go off and ignore my ideas
<water> and tunes becomes ever more untobtainable
<lar1> Life is too short to whine like that, water
<eihrul> water: question... do you want my help or not?
<water> not if we're going to argue about jargon
<water> it's the same thing every other tuneser does
<eihrul> it's not jargon, it's the behavior behind the jargon
<water> lol
<water> no, we got terms mismatched
<water> it's so bad right now i don't feel up to fixing it
<eihrul> saying a method delegates to its calling method is different from saying it delegates to the object enacting the method...
<eihrul> it's not a matter of jargon
<water> why would a method do either?
<eihrul> because a method accesses the state of it's self
<witten> you must define delegates to make it clear what you mean.. 
<witten> okay, that makes sense
<witten> but you gotta be really careful
<water> i don't understand i thought delegation was for inheritance
<witten> delegation can be a general term that means "if i don't have a particular member, then look for it elsewhere"
<water> i.e. clone-and-modify
<hcf> water: would a slate glossary be as unused and useless as the tunes glos?
<water> hcf: YES
<water> i'm talking about self-like delegation only
11:20pm
<water> copy-and-modify
<water> any other kind of delegation seems rather non-intuitive
<witten> eihrul: i think a better term to talk about what you're calling delegation would be member resolution or something
<eihrul> then you're saying a method calls another method
<eihrul> by cloning itself
<eihrul> and modifying the clone such that it resembles the other method...
<water> yuck
-:- SignOff lar1: #TUNES (Leaving)
<water> seriously that's terrible
<eihrul> well, umm, isn't that *your* suggestion?
<water> no
<eihrul> well, 'parent' is a slot implicitly used for inheritance
<water> that wasn't about *calling* methods
<water> that was about containership
<eihrul> you had earlier stated that a method is related to a method it uses upon another object
<eihrul> by a 'parent' relationship
<water> huh?
<water> you substituted some important term there
<witten> ARGH
<witten> you two are just talking at each other
<witten> i understand completely what both of you are getting at
<witten> you need a translator or something :P
<water> thank god someone does
<witten> eihrulspeak <-> waterspeak
<water> like i said, it's a matter of terms
<witten> i can see why you people don't get anywhere if all the discussion is like this :P
<water> well eih and i agreed well until very recently
<witten> did you even know what you were agreeing to? :)
<water> until the problem with syntaax, yes
<water> when we discovered the problems with syntax, the argument turned south
<eihrul> let's clarify shall we? given that an activation record was a clone of a method residing on the stack, what exactly is its 'parent'?
<water> whose parent?
<eihrul> the activation record
11:30pm
<eihrul> aka the clone of the method
<water> the method
<water> because that's what it was cloned from
<eihrul> and there begins the seed of my misunderstanding
<water> oh
<eihrul> now, re: unifying blocks and methods
* water/#tunes remains in conversation-debuggin state
<eihrul> if the parent scope of a block is held by the 'parent' field...
<water> not exactly
<water> the parent field just points to the parent, it doesn't actually get you the scope
<eihrul> then how do you maintain the relation between parent scope and child scope?
<water> oh well implementationally you have to follow that parent reference
<eihrul> so this particular 'parent' slot exists independently of the implicit 'parent' slot that implements cloning/inheritance, eh?
<water> no its the same
<water> implicit=inherited from root
<water> (and whose meta-behavior is immutable)
<eihrul> now exactly how do the respective handlings of methods and blocks tie together? :)
<water> where do block fit into this?
<eihrul> well, you've consolidated them into a single idea
<water> blocks are just objects have a meaningful result slot
<eihrul> that supposedly supports both methodiness and blockiness
<witten> eihrul: what's the difference, except that one is named/declared/reused?
<water> s/have/that have/
<water> both should be able to be anonymous too
11:40pm
<witten> okay
<witten> it just seems almost trivial to unify them
<eihrul> so where does 'self' fit in?
<water> well the method's 'self' accesses the method
<water> to get the object, you just dial '../' and the 'self' or just call your local operator :)
<water> because the method itself is a namespace that must be exited to get the receiver object
<witten> receiver object?
<eihrul> now, what does the relationship '../' mean exactly and how is it created?
<water> yeah the receiver of the message
<water> dunno, for now its just syntax
<witten> by exited, do you mean that the receiver object is a "parent" of the method?
<eihrul> yes, but for what?
<water> witten: no
<eihrul> why does ../ lead you to the receiver of the message?
<water> eihrul: because i said so
<water> :)
<water> yes, this is me making it work
<witten> why explicitly go to the receiver with "../" when you can just recurse up the inheritance hierarchy by searching "parent"?
<witten> (the first parent should BE the receiver)
<water> witten: because it might not be so
<witten> example?
<water> hm
<water> actually i don't need one
<water> every time you want 'self', you'll still have to bypass the method 'self'
<witten> eh?
<water> and accessing 'parent' of the *method* isn't the same thing
<water> witten: 'self' is accessed from method code, right?
<witten> right
<water> but every object is a namespace so even methods have 'self'
<witten> if you want them to
<water> well it doesn't allow for method-object independence otherwise
<witten> okay
<water> because ordinarily 'self' implies strict containerism
<witten> right
11:50pm
<water> so namespaces + namespace syntactic operators allow me to bypass the 'problems' due to my object model
<witten> by introducing "../"?
<water> sure
<water> maybe i could use 'receiver' instead
<witten> it just doesn't seem right
<water> you have a better idea?
<witten> not yet
<water> heh
<water> neither does eihrul
<eihrul> you sure?
<water> yes i don't like your 'solutions'
<witten> well
<water> they are unacceptible to me, and i'm the one who came up with this language
<witten> if "parent" is the enclosing namespace, then isn't the value in the parent slot the same as your "receiver"?
<witten> water: the attitude really isn't necessary
<water> dunno
<water> i've had a very long day
<witten> i mean, it's one thing to do member resolution (recursively search through the parent tree looking for a member), and it's another thing to just USE whatever object is in the parent slot
<water> yeah but namespace access is different
<witten> how so?
<water> it's not just a matter of "give me that object"
<witten> why?
<water> because you can't go past the one container level
<witten> what do you mean by that?
<water> hm maybe i should keep the directory syntax
<water> so you can access things like modules
<water> remotely
<eihrul> what is wrong with a given slot being the 'receiver'?
<water> (within the limits of meta-protocol)
<witten> eihrul: nothing, it just seems redundant
<water> it's not enough
<eihrul> how so?
<water> and besides the 'receiver' slot wouldn't work anywa
<witten> eihrul: the parent IS the receiver already. why not just use that?
-:- SignOff air: #TUNES (http://www.qzx.com/ :: sleep)
<water> anyway
<eihrul> witten: it isn't...
<witten> eihrul: why not?
<eihrul> the parent of a given clone of the method is the method
<eihrul> the parent of the method itself is probably root
<witten> oh, that's where your language differs, then
<water> yeah methods can inherit and such
[msg(TUNES)] newlog 2000.0216
IRC log ended Wed Feb 16 00:00:01 2000