08:11:55 --- log: started forth/06.10.01
08:11:55 --- join: clog (n=nef@bespin.org) joined #forth
08:11:56 --- topic: 'Welcome to #forth. We discuss the Forth programming language, simplicity, and a variety of technical subjects. Introduction: http://tinyurl.com/kvawv | Starting Forth: http://tinyurl.com/rm7pq | Thinking Forth: http://tinyurl.com/nsy4j | Gforth compiler: http://tinyurl.com/s8uho | ANS/ISO Forth Standard doc: http://tinyurl.com/nx7dx | Paste >5 lines: http://forth.pastebin.ca/'
08:11:56 --- topic: set by Quartus on [Wed Aug 30 23:43:43 2006]
08:11:56 --- names: list (clog PoppaVic Astrobe vatic zpg nighty_ arke Cheery @Quartus madgarden Snoopy42 larsb TreyB madwork @JasonWoof virl virsys @crc fission Quiznos Teratogen Quartus__ jcwren Zarutian nighty Zymurgy Raystm2 michaelw ohub warpzero juri_ ccfg)
08:34:40 --- join: BrianB04 (n=bmbommar@c-69-136-128-216.hsd1.mi.comcast.net) joined #forth
08:34:46 <BrianB04> Okay, I'm back after a minor drive failure.
08:35:04 <arke> Welcome back.
08:36:11 <BrianB04> I guess when you have a 6 year old drive, you shouldn't try to load big stuff off it...lest it may break.
08:36:33 <arke> Heh.
08:37:10 <arke> I'm not really practicing "safe driving".
08:37:15 <arke> I have everything on an external
08:37:19 <arke> if that breaks, I'm fucked :P
08:37:38 <BrianB04> I bought an external, nice Western Digital My Book
08:38:43 <BrianB04> I have a question though regarding forth: What's the difference between a word you just use like: word or a word that is preceded by a period?
08:39:34 <Astrobe> ypu mean, like: .word ?
08:39:40 <BrianB04> Yea.
08:39:50 <BrianB04> Or in the case of Win32Forth something like .platform
08:40:32 <Astrobe> normally none. It's probably just a denotation used by the author. Unless...
08:40:40 <PoppaVic> it's a vague convention
08:40:55 <PoppaVic> it usually IMPLIES <print>
08:40:56 <Astrobe> Win32Forth has OOP support, has it?
08:41:05 <BrianB04> Yea.
08:41:21 <BrianB04> I haven't even begun to look at the OOP support though:)
08:41:32 <Astrobe> Then maybe it's a method or property.
08:43:36 <BrianB04> I have to figure this out, because it doesn't work quite the same as MUF. In MUF if I do "something" "something" = if then, those two strings get dumped on the stack, apparently W32F doesn't think that way.
08:44:02 <PoppaVic> huh??
08:44:21 <BrianB04> In other words, any strings you input like "something" gets put on the stack...
08:44:27 <PoppaVic> oh.. you mean you have got a weird variant with different conventions
08:44:44 <BrianB04> Right. It must have changed more about how FORTH works than I thought.
08:44:58 <PoppaVic> or your syntax is off
08:45:15 <BrianB04> Although, I suppose that's why MUF can be made so horribly unreadable.
08:45:17 <PoppaVic> The major consistency in forths is - they ain't consistent.
08:45:38 <PoppaVic> talking about "forth" is akin to talking about "asm"
08:46:35 <Astrobe> My ANS Forth is rusted, but I think the correct phrase is S" something" S" something" COMPARE IF ( ... ) THEN
08:46:44 <BrianB04> Here: http://forth.pastebin.ca/187886 if you are curious, is what a MUF program looks like.
08:46:55 <PoppaVic> yeah, there has never been huge agreement about "
08:47:22 <Astrobe> That's why there's S" IIRC! :)
08:47:28 <PoppaVic> even '.' is a muck
08:47:38 <PoppaVic> Astrobe: sometimes.. somehow
08:48:40 <BrianB04> In that program, if anyone looked at it, anything is a . is a defined macro, so you can define something to do anything, and use .<whatever> doesn't have to be in the actual program.
08:49:01 <PoppaVic> sounds flakey to me
08:49:21 <PoppaVic> ..like an entirely new and weird convention
08:50:07 <BrianB04> But, I figured even if there are differences, I am starting to understand how to think in stacks, so...I can learn it:)
08:50:18 <BrianB04> And that was the biggest challenge.
08:50:52 <BrianB04> Does 'normal' FORTH use anything like this ( s -- s ) to indicate what happens to the stack after a word runs?
08:50:52 <PoppaVic> even that is sorta' messy
08:51:09 <Astrobe> MUF seems to be a deviant dialect of Forth
08:51:32 <PoppaVic> BrianB04: often folks will use ( ? --- ?' )
08:51:44 <PoppaVic> where "?" is already a shithole.
08:51:58 <Astrobe> but, yes stack pictures are in common usage
08:52:39 <PoppaVic> Astrobe: please be advised, the nearest thing to a forth "standard" is FIG, F79, F83 and ANS - and they are all really, really vague.
08:53:23 --- join: Crest (n=crest@p54895632.dip.t-dialin.net) joined #forth
08:53:55 <BrianB04> Is there any one particular 'standard' that should be stuck with?
08:53:59 <PoppaVic> The "conventions" are a royal mess.
08:54:11 <BrianB04> I know that W32F is ANS.
08:54:20 <PoppaVic> BrianB04: nowadays? THe best I can suggest is Gforth
08:54:26 <Astrobe> IMO, ANS Forth is precise enough to be an official ISO standard.
08:54:44 <Astrobe> BrianB04: ANS Forth
08:54:45 <PoppaVic> Astrobe: that's nice, but you'd be in error
08:54:54 <Crest> one thing that realy sucks in gforth is that it doesn't implement forget
08:54:55 <Astrobe> The current one.
08:55:03 <PoppaVic> Astrobe: it's close though
08:55:10 <Crest> and i has no powerpc assembler
08:55:12 <BrianB04> I would like to have the ability to do GUIs...though I guess for learning GForth could work.
08:55:22 <Astrobe> BrianB04: Speak ANS if you want to get help!
08:55:22 <PoppaVic> Crest: frankly, most forths implement some variant anyway
08:56:20 <PoppaVic> BrianB04: you may well want some commerical product, for gui.. And, (again), it isn;t going to be portable.
08:56:21 <Astrobe> Crest: try MARk or MARKER
08:56:30 <Crest> k
08:56:53 <Crest> you can work around the missing forget but its not fully ans complient bc of this
08:57:11 <BrianB04> PoppaVic: So something like SwiftForth?
08:57:14 <PoppaVic> Crest: mark/marker is the "latest variant" - it's still a mess.. So far as I know, if you HAD deferred words into that space - you can expect to die ugly.
08:57:50 <Crest> tmsidk i already had this kind of fun
08:58:01 <PoppaVic> BrianB04: if you want to do well with a-forth, you might. I won't run doze and don't care at all, but yeah: you want support.
08:58:28 <PoppaVic> huh?
08:58:31 <BrianB04> PoppaVic: Whatcha run? OSX or a *nix variant?
08:58:44 <Crest> osx
08:58:54 <PoppaVic> I ran Debian for successful years, and then went to a powerbook and OSX
08:59:05 <Crest> osx is a unix variant
08:59:10 <PoppaVic> yep
08:59:17 <PoppaVic> actually, a bsd-variant
08:59:29 <virl> actually bsd on steroids
08:59:38 <PoppaVic> I live in C, so I get peeved.
08:59:53 <arke> C# here
08:59:54 <Crest> althoug it' kernel is a truly mad kombination of mach3 and freebsd5
09:00:05 <Crest> *combination
09:00:18 <PoppaVic> virl: I dunno about "steriods", I think it's OK, but that's mostly libs and headers and tools
09:00:30 <BrianB04> If OSX machines werent so expensive compared to PC counterparts, or I could buy OS X for my (Really standard) PC...I would.
09:00:43 <PoppaVic> Crest: since I never touch kernel-source anymore: I don't care at all
09:01:11 <PoppaVic> BrianB04: I'd recommend either freebsd or debian, and leave the goddamned kernel alone.
09:01:52 <BrianB04> I always /hated/ bothering with the kernel, always such a pain in the butt.
09:01:59 <PoppaVic> Folks that keep dicking the kernel and bleed are just... funny.
09:02:15 <BrianB04> Everybody was always like: "But you can make it really tiny, and boot really really fast"...it's a kernel...it boots fine.
09:02:32 <PoppaVic> ..until it breaks "the universe"
09:02:54 <PoppaVic> and, once broken - you better have an alt-boot
09:02:54 <BrianB04> FreeBSD is especially bad about that...everything hinges on the kernel.
09:03:06 <PoppaVic> then don't diddle it.
09:03:59 <BrianB04> The one thing I hate with OS X, and this isn't the system itself, it's some of the fanatics that move with it. "But it doesn't look exactly like an OS X application, the spacing is a bit off".....
09:05:29 <PoppaVic> ugh
09:05:35 <Astrobe> I just finished implemented NEEDS .... in blocks! :)
09:05:58 <PoppaVic> <shrug> I never use blocks - congrats, you've hit the 70's
09:06:09 <BrianB04> That's why I don't port anything I write to OS X...people whine about how it looks.
09:06:33 <PoppaVic> BrianB04: don't confuse CLI with GUI, or even termwin with CONSOLE.
09:07:37 <Astrobe> if it's old, doesn't mean it cannot be modern.
09:07:56 <BrianB04> I would love to spend my time writing for console, so much easier:) But, unfortunetly most people need shiny buttons.
09:08:08 <PoppaVic> I'm still looking for a portable way to learn console/mode and deal with scancodes/raw, but it looks unlikey.
09:08:30 <PoppaVic> BrianB04: look - a GUI is not "the program" - it's an interface.
09:09:10 <PoppaVic> I guarentee I can't write a nice GUI. BUT, I can write a lib and CLI that the GUI author can use.
09:09:24 <Astrobe> I don't think GUI programming is that harder; it depends on the lib you use.
09:09:52 <PoppaVic> GUI's blow to program, and part of it is ART and the other is learning to work with "events"
09:10:19 <PoppaVic> oh.. and don't forget "style/convention manuals"
09:10:36 <BrianB04> It can be harder. Take a look at QT, you write your C++ code, then have to code in dozens of other weirdly named items, and events as PoppaVic said to make it work. And if it doesn't look exactly right, people whine...it's a lose lose.
09:10:52 <PoppaVic> I never use QT or C++ anymore
09:10:59 <PoppaVic> let them whine.
09:11:24 <Astrobe> Exactly what I mean BrianB04. Then take a look at GraphApp
09:11:29 <PoppaVic> If you need an "artist" versed in QT, then hire 'im. THe core can be C
09:11:33 <BrianB04> You write strictly in C?
09:11:56 <PoppaVic> NO, I tinker in Gforth for fun and C for my "universe"
09:12:03 <Astrobe> Granted, it has much less features, but user interfaces mustn't be complex anyway.
09:12:36 <BrianB04> I've been meaning to get back into C
09:12:47 <PoppaVic> My personal feeling is to use HTML and a browser - feed the output to anybrowser and let the browser manage the gui.
09:13:31 <virl> thats the reason why QT has a designer.. to hide those weird things..
09:13:49 <PoppaVic> glade exists too - and it's STILL nasty
09:14:04 <BrianB04> It hides the weird things to a point, until you have to code for them:)
09:14:12 <PoppaVic> yep
09:14:56 <BrianB04> That's the reason why so many retail outlets still use console based applications...they are easier to code, and cheaper to code.
09:15:01 <PoppaVic> I'm trying to wrap my Cish/Forthish head around "events", to see if THAT makes a diff.. I believe it might.
09:15:30 <PoppaVic> well, others use a sealed-GUI - same idea
09:15:36 <arke> PoppaVic: try .NET, you'll never look back :P
09:15:38 --- quit: vatic ("*poof*")
09:15:49 <PoppaVic> arke: not in my life.
09:16:32 <BrianB04> .Net, you mean the weird mess? .Net was so bizaare, at least to me, especially in how it deals with SQL...what ever happened to simply running a query, getting results, working with results?
09:16:53 <PoppaVic> SWL is another whole half-ass solution
09:16:57 <PoppaVic> SQL
09:17:31 <PoppaVic> arke: have you reread thru the the Thinking Forth pdf yet?
09:18:22 <arke> PoppaVic: I printed it out and bound it myself and have read it several times, yes.
09:19:24 <PoppaVic> cool... I had the ol' hardcover around.. He's got a lot of good concepts, but I get bugged by a lot of underlying assumptions... We still suffer the 70's
09:19:35 <arke> Yeah. :(
09:19:50 <arke> As much as I love forth, I'Ve found theres not really much place for the language itself anymore.
09:19:58 <arke> However, there is much more room for its philosophy
09:20:03 <arke> and I think that part of it will never die.
09:20:09 <PoppaVic> For example... I still HATE just adding word after word to the "main-namespace"
09:20:12 <arke> And I abide by it everytime I write a line of code. 
09:20:43 <PoppaVic> yes, oh my god yes: don't get me wrong.. he's got concepts there that apply to ANY language
09:21:22 <arke> Yes.
09:21:34 <arke> Which is why I think it is probably the one book that has helped me the most grow as a programmer.
09:21:40 <PoppaVic> yeppers
09:21:55 <PoppaVic> I wish he would retitle it and clean it up a bit.
09:22:15 <arke> It would be cool to adapt it to a newer programming language
09:22:27 <arke> I think somebody said they wanted to do that someday
09:22:45 <PoppaVic> Be even more cool if he just kept forthish, and lost the ancient presumptions.
09:22:52 <Astrobe> Which language would you choose for that?
09:23:18 <Astrobe> which presumptions?
09:23:28 <arke> Astrobe: I don't know, to be honest.
09:23:48 <PoppaVic> prob is Brodie either ends up trapped in traditional/FIG mindset, F79, F83 or whatever forth-inc is hawking.
09:23:54 <arke> Right now, I'm in love with C# so I'd say that but some concepts need to be changed up.
09:24:13 <BrianB04> There is a guy called AnalogX that writes some really tiny applications, and I keep trying to figure out what he does the Frontends in, since he uses strictly C
09:24:14 <Astrobe> such as?
09:24:32 <PoppaVic> C# can blow me (again)... It's more changes in the wrong places for the wrong reasons.
09:24:57 <PoppaVic> BrianB04: no context
09:25:02 <BrianB04> And of those books listed in the topic, where should I start to learn FORTH? Starting Forth, or somewhere else?
09:25:06 <arke> PoppaVic: C# has made a huge impact and rightly so ... one year ago, I thought the same thing as you, but it really is a great new thing.
09:25:35 <PoppaVic> arke: all they are doing is playing with an advanced cpp and some C tweaks.
09:25:40 <arke> PoppaVic: They took the best things of Java, C++, and some older OOP languages, and made a very streamlined language out of it.
09:25:56 <arke> Noo no no no n
09:26:01 <arke> you really cannot compare C# to C++
09:26:06 <arke> They are very different
09:26:08 <PoppaVic> arke: well, macosx wants me to use Obj-C - and I can't play.
09:26:10 <virl> but to java
09:26:25 <arke> yes, its more similar to Java
09:26:37 <arke> but anybody whos done both (like I have) will tell you right off the bat how shitty Java is
09:26:41 <virl> hell, they took java and put the things back into it which java didn't include
09:26:49 <virl> (for good reasons)
09:26:50 <PoppaVic> hehehehaha
09:26:54 <arke> virl: thats a totally false statement :)
09:27:07 <PoppaVic> cool..
09:27:11 <virl> I won't touch this ugly C# shit
09:27:24 * PoppaVic slides thru the room watching the OTHERS snipe ;-)
09:27:44 <arke> PoppaVic: :)
09:27:46 <virl> really anything which was made by this stupid company can't be good
09:27:53 <arke> virl: again, not true.
09:28:15 <arke> For example, C# and .NET :)
09:28:21 <virl> and btw. the world had too much C style languages
09:28:24 <arke> brb dinner
09:28:35 <arke> virl: because they work and everybody feels familiar
09:28:46 <virl> arke, please get your brain back, wherever you lost it
09:29:02 <Astrobe> BrianB04: I would suggest, pick an ANS Forth, pick a simple app you want to make, and try to write it. If you fail, ask questions here or on c.l.f.
09:30:22 <PoppaVic> 80% of everything seems to be syntax and semantic. 
09:30:51 <Astrobe> and the remaining 20% ?
09:31:06 <PoppaVic> so far, not one c.l.f ref. has made me interested/happy
09:31:35 <PoppaVic> the last 20 percent seems to be parsing/macros/interpret/compile/runtime
09:32:12 <PoppaVic> add to that export/inport, binary/pcode-interpret
09:32:13 <Astrobe> I guess that was 80% of languages, not everything then
09:33:15 <PoppaVic> Folks still love to forget that Forth was DESIGNED to BE the "OS" originally.
09:33:59 <Astrobe> c.l.f. is a good place for newbies to ask beginner questions. The only thing is that sometimes it brings back flamewars. Pick your answer(s), and run in taht case
09:33:59 <PoppaVic> from what I recall of ANS, it's never really been subjugated, either
09:34:02 <virl> would be fine, but there isn't any modern implementation today.
09:34:30 <PoppaVic> Astrobe: yeah, I was a FIG member for a few years - I don't miss most of the waste
09:35:06 <PoppaVic> virl: what would?
09:35:35 <virl> when forth would be the OS
09:35:41 <PoppaVic> ugh
09:35:56 <Astrobe> the dquotes around OS are important, cause at that time OSes didn't even exist
09:36:00 <PoppaVic> That's FINE for embedded-processors doing a chore
09:36:16 <virl> "OS"
09:36:17 <PoppaVic> Astrobe: not true, CP/M was around
09:36:40 <virl> bah, well embedded processors not..
09:36:42 <PoppaVic> prob is, all forths want to be written in asm and take over the systems
09:36:59 <virl> it would be cool for a gaming console..
09:37:04 <PoppaVic> sure would
09:37:15 <Astrobe> Ok, it was just invented.
09:37:23 <virl> and for a desktop.. well sad dreams
09:37:28 <PoppaVic> yes
09:37:33 <PoppaVic> but, WHY?
09:37:40 <PoppaVic> too many preconceptions
09:38:36 <arke> back
09:38:40 <arke> virl: whats with the insults?
09:38:46 <PoppaVic> I sometimes have to agree with the Lispers.
09:38:59 <PoppaVic> I don't *LIKE* to do so, but...
09:39:22 <arke> Its funny how similar Forth and Lisp are in some ways
09:39:34 <arke> I don't think it is a coincidence either.
09:39:38 <PoppaVic> otoh, most of the fanatic lispers are thinking of lisp---->machine
09:39:46 <PoppaVic> ..they bypass everything as well
09:39:47 <Astrobe> The problem is that the modern meaning of OS is "everything in the box", uber-lib, and that's not compatible with Forth.
09:39:58 <PoppaVic> Astrobe: I disagree
09:40:18 <virl> modern OS aha-haha
09:40:23 <arke> Astrobe: its not incompatible with Forth, its just that all the forths aren't made to be like that
09:40:36 <PoppaVic> I think it hilights many forth concepts/ideas, but most forths are so damned antiquated, we never get ahead
09:40:51 <arke> PoppaVic: exactly.
09:40:57 <virl> xell xell xell xell for ever
09:41:07 <Astrobe> no, if you're "OS" doesn't do preemptive multitasking, people tell you that it's not an OS.
09:41:19 <PoppaVic> virl: you can laugh and bray, but yer still snarfled.
09:41:45 <arke> Astrobe: They'll tell you its an OS but not a modern OS
09:41:49 <PoppaVic> Astrobe: tasking is simply a low-level interrupt and handlers.
09:41:58 <Astrobe> if there's no memory protection, people tell you it's not an OS
09:42:05 <Cheery> I wonder what is future OS...
09:42:10 <Cheery> :P
09:42:17 <arke> again, they'll say its an OS but not a modern OS :)
09:42:34 <arke> Cheery: BLOATWARE :P
09:42:43 <Astrobe> if it has no file system, they tell you it isn't an OS
09:42:51 <Cheery> Is this modern OS some kind of joke? :D
09:42:51 <arke> again, they'll say its an OS but not a modern OS :)
09:43:08 <Astrobe> Still, there are many embedded modern OS that have none of these.
09:43:30 <Cheery> arke: I think the OS which forces what kind of file system you have is stupid.
09:43:44 <Cheery> if modern OS is stupid, why would we want such? :)
09:43:48 <PoppaVic> you don't own the FS.
09:44:07 <PoppaVic> the FS and all the kernel-shit is NOT open.
09:44:19 <PoppaVic> yer a layer above
09:44:23 <Cheery> who owns it then? MS or RIIA?
09:44:39 <virl> modern OS is much much more bloat for every simple task... object oriented shells ... webservices for local things .. so like hurd .. and much other modern things ..
09:44:41 --- quit: zpg (Read error: 110 (Connection timed out))
09:45:35 <arke> virl: and whats wrong with that?
09:45:59 <arke> processing power is enough that a little bit can be spent on abstraction
09:46:52 <virl> 'little bit on abstraction' this 'little' is in reality extrem much.
09:47:13 <arke> thats an implementation issue though.
09:47:18 <arke> Lets take .NET as an example.
09:47:21 <arke> You see what it provides
09:47:25 <arke> It provides alot
09:47:28 <arke> and you can use it very easily.
09:47:35 <arke> Isn't that all you could ever want?
09:48:14 <arke> It wouldn't be very hard to make a simple OS to run .NET
09:48:29 <arke> And you can take that and run it anywhere
09:48:42 <arke> You can't say the same about Forth, or C++
09:49:01 <virl> sry, but that is a java argument.
09:49:25 <arke> It was javas argument.
09:49:39 <arke> .NET does it so much better though.
09:49:42 <Cheery> .NET provides a lot?
09:49:44 <arke> Especially faster.
09:49:50 <arke> Cheery: yes.
09:50:13 <Astrobe> Nonsense arke. Forth can run anywhere, and could probably be ported much easily.
09:50:14 <Cheery> What kind of flower-blindfold do you have?
09:50:38 <PoppaVic> Astrobe: well, gforth can.. FIG did
09:50:45 <Cheery> .NET provides relatively little to what it does.
09:51:11 <arke> Astrobe: to a limited extent, yes. But not much.
09:51:14 <Cheery> or what it contains.
09:51:21 <PoppaVic> .NET just fixes a convention/codification. Forthers COULD have done so decades ago
09:51:31 <arke> Astrobe: you don't have one way of drawing, one way of doing this, one way of doing that, which you can _depend_ on being there.
09:51:46 <arke> PoppaVic: I agree that Forth could have been .NET years ago. 
09:51:57 <arke> Cheery: It provides plenty for what I need to do with it.
09:52:09 <arke> Cheery: for business coding, it is pretty much the ultimate.
09:52:27 <arke> (but thats not what I'm doing with it at the moment)
09:53:30 <Astrobe> arke: just wait for ANS 200x.... it's only a matter of standards. My system runs GUI with the same look under X11 and Windows. It's quite easy to define a thin abstraction layer to get source-level portability
09:54:04 <arke> Astrobe: thats exactly my point though ... .NET gives you that layer already, you never have to worry about it.
09:54:21 <arke> Astrobe: and ANS 200x is a joke, I'm on the mailing list and theres nothing worth interest going on.
09:54:33 <arke> I might even have unsubscribed because of it.
09:55:16 <arke> And even so, it doesnt provide you a layer at all
09:55:25 <Astrobe> arke: you also said that you cannot do that in Forth.
09:55:34 <arke> No I did not.
09:55:41 <arke> You can do that in Forth just fine.
09:57:16 <Astrobe> You said that one can make a simple OS to run .NET everywhere, and that one cannot build a simple <kernel> and run Forth everywhere
09:57:32 <arke> Where did I say that?
09:57:48 <arke> You can do that with Forth as well.
09:57:50 <Cheery> i wonder how many bool b = True; if(b) { return True; } else { return False: } there is in .NET
09:57:58 <Cheery> or typo.
09:58:00 <Astrobe> 1Omin ago
09:58:01 <arke> But with Forth, you need to write the huge library, come up with a good interface for it, test it, blah blah blah
09:58:17 <Cheery> i wonder how many bool b = True; if(b) { return False; } else { return True: } there is in .NET
09:58:27 <arke> Cheery: why do you ask that?
09:58:33 <arke> Cheery return !b;
09:58:53 <Cheery> I just ask. ;) 
09:58:59 <arke> Oh. :)
09:59:22 <virl> oh.. I'm so sick of OOP
09:59:40 <Quartus> virl hates something?   Wow, it must be a day ending in a Y. :)
09:59:40 <arke> virl: have you even used it, except for reading about it?
09:59:42 <Cheery> I'm sick of programming languages and the capitalism.
09:59:47 <arke> Quartus: :)
10:00:27 <Cheery> arke: I'm same with virl about OOP.
10:00:45 <PoppaVic> OOP is not OO, I wish folks would learn that
10:01:07 <Cheery> kind of OOP which is oriented around java.
10:01:09 <arke> Thats fine, but alot of people simply dislike OOP because they read about it and it didnt appeal to them :)
10:01:16 <Cheery> other kind of OOP doesn't look too bad actually. :)
10:01:26 <arke> Well, Java is ugly anyway :D
10:01:30 <PoppaVic> arke: worse - it won;t translate or port well
10:01:35 <Cheery> Thus I hate C++ OOP as well.
10:01:37 <Astrobe> arke: you can pick libs written by others, just like .NET probably does.
10:01:37 <virl> I wrote once a helloworld in it and it reminds me so on java and java suX 
10:01:59 <arke> virl: ..........!!!!! HAHA
10:02:00 <PoppaVic> Cheery: be nice to know WHY - and stop saying OOP vs OO
10:02:18 <Cheery> PoppaVic: why?
10:02:26 <PoppaVic> because OOP != OO
10:02:37 <PoppaVic> contexts are not classes
10:02:48 <PoppaVic> classes are NOT polymorphs
10:02:51 <virl> the only OOP which I would fine would be the one I created by myself
10:02:52 <crc> good afternoon
10:02:58 <Quartus> Object Oriented Programming is not Object Oriented, eh?  Genius.
10:03:15 <Cheery> shh. he's acronym expert. ;)
10:03:31 <arke> virl: well, there IS the saying that "if you want something done right, do it yourself" :)
10:03:33 <Astrobe> The problem is, that OO is not as easy at it looks.
10:03:46 <PoppaVic> Quartus: I mean they are not identical, and OOP has far more implications - if that bugs you, tough shit.
10:03:47 <virl> arke, I know that one.
10:03:57 <Astrobe> And OOL sometimes severely distort OO
10:04:02 <arke> Although I do prefer the form "If you want something done your way, do it yourself. If you want it done right, do it twice". :)
10:04:04 <PoppaVic> right
10:04:05 <arke> crc: hello :)
10:04:23 <arke> Astrobe: OO is hilariously easy if you have a bit of framework, like .NET :)
10:04:26 <PoppaVic> Astrobe: well, NOW envision "event-programming"
10:04:30 <virl> there are so much shit in this world, to solve it I need to be fast as light and be immortal.
10:04:32 <arke> Astrobe: and even without framework, hehe
10:04:49 <crc> hi arke
10:04:50 <arke> PoppaVic: Theres another thing MS did right - event programming is SOO easy in .NET
10:05:02 <PoppaVic> arke: that's nice - why?
10:05:11 <arke> virl: Well, at least you're not lacking in self-confidence :P
10:05:15 <virl> oh.. wise arke.. how easy?
10:05:29 <Astrobe> arke: no no no placing methods, designing class hierarchies requires experience. That's why there's design patterns.
10:05:44 <PoppaVic> afaik, .NET is all run under a single vm/engine
10:06:11 <PoppaVic> wtf is a "design pattern"? a goddamned "template"?
10:06:23 <arke> PoppaVic: void showHelloWorld() { MessageBox("Hello, World!"); } ... MyButton.OnClick += new delegate(showHelloWorld); (thats actually pseudocode here, but its almost the same)
10:06:35 <Cheery> PoppaVic: Where to start? hmm... First thing I can't get over is that OOP java and C++ uses a whole big set of 'new' keywords and syntax goop that no-one except weirdo can stand it.
10:06:35 <Astrobe> Poppavic: no it's more sorta recipe.
10:06:46 <PoppaVic> arke: hmm, I dunno - now add a few
10:07:01 <crc> PoppaVic: http://en.wikipedia.org/wiki/Design_pattern_(computer_science)
10:07:11 <PoppaVic> Cheery: depends on what you need to know and why
10:07:17 <arke> PoppaVic: MyButton.OnClick += new delegate(method1); MyButton.OnClick += new delegate(method2); MyButton.OnClick += new delegate(method3); :)
10:07:33 <Astrobe> : HELLO " Hello, World" DIALOG ;
10:07:59 <arke> Astrobe: my example was showing how to trigger the hello world upon clicking some button
10:08:05 <PoppaVic> sounds like everyone gets the same args and returns the same values and you are talking about funcs - or maybe just a process.
10:08:17 <arke> PoppaVic: ?
10:08:42 <PoppaVic> arke: yeah.. It depends on the i/o stuff and the engine, apparently.
10:08:51 <arke> Oh.
10:08:52 <arke> Yeah.
10:08:53 <Astrobe> : SHOW-HELLO HELLO SHOW ; ' SHOW-HELLO MY-BUTTON ON-CLICK
10:08:53 <Cheery> OOP class-object -relationship neither makes me happy. Instead you encapsulate actions, you start encapsulating plato-objects inside each other and creating black ghettos.
10:08:55 <PoppaVic> ..seems like they may have codified all the i/o
10:09:17 <arke> Astrobe: sure. Now add maybe two more small libraries and your namespace is overfilled.
10:09:24 <PoppaVic> wtf is a "plato-object" or yer version of a ghetto?
10:09:29 <Cheery> and multiplying them like they'd be some static viral infections or something.
10:09:31 <Quartus> "namespace is overfilled"?
10:09:41 <Cheery> expect not having any kind of evolution program.
10:10:13 <PoppaVic> evol? genetics? wtf?
10:10:26 <Astrobe> arke: no. I do more or less that in my system. The GUI lib require less that 100 words (probably far less).
10:10:34 <arke> Quartus: Either that or method names have to check the type and index a VT every time you call it at runtime
10:10:56 <Quartus> arke, that'd be a really clumsy way to build an OO layer.
10:11:06 <PoppaVic> arke: ahhhh - I'll let you fight the good fight there ;-)
10:11:17 <arke> Well
10:11:22 <arke> I don't want to argue about OO in Forth
10:11:29 <arke> because I don't even know myself what the ideal system would be.
10:11:35 <arke> Nobody has come up with one I liked though.
10:11:42 <arke> I like how C# does it - simple and easy to understand.
10:11:59 <PoppaVic> arke: it's difficult because the way most forths treat the base-wordlist/voc is how C treats "the namespace"
10:12:18 <arke> Yes. :/
10:12:21 <PoppaVic> .and the latter is NOT friendly either
10:12:56 <arke> I haven't checked on RetroForth in a while but I think it had the underlyings for a very good OO system 
10:13:07 <arke> I should do that.
10:13:18 <PoppaVic> except it's again written in ASM and doesn't port well
10:13:57 <crc> PoppaVic: it runs on the major (other than OS X) operating systems for the x86 architecture
10:14:08 <Quartus> If it was written in C, you'd slam it for that.
10:14:16 <Astrobe> the ideal system, the ideal language, is the one you understand, you master, and that fits your needs and requirements.
10:14:19 <PoppaVic> that's nice - and I don't have an X86, next?
10:14:44 <PoppaVic> Quartus: I love watching you in action - it's comedy.
10:15:05 <arke> PoppaVic: port retro to MSIL and you can run it on anything :)
10:15:14 <Astrobe> ... Port the asm! programmer or chicken?
10:15:14 <arke> or port it to JVM
10:15:22 <arke> Hehe.
10:15:24 <crc> arke: does MSIL support self modifying code yet?
10:15:33 <arke> crc: I don't know.
10:15:54 <crc> back in the .NET 1.0 days it didn't (I did check)
10:16:14 <arke> well, its on .NET2 now, soon .NET3, so it might (although I doubt it, its a security thing)
10:16:39 <arke> But I believe there are ways to run IL apps from a IL program
10:16:49 <arke> generate, run, or something
10:16:57 <crc> that's not quite the same though... :)
10:17:03 <arke> Nope, its not. :)
10:17:09 <crc> I'd guess that a direct or indirect threaded forth could be done though
10:17:21 <arke> Yeah.
10:17:30 <arke> There was a .NET forth somewhere
10:17:34 <arke> incomplete though.
10:17:47 <virl> lol.. on anything I don't expect to see a .net application running on a ATMEL cpu
10:17:58 <crc> that was not an interactive forth; it just compiled to .NET apps though
10:18:03 <arke> virl: and again, why not?
10:18:29 <virl> arke? you ask THAT really? *buhaha*
10:18:36 <arke> virl: .NET apps are just bytecode that are translated, and you can also directly translate it to a, executable. I don't see the problem. .NET apps are way faster than Java apps too.
10:18:49 <PoppaVic> hehehe
10:19:14 <arke> And really, virl
10:19:23 <arke> Would a forth app run that much faster? 
10:19:46 <arke> You're never gonna get realtime DSP out of it either way.
10:19:55 <PoppaVic> forth is always slower than any asm - so what? Now, forget optimizing the pcode.
10:20:19 <Astrobe> The problem is that there's chances you just cannot squeeze .NET in an ATMEL in the first place.
10:20:40 <PoppaVic> I am SURE that some bloke is bright enough to figure out how to turn the pcode into an inline set of calls and code.
10:20:41 <arke> Astrobe: which is why theres tools that give you statically compiled .NET executables so that you can.
10:20:46 <arke> which only include what you need.
10:21:03 <arke> Basically, what PoppaVic said
10:21:41 <Astrobe> what about the minimal system requirements in that case?
10:21:47 <Astrobe> WinCE? :)
10:22:03 <arke> Implementation of the .NET classes used.
10:22:34 <arke> Which can be provided in mostly pcode as well
10:22:36 <PoppaVic> forget .net - focus instead of who/what/howto for the platform(s)
10:22:51 <arke> .NET is just a way :)
10:22:53 <arke> (and I like it)
10:22:57 <PoppaVic> devices, drivers, drives, cpu....
10:23:27 <PoppaVic> arke: that's OK, I don't - but fine. Why does it work? it's an entire engine.
10:23:41 <Astrobe> virl: maybe it's time to give the CPU specs.
10:24:02 <arke> Astrobe: I know that its a tiny 8 bit thing with 32k of RAM.
10:24:08 <PoppaVic> Now, I'd be WORRIED if idiots tried to specify their .NET mess was "the os"
10:24:11 <arke> or maybe more, depending on what its done for.
10:24:21 <arke> PoppaVic: it could be :)
10:24:27 <arke> (personally, I wouldn't mind)
10:24:38 <PoppaVic> arke: sure, and it's still "an engine"
10:25:12 <arke> Yep.
10:25:12 <PoppaVic> all it does is codify the idea of source/pcode/binary(load/link), etc
10:25:17 <virl> to give the CPU specs?
10:25:23 <arke> eerm.
10:25:31 <arke> PoppaVic: not just that, it also gives you a library etc.
10:25:42 <PoppaVic> doesn't usually need CPU - it could use artificial/internal.
10:25:44 <Astrobe> virl: of your atmel CPU.
10:25:44 <arke> A pretty big and good one at that
10:25:55 <PoppaVic> arke: sure, like a better libc
10:26:00 <Astrobe> bbl
10:26:04 --- quit: Astrobe ("leaving")
10:26:06 <crc> PoppaVic: singularity is an OS written in/around .NET
10:26:07 <arke> I guess you could say that.
10:26:20 <crc> http://research.microsoft.com/os/singularity/
10:26:26 <PoppaVic> I still think folks want to bypass issues to reach issues.
10:26:29 <arke> Ooh, I had forgotten about that! :)
10:26:49 <arke> I don't know why people are so opposed to the portability thing.
10:26:57 <PoppaVic> crc: it's still riding on one, right?
10:26:57 <arke> One library interface which you can use anywhere.
10:27:16 <Quiznos> arke i have a reason; portability, the way GNU uses it leads directly to binary bloat.
10:27:23 <PoppaVic> arke: there is a LOT of Chuck-input, and worse - asm-heads
10:27:34 <crc> PoppaVic: riding on what?
10:27:38 <arke> Quiznos: I don't really agree with GNU though :)
10:27:42 <Quiznos> ok
10:27:47 <PoppaVic> crc: the OS
10:27:49 <arke> But you're right.
10:27:51 <Quiznos> i want a deGNUded dist
10:28:09 <crc> the OS is written in a small amount of assembly (for low-level initialization of hardware), the rest in a version of .NET
10:28:11 <PoppaVic> I can agree with the fact GNU can bug the fuck outta' me
10:28:34 <PoppaVic> crc: unless that was bootstrapped from a loader, it makes no diff
10:28:37 <crc> kind of like jnode (http://www.jnode.org/) does with Java
10:29:14 <PoppaVic> I think the #openbios folks had a hint.. I just keep thinking there is more above.
10:29:16 <crc> PoppaVic: singularity *is* its own OS
10:29:34 <crc> Quiznos: BSD :)
10:29:39 <PoppaVic> crc: that's great - how well does it interface with decades of existing code?
10:29:46 <crc> it doesn't.
10:29:50 <PoppaVic> ahhhh
10:30:28 <arke> ...which is a good thing, in my opinion :)
10:30:32 <crc> and why should it? It's a research project, not a commercial system
10:30:42 <arke> .NET2.0 isn't completely backwards compatible to .NET1.1 either
10:30:46 <arke> mostly, but not completely
10:30:51 <arke> and how about OSX vs. OS9?
10:30:53 <PoppaVic> crc: research is nice...
10:31:13 <PoppaVic> arke: well, from M$, I ain't suprised
10:31:15 <arke> Apple just wrote OSX from the ground up then made a wrapper .. thats how legacy stuff should be supported :)
10:31:21 <arke> PoppaVic: um.
10:31:33 <arke> PoppaVic: except that Windows XP can still run Windows 3.0 apps without problems? :)
10:31:43 <arke> I'd call that legacy support :)
10:31:46 <PoppaVic> it was similar with FIG and F79, 83, etc
10:32:09 <crc> arke: you can run windows 1.0 apps under xp if you alter a few bytes in the executable header
10:32:30 <arke> Even better! :)
10:32:34 <PoppaVic> I don't mind "legacy", but I'd prefer xlating - wrappers work, but get ugly fast
10:33:01 <arke> PoppaVic: well yes, but the principle is the same - write anew, then provide compatibility, instead of writing to maintain compatibility
10:33:26 <arke> Its what they should have done with Vista (they did it a little bit but not enough)
10:33:53 <PoppaVic> arke: oh, don't take me wrong: if v2 is superior to v1, then v2 should be xlate v1 constructs into apropos for v2.
10:34:23 <arke> Yeah.
10:34:25 <arke> Like that.
10:34:29 <PoppaVic> what HAPPENS, however, is clever lil' asm-whackers just go ahead and short it all
10:34:35 <arke> ???
10:35:05 <PoppaVic> arke: it may be I've seen worse
10:35:45 <PoppaVic> I've seen some god AWFUL code
10:36:17 <arke> then you'll love thedailywtf.com :)
10:36:42 <PoppaVic> C programmers relying on "inline asm" and forthers that decide to tweak binary or write code: ... code;
10:37:08 <arke> Oh, that. Yes.
10:37:16 <arke> .NET doesn't allow that.
10:37:16 <arke> :)
10:37:26 <PoppaVic> arke: these are the sorta' think that make Autoshit seem to "do the job"
10:37:53 <arke> :)
10:37:58 <PoppaVic> does .Net allow link & load from existing libs?
10:38:17 <arke> it has pinvoke which allows loading unmanaged .dlls, so yes
10:38:50 <PoppaVic> ahhh, that ain't all bad.. I'd hope the compiler warns (for now)
10:38:54 <arke> and theres sites out there dedicated to making wrappers for popular .dlls for just that purpose (which I find great)
10:39:08 <PoppaVic> arke: yeah, wrappers bug me
10:39:18 <arke> I noticed.
10:39:26 <arke> But this is the good kind of wrapper.
10:39:30 <arke> :)
10:39:48 <PoppaVic> Well, any idiot can write a "wrapper" that just masks "issues".
10:40:05 <PoppaVic> I keep thinking there should be more/better
10:40:23 <arke> well, I don't know why you'd call that an issue.
10:40:38 <arke> By virtue of unmanaged vs. managed code, you have to do a little changeing around
10:40:53 <arke> if you have a simple light wrapper, I can't see anything bad from this.
10:41:01 <PoppaVic> arke: oh, most of them don't port well or handle what failed/why - right up the shitpile
10:41:01 <arke> like
10:41:33 <arke> Oh, I see what you're saying.
10:41:36 <PoppaVic> it's like C++ programmers talking about "Gee, you can write a C wrapper"
10:41:37 <arke> Well, you can't avoid that.
10:41:42 * virl hopes .Net dies
10:41:49 <PoppaVic> arke: ok, why?
10:41:55 * arke hopes virl's uneducated opinions die :)
10:42:10 <arke> PoppaVic: people making bad wrappers.
10:42:19 <PoppaVic> I can see a reason for .Net, but I won't adopt the fucker
10:42:20 <arke> PoppaVic: that you can't avoid.
10:42:35 <virl> I don't need another 0190-programming language
10:42:45 <arke> virl: wtf?
10:42:49 <PoppaVic> arke: ahh, so we are back to "someone must traipse along and fix it"?
10:42:56 <virl> with another stupid vm-static-type system
10:43:06 <arke> PoppaVic: yeah, but you have that with EVERYTHING
10:43:12 <PoppaVic> virl: dream on
10:43:20 <PoppaVic> ..write yer interpreter
10:43:20 <arke> virl: I think you're confused.
10:44:25 <PoppaVic> arke: no, he's not confused THERE - he refuses to realize that EVERYTHING is interpreted AND COMPILED to be re-INTERPRETED, etc.
10:44:47 <arke> or rather compiled to be recompiled :)
10:44:55 <PoppaVic> or linked
10:45:00 <PoppaVic> or loaded/linked
10:45:13 <arke> Nah, its just that
10:45:20 <PoppaVic> there are a few basics, and V-mem adds a few
10:45:27 <arke> .NET? Its by microsoft? It has oop? I hate it!
10:45:54 <arke> (I'vebeen guilty of that one myself though)
10:46:03 <virl> you don't know anything.
10:46:21 <PoppaVic> arke: well, me? I despise M$ - yeah, and I know whom they stole from. But, beyond that I keep watching the Forthish universe - and it's never improved over 30 years
10:46:54 <PoppaVic> virl: and you still talk a good game and say less of use - so what?
10:48:23 <virl> god, why me.
10:48:28 <PoppaVic> yeppers
10:49:06 <arke> PoppaVic: I wasn't referring to you either. :)
10:49:21 <PoppaVic> arke: s'ok, I knew - but it wouldn't matter
10:50:27 <PoppaVic> arke: I see similar shit with the unicode folks that don't want it ALL in unicode, but magic - or the same magic and it COULD be unicode.
10:51:06 <arke> Yus!
10:51:09 <PoppaVic> ..some way or another, something reads to translate to execute to MAYBE interpret or transliterate or execite
10:51:21 <PoppaVic> execute
10:52:05 --- nick: Quiznos -> ElmerJFudd
10:52:24 <PoppaVic> what and how to which is always an issue, and everyone wants to pretend it doesn't matter. This is part of the OS-doesn't-Matter issue.
10:53:47 <PoppaVic> arke: even the bootstrap is a goddamned interpreter.
10:53:51 --- nick: ElmerJFudd -> Quiznos
10:53:57 <virl> I know it's not worth using it, and I'll prove it.
10:54:11 <PoppaVic> virl: what?
10:54:46 <arke> virl: I know its worth using it, and I can prove it - in only 2-3 years, it has dethroned both java and vb in their thrones of enterprise kingdom
10:55:01 <PoppaVic> oh, yer talking about .NET
10:55:08 <arke> virl: developers all around the world are rejoicing about .NET
10:55:26 <arke> virl: applications written in .NET are inherently more stable
10:55:30 <PoppaVic> arke: I don't (and won't), but that's neither here nor there
10:55:50 <arke> PoppaVic: well surely, but you have your reasons, and you don't need to. At least you're educated about it.
10:56:02 <PoppaVic> I think the idea solves the wrong problem, badly.
10:56:06 <virl> bah..
10:56:15 <arke> Surely, but that is a matter of opinion :)
10:56:36 <arke> virl: anyway, to recap, unless you can prove that all programmers suck except you (which you seem to think), you have no point.
10:56:49 <PoppaVic> of course, but I've been tinkering for at least 3 decades, and it seems to reiterate similar issues from the past.
10:57:01 <PoppaVic> arke: I'll but that
10:57:04 <PoppaVic> buy
10:57:14 <virl> -____-
10:57:27 <PoppaVic> virl: I know it bugs you
10:57:35 <arke> PoppaVic: yes, and I'm younger than your programming carreer :)
10:57:58 <PoppaVic> arke: and I'm a lot older than my years - it balances out.
10:58:23 <arke> :)
10:58:54 <PoppaVic> I hate to admit it, but the rugrat "Why?" has often proved out.. Until you get to the point where you hit "because"
10:58:57 <virl> why the hell doesn't the world improve for me? only for those bloatware.
10:59:29 <PoppaVic> virl: yeah?
10:59:39 <arke> PoppaVic: thats why I talk with my ideas to both people older and younger :)
10:59:52 <arke> PoppaVic: the older ones have the experiences, the younger ones ask the obscure questions :D
11:00:17 <arke> virl: because you're portraying yourself as a selfish, overly angered grumpy old man?
11:00:46 <virl> I'm not selfish, I never ever was selfish.
11:01:05 <arke> <virl> why the hell doesn't the world improve for me? only for those bloatware.
11:01:43 <virl> it's a fact, a bad one.
11:02:26 <virl> a really bad one.
11:02:27 <arke> why not work towards it instead of complaining and working against it?
11:02:55 <virl> why should I help the hell? why should I prevent happening good things?
11:03:21 <arke> "One must face their enemy before he can judge him". 
11:03:27 <arke> Educate yourself.
11:03:41 <arke> All you'Ve been suggesting so far is that the only thing you know about C# is that its microsoft and "kinda like that java thing". 
11:04:11 <arke> Not to mention that C# is now a standard too, not Microsoft.
11:05:17 <virl> oh .. a standard .. you mean this ecma thingy
11:05:25 * crc does note that Mono on Linux uses less resources than Java does, though it still has a bigger hit than native apps
11:05:44 <arke> Aah, it took you 1 minute and 6 seconds to load up wikipedia, look for c sharp, and write a witty reply. 
11:05:58 <virl> crc, yeah it's faster than java. but that's not a reason why I should like it.
11:06:01 <arke> crc: same on windows. .NET is quite a bit speedier than Java.
11:06:22 <crc> arke: I almost never use windows now
11:06:26 <arke> virl: I'm not saying you should love it, I'm just saying you shouldn't conduct a crusade against it. 
11:06:28 * PoppaVic is talking f2f - brb
11:06:32 <arke> crc: I exclusively use Windows now :)
11:06:43 <arke> crc: but that has several reasons.
11:06:56 <virl> it's from MS and this company hasn't made anything good in it's history. everything was stolen from others and then they tend to build backdoors, exploits and much more other shit.
11:07:03 <crc> I tolerate windows at work, but only after setting up mingw and cygwin
11:08:10 <arke> virl: "hasn't made anything good in its history"
11:08:19 <arke> virl: .NET :)
11:08:35 <virl> (haha)
11:08:38 <arke> And when did you last see slashdot announce a .NET backdoor or vulnerability?
11:08:47 <arke> I can't remember seeing one and I check slashdot daily.
11:09:04 <PoppaVic> arke: I can't condone a single M$ program - at all.
11:09:16 <Quartus__> it's a rubber-room vm.
11:09:29 <PoppaVic> meanwhile, .NET is still forthish/lisp predicated - 20 years late
11:09:44 <arke> I won't claim they're pefect, because they'renot. They've done and still do a bunch of things I don't like.
11:09:56 <arke> But .NET and C# they did right.
11:10:01 <PoppaVic> nope
11:10:13 <PoppaVic> Someone else did - and WHY?
11:10:37 <virl> same old object system. 
11:10:48 <arke> Oh, I see what you're saying.
11:10:54 <PoppaVic> yeppers
11:10:56 <arke> I guess I can't argue with that point.
11:11:14 <arke> You mean the concepts, right?
11:11:19 <PoppaVic> sure
11:11:42 <PoppaVic> ANd, I hate to admit it, but forth spun off lisp
11:11:43 <arke> Ah.
11:11:52 <arke> Oh yes, definetely.
11:11:57 <arke> And C# spun off Java alot.
11:11:59 <arke> And C++.
11:12:00 <PoppaVic> and I HATE trying to read lisp
11:12:08 <arke> And .NET spun off the Java API
11:12:09 <arke> and the Windows API
11:12:11 <PoppaVic> So, again... "why?"
11:12:14 <arke> but you know what
11:12:26 <arke> they took those existing concepts, put them together, and made a streamlined system that works nicely.
11:12:26 <PoppaVic> or even more usefully: "how?"
11:12:33 <arke> At least in my opinion.
11:12:38 <arke> So I will give credit for that. :)
11:12:44 <arke> Yeah
11:13:04 <PoppaVic> arke: ok, and - here in #forth and over in ##C - I still ask "why? and how?"
11:13:17 <arke> ?
11:13:20 <arke> What do you mena?
11:13:43 <PoppaVic> folks do not often want to look at <it> or the why/how.
11:14:22 <PoppaVic> If forths have taught me anything, it's that it's ALL about "breakout"
11:14:43 <PoppaVic> and in neither channel does such a concept work well
11:15:19 <Quartus__> breakout is based on pong.
11:15:38 <PoppaVic> arke: remember - ##C'ers want to embrace libraries (good or bad) and #forth'ers want to bow to Chuck and "rewrite it over and over"
11:15:50 <PoppaVic> Quartus: yer soo damned cute
11:16:35 <virl> damned cute.. lol.. reminds me on babys, they are also so damned cute.
11:17:22 --- mode: ChanServ set +o arke
11:17:57 <Quartus__> you should refrain from sweepingly classifying whole communities of programmers according to your own provincial bigotries.
11:19:11 <PoppaVic> Quartus: yeah, I'm now a Province-Bigot - great - you can still blow me.
11:19:32 <arke> Or blow me instead, I'm the one with the @ in front of his name :P
11:20:37 <PoppaVic> I'm a whole lot of things, depending on topic, day, weather, emotion and whatnot: and I still don't talk the Q-shit.
11:21:07 * PoppaVic inserts the 2nd "Chess" Cd
11:25:28 <PoppaVic> I dunno', though - are "Babies cute" - OR - or "Babies are ute when held and handled by others?"
11:25:40 <PoppaVic> ute/cute
11:26:49 <PoppaVic> virl: it seems a lot like like playing grandparent/uncle/aunt - for short periods they are cute, then you spoil them nicely, and send them home ;-)
11:27:42 <PoppaVic> ..BOG forbid you need to "discipline" some other folks kid, though.
11:30:09 <PoppaVic> Anyway, arke - stay well, I think I'll just call it a Knight and take a snooze or watch the tube awhile.
11:30:38 <arke> Night :)
11:31:23 --- quit: PoppaVic ("Pulls the pin...")
11:33:10 --- quit: BrianB04 ()
11:46:34 --- join: Astrobe (n=fred@c-real.rouen-wireless.net) joined #forth
11:46:42 --- join: neceve (n=claudiu@unaffiliated/neceve) joined #forth
12:06:27 --- join: snoopy_1711 (i=snoopy_1@dslb-084-058-104-238.pools.arcor-ip.net) joined #forth
12:14:03 <Quiznos> bs
12:14:05 <Quiznos> oops
12:14:40 --- quit: Snoopy42 (Read error: 145 (Connection timed out))
12:14:55 --- nick: snoopy_1711 -> Snoopy42
12:15:48 <Astrobe> Did someone take a look at LSE64?
12:20:24 --- join: vatic (n=chatzill@pool-162-84-156-148.ny5030.east.verizon.net) joined #forth
13:08:00 <Quartus> Is that Doty's pet system?
13:08:09 <Astrobe> yes.
13:09:11 <Quartus> I glanced at the documentation.  It appears to be a hastily-coded weekend Forth built for some specific purpose.
13:11:20 <Quartus__> which is fine, but I don't see it turning the world on with its smile, or anything like that.
13:12:07 <Astrobe> Doty made it clear it was "user-oriented", hence the strange look.
13:12:19 <Quartus__> I've forgotten, does it have anything like create/does?
13:14:57 <Astrobe> I don't find it nor something similar
13:15:06 <Quartus> The absence of create/does> is usually a sign that the system was built by somebody who didn't know Forth, as it's one of the slightly trickier bits.
13:16:37 <Astrobe> I think it pruned it because it's users, who are physicians, don't need it. It seems that they use it very much like a scripting language
13:17:28 <Quartus> Yes, I suppose you could chartiably assume the implementor was a Forth master who decided to remove things his users didn't need. 
13:21:51 <Quartus> The 'always compiling' choice, and the absence of create/does>, along with a few other missing items, suggests to me a Forth novice who decided to implement before learning the language, and thus didn't build any of the more sophisticated stuff.
13:23:16 <Astrobe> He is also a physician in the first place; but he wrote something complex enough already to assume he has the skills to do something like create/does
13:24:04 <Astrobe> And IIRC he ported an existing system made by someone else.
13:24:25 <Astrobe> No, I think he did choose to do it that way
13:24:34 <Quartus__> in fact there are a great many partial and hobby forths at least that complex; they're not that hard to write, at least up to a point.
13:24:50 <Astrobe> Esp. the "compile always" thing, which is IMO the most interesting part
13:28:45 <Astrobe> But he doesn't claim it is "newForth", except perhaps for the above-mentionned feature, in some way.
13:58:04 --- join: saon|work (n=saon@adsl-074-247-197-253.sip.jax.bellsouth.net) joined #forth
14:12:08 --- quit: Astrobe ("leaving")
14:20:35 --- quit: saon|work ("Leaving")
15:27:33 --- quit: Cheery ("Download Gaim: http://gaim.sourceforge.net/")
15:53:52 --- quit: vatic ("*poof*")
16:13:17 --- quit: virl (Remote closed the connection)
16:28:54 --- join: Jim7J1AJH (n=jim@221x115x224x2.ap221.ftth.ucom.ne.jp) joined #forth
16:29:04 --- join: erider (n=erider@unaffiliated/erider) joined #forth
16:29:10 <erider> hi all 
16:43:32 <Quartus> hi
16:47:27 --- join: zpg (n=user@user-544481c1.lns5-c10.dsl.pol.co.uk) joined #forth
16:58:53 <Quartus> hi zpg
17:04:45 <erider> hi Quartus
17:06:10 <zpg> hi Quartus
17:08:52 --- quit: madgarden (Read error: 131 (Connection reset by peer))
17:17:10 --- quit: neceve (Read error: 131 (Connection reset by peer))
17:22:07 <zpg> Quartus: I was going to ask you earlier -- will the eval. of your Palm system allow me to write pretty much everything in the Brodie books?
17:22:24 <zpg> (I managed to get the entire of Starting Forth with images etc., onto my Palm, which was neat.)
17:29:41 --- quit: Jim7J1AJH ("leaving")
17:31:43 <Quartus__> it should do, zpg. From the revised version, anyway.
17:32:02 <zpg> cool.
17:32:30 <zpg> Hands have been hurting and tinkering on the Palm is a nice way to go about Forth. Unfortunately, I can't afford the license at present though.
17:33:10 <zpg> I wrote a simple cubed function, then a ^6 word which called cubed cubed.
17:34:02 <zpg> The latter overran the signed single int boundary. Couldn't quite workout m* since the stack had 7 7 7 on it after dup dup, and m* wants two singles, but once we've called it on the two top 7's, the stack then contains a signed and a double.
18:06:44 <Quartus> Yeah, m* would be the wrong choice.  m*/ would work.
18:09:05 <zpg> using one as the divisor?
18:09:09 <Quartus> Right.
18:09:32 <Quartus> If you want your word to take a single-cell, and return it as a cubed double-cell value.
18:09:51 <zpg> yes. trying now
18:12:10 <Quartus> I guess a 16-bit version would work for up to 40 cubed.
18:12:24 <Quartus> Unsigned.
18:13:54 <zpg> yes, the problem is with  7 ^6
18:15:38 <Quartus> cubed cubed is ^9, not ^6, isn't it?
18:16:08 <zpg> oops, sorry - a typo on my part.
18:16:27 <zpg> that's 2am for you i guess.
18:22:01 --- join: TheBlueWizard (i=TheBlueW@ts001d0942.wdc-dc.xod.concentric.net) joined #forth
18:22:28 <zpg> that worked nicely for cubed, but now ^9 need reworking since we have a double, not single, on the stack :) 
18:22:55 <Quartus> right, simplest would be to make cubed take and return a double-cell
18:23:23 --- join: Jim7J1AJH (n=jim@221x115x224x2.ap221.ftth.ucom.ne.jp) joined #forth
18:23:31 <zpg> yep indeed. double only.
18:23:46 <zpg> but makes calling it a bit ugly. would i have to do    7 0 cubed?
18:23:52 <Quartus> 7. cubed
18:23:56 <zpg> nice
18:24:07 <zpg> obviously some manual reading is in order. but this is nice to know.
18:24:33 <jcwren> !
18:24:37 <jcwren> Read the manual?
18:24:38 <jcwren> Are you nuts?
18:26:12 <zpg> completely.
18:26:30 <Quartus> You'll only be able to represent 11^9 in a 32-bit integer, though.
18:26:32 <zpg> i can't see a multiplcation word that takes two doubles, returning a double. only unsigned stuff, mixed-length and singles.
18:26:52 <Quartus> It hardly matters for ^9 -- as I say, you can get up to 11.
18:26:53 <zpg> this is brodie, chapter 7
18:27:02 <zpg> Quartus: yeah indeed. this is a simple test.
18:27:19 <Quartus> There is no built-in double*double word.  Not hard to build one, though.  Good exercise, actually.
18:27:31 <zpg> is there a reason for no builtin?
18:27:44 <jcwren> The Palm uses 16 bit cells, I take it?
18:27:48 <Quartus> It'd ideally be a double*double -> triple, and on it goes.
18:27:52 <Quartus> Yes, it's a 16-bit Forth.
18:28:54 <Quartus> You don't need double*double for either cubed or ^9, though, not for a double-cell result that doesn't overflow.
18:29:33 <zpg> but if i take a double-cell for cubed, and i then use 2dup ....
18:29:47 <Quartus> Don't.  Take the lower part.
18:30:01 <Quartus> over, instead of 2dup.
18:30:55 <zpg> hmm ok, so use mixed multiplication ... i see.
18:30:57 <zpg> trying...
18:31:44 <Quartus> Your max for unsigned cubed is 1625, the max for cubed cubed is 11.
18:32:05 <Quartus> If you need greater range, there's floating-point.
18:32:13 <zpg> ok
18:32:39 <Quartus> Or you could build triple/quadruple/quintuple/sextuple/septuple multipy routines, if that works for ya. :)
18:32:56 <Quartus> Or go full-out and write a multiprecision math library.
18:33:25 <Quartus> I ported Zettel's for a calculator app (SCX) where I wanted extended precision.
18:34:20 <zpg> btw - why no double*double by default? because it would have to push a triple which is an ugly builtin?
18:34:37 --- join: crest_ (n=crest@p54895D5C.dip.t-dialin.net) joined #forth
18:34:47 <Quartus> In fact m*/ does produce a triple-cell intermediate result.
18:35:14 <zpg> ok, do why no d* ?
18:35:16 <zpg> *so
18:36:09 <Quartus> D* wasn't in common use at the time of the Standard.  I daresay that hasn't changed.  You'd need a bunch of additional triple-cell words; if you were working with huge integers, you'd want a proper set of bignum routines.
18:36:39 <zpg> ok, interesting
18:36:54 <zpg> for some reason, this is my first test example on the palm heh
18:36:57 <Quartus> It really isn't hard to write UD*. You should give it a shot.
18:37:10 <zpg> shall do soon.
18:37:24 <zpg> still having grafitti woes at the moment :)
18:37:35 <Quartus> heh. Practice.  Write large symbols.
18:38:07 <zpg> do you write straight onto the palm?
18:38:32 <Quartus> Usually.  I have one of the IR keyboards that I use if it's actual writing I'm doing -- English text instead of Forth.
18:38:51 <zpg> yeah, i might buy one, was ebaying this evening
18:38:59 <Quartus> Two things beginners at graffiti do -- write too small, and write at an angle.  
18:39:14 <zpg> yes, i was reasonable at it but time has erased all dexterity.
18:41:47 <zpg> i'm busy baffling myself with rotating and dup now
18:42:19 --- quit: Crest (Read error: 110 (Connection timed out))
18:42:38 <Quartus> Shouldn't need rot for cubed.
18:45:23 <zpg> yeah this is a mess.
18:45:49 <Quartus> Would you like to see  cubed ( d1 -- d2 ) ?  Sometimes it's easier to study than to create.
18:46:04 <zpg> yes
18:46:06 <zpg> please.
18:46:11 <Quartus> : cubed ( d1 -- d2 )  over dup * 1 m*/ ;
18:46:28 <Quartus> Then ^9 is  : ^9  cubed cubed ;
18:46:30 <zpg> oh that makes much more sense.
18:46:38 <zpg> yeah the ^9 definition is identical to mine, unsurprisingly.
18:47:03 <Quartus> Then      7. cubed d. -> 343       7. ^9 d. -> 40353607
18:47:30 <zpg> cubed  was getting messy though, i was calling m*/ for both, but trying to go from [7 0] to [7 0 7] (with over) to [7 0 7 7] to [7 7 0 7] then ... oh just thinking ti through illustrates that it's still a mess.
18:47:41 <zpg> didn't know about 'd.' either, that's useful.
18:48:22 <zpg> for some reason, it didn't occur to me to deal with the singles with a simple *
18:49:53 <zpg> with regard to this function, i guess my first impressions are 'geez, no room for casting' -- i have to explicitly call a double a double. so used to lazy initialisation and dynamic typing.
18:50:39 <zpg> but again, your code indicates that most my problems don't lie in the language, rather the understanding of the stack.
18:50:51 <Quartus> heh. Well -- what's the context?  If you wanted cubed as part of a larger library of math words, you'd have them all operate on the same data type, be it float, double, or multi-precision.  If you are using it in a specific app for a specific reason, specifying the type in the operator isn't an issue.
18:51:40 <zpg> I guess so. Just paradigms I guess. I tend not to think about this stuff in Lisp, etc. Perhaps that's a 32-bit deal too.
18:51:56 <Quartus> Sure.  You will bump into the integer ceiling more often in a 16-bit Forth.
18:52:11 <zpg> Indeed.
18:52:30 <zpg> But I really like writing on the Palm (good work btw, not that I can fully appreciate it yet.)
18:52:32 <Quartus> Not all that often, but more often.  The only occasion that I remember bumping into it was when writing date conversion routines that had to work over a range of two thousand years.
18:52:47 <Quartus> thanks. Yes, it's great fun to write code on the Palm.
18:52:52 <zpg> My only qualm is switching applications, especially between Quartus and Memo.
18:53:03 <Quartus> Do you have an OS5 device? Or is this a Palm V?
18:53:08 <zpg> an old m130
18:53:15 <Quartus> I've forgotten if that's OS5 or OS4.
18:53:22 <zpg> got it for Frobnitz (IF).
18:53:23 <zpg> OS4
18:53:29 <Quartus> Ok. So get HackMaster, and SwitchHack.
18:53:31 <Quartus> Both are free.
18:53:51 <Quartus> Then one pen stroke takes you back and forth between the last two apps.
18:54:19 <zpg> switchhack, great. i've got switcheroo but it does nothing for me.
18:54:22 --- join: Anbidian (i=anbidian@S0106000fb09cff56.ed.shawcable.net) joined #forth
18:54:30 <zpg> (i.e., doesn't feel intuitive, which is my only gauge in these things.)
18:54:47 <Quartus> SwitchHack is what I used under OS4.  Switch5 is the OS5 equivalent.  Very handy.
18:55:19 <zpg> thanks for the tip, much appreciated.
18:55:50 <zpg> btw - does Quartus (btw, using the product name while it's simultaneously highlighted as your nick is a tad confusing!) provide a decent income?
18:56:09 <Quartus> Depends on what you mean by decent. :) It's not the only iron I keep in the fire.
18:56:52 <zpg> do you do consultancy work then?
18:57:12 <Quartus> I do, and various other projects.
18:57:30 <TheBlueWizard> gotta go...bye all
18:57:32 <zpg> Palm related, or general?
18:57:52 <Quartus> Both; different projects at different times.
18:58:06 --- part: TheBlueWizard left #forth
18:58:22 * zpg nods
18:58:37 <zpg> ok switchHack now installed, let's check it out
19:00:11 <zpg> oh, nice!
19:02:14 <zpg> and i just re-wrote cubed which of course works well.
19:03:18 <zpg> unfortunately, i can't seem to select stuff in Q. that I've already evaluated.
19:05:42 <zpg> (7 ^9 seems to wreak havok though)
19:07:31 <zpg> and while i'm being inquisitive -- is there a way to maintain/persist a Quartus session, since switching to memo and back means i have to paste in 'include a' again? 
19:13:06 <Quartus> zpg, it comes up clean each time.  If you create a startup.quartus memo, you can re-include from there automatically.
19:13:26 <Quartus> I define i as a shortcut for "include ", helps.
19:13:42 <zpg> yes, good idea. thanks.
19:14:07 <Quartus> Alternatively in startup.quartus:     : L include ;
19:14:09 <zpg> also, re: your list code -- i guess one could write something like l+ which calls list-length (which we write of course). this would check the length of the list then add the elements together.
19:14:11 <Quartus> then   l <filename>
19:14:34 <zpg> ok, doing that now.
19:14:44 <Quartus> zpg, you could, yes, produce a whole raft of list operators.  
19:15:22 <Quartus> To sum a list, I'd just cdr down the list adding the elements together; wouldn't need a length function.
19:17:50 <zpg> surely you could write a list-length to do that, just for convenience.
19:17:59 <Quartus> I'm not sure how it would help. You'd wind up walking the list twice.
19:18:03 <zpg> so you could then write l+ to take a list, check it's length, etc.
19:18:22 <Quartus> You have to walk a list to determine its length. You have to walk a list to sum it, too.
19:18:49 <erider> recursively 
19:19:06 <Quartus> No recursion is required to sum a list, or to determine its length.
19:20:13 <zpg> yeah you don't want to recurse. we're simply calculating the number of elements here.
19:20:39 <zpg> Quartus: oh i see why twice, once for the length, once for the actual values to sum. good point.
19:20:50 <zpg> so you could calculate the length as you push the numbers onto the stack.
19:21:02 <zpg> then loop with the approriate number of +
19:21:14 <Quartus> You could, though that'd be a strange and complicated way to do it.
19:21:26 <zpg> i'm just thinking of lisp's (+ 1 2 3 4 5)
19:21:42 <zpg> as l+ in forth, given that the top of the stack is our list.
19:21:47 <Quartus> Absolutely no reason not to sum the values as they're encountered; when you're at the end of the list, you're done.
19:21:53 <zpg> oh of course.
19:21:55 <zpg> d'uh
19:22:18 <zpg> sorry for the idiocy, i've clearly not got this stack business past the 'Can you say, "stack", stage' 
19:22:51 <Quartus> Commonly beginners think the stack has to be used for everything, temporary storage, data storage, dry cleaning, unwanted wedding gifts. :)
19:23:01 <zpg> heh heh
19:23:18 <zpg> i really appreciate your help by the way.
19:23:37 <Quartus> On some Forths, the data stack is quite shallow; it's unusual and probably always a bad idea to use it for storing lots of stuff.
19:23:41 <Quartus> Sure, no problem.
19:24:39 <zpg> with your example, would you put 0 on the stack before you start walking along the list?
19:24:47 <zpg> so that the very first element can be summed cleanly.
19:24:54 <Quartus> Yes.
19:24:55 <zpg> *added
19:25:00 <zpg> nice.
19:26:52 --- join: I440r (n=mark4__@12.197.217.242) joined #forth
19:29:23 <zpg> incidentally, i'm intrigued by the alias we made  --> : l include ;
19:29:38 <zpg> the immediacy of include remains even though this is a straightforward word definition.
19:31:52 <Quartus> immediacy?
19:32:03 <zpg> well, include is an immediate word, right?
19:32:35 <Quartus> Shouldn't be.
19:32:47 <zpg> include <something> rather than, perhaps, s" <something>" include.
19:33:03 <Quartus> No. Hang on.
19:33:04 <crc> that is parsing, not immediacy
19:33:09 <zpg> oh ok
19:33:13 <zpg> a special condition?
19:33:28 <Quartus> include is not an immediate word.
19:33:36 * zpg nods
19:33:43 <Quartus> Neither is INCLUDED, which is a standard word.
19:33:58 <Quartus> include is effectively : include parse-word included ;
19:34:09 <Quartus> : L include ;  does no more than alias L to include.
19:34:16 <Quartus> ' include alias L  would do the same.
19:34:42 <zpg> but if i were to write 'parse-word' (to push to the stack), forth would throw an error
19:34:51 <Quartus> I don't understand.
19:35:01 <zpg> the definition of include you provide is
19:35:07 <zpg> : include parse-word included ;
19:35:10 <Quartus> Yes.
19:35:12 <zpg> but if i wrote 
19:35:21 <zpg> parse-word my-new-function-word
19:35:32 <zpg> parse-word would be looked up in the dictionary, and not found.
19:35:40 <zpg> say i'm doing --> include myfile
19:35:42 <zpg> if i typed
19:35:42 <Quartus> parse-word will be found; it's in the dictionary.
19:35:51 <zpg> oh god ok
19:35:57 <zpg> so parse-word is just any token?
19:36:02 <Quartus> parse-word is the name of a word.
19:36:13 <Quartus> It's a function in the Quartus Forth dictionary.
19:36:21 <zpg> hmm
19:36:27 <zpg> so i can say
19:36:28 <Quartus> parse-word myfile included     would also work, though it's a fairly daft thing to do.
19:36:36 <zpg> 'myfile parse-word included' then?
19:36:55 <Quartus> no, because myfile isn't a word in the dictionary.  It needs to be parsed into a string for included to use, and that's what parse-word does.
19:37:10 <zpg> oh i see, i'm getting things all topsy turvy
19:37:27 <Quartus> It's likely that it's simpler than you imagine it to be.
19:37:34 <zpg> yes
19:37:37 <zpg> but i'm thinking
19:37:50 <jcwren> DANGER WILL ROBINSON!
19:37:55 <Quartus> That's a common beginner issue.  They're used to complex environments and so struggle to try to fit simple things into a more complex pattern.
19:38:26 <zpg> : include parse-word included ; ==> my typing 'include abc' would be the same, therefore as 'parse-word included abc' 
19:38:32 <Quartus> Yes.
19:38:38 <Quartus> no, sorry. I didn't read it.
19:38:43 <Quartus> parse-word abc included
19:38:48 <zpg> indeed, i noticed you example
19:38:56 <zpg> so how come it's not a straightforward situation
19:39:18 <Quartus> It is.  : include parse-word included ;    when you type include abc,  first parse-word runs, and parses abc; then included runs.
19:39:24 <zpg> i mean, if i write cubed as we discussed above, i can imagine instead of typing '7. cubed', typing '7. over dup * 1 m*/'
19:39:46 <zpg> ok, so how come parse-word skips over included?
19:40:12 <Quartus> included is part of the include definition.  It's not in the input-buffer when include is run.
19:40:27 <jcwren> Perhaps he is not clear on the compiling vs interpeting modes.
19:40:54 <zpg> jcwren: not clear at all :)
19:40:56 <Quartus> It's not a compiling vs. interpreting issue, really.  
19:41:03 <jcwren> Yes, it is.
19:41:19 <jcwren> : include parse-word included ; "skips" over included, from his point of view, because it's compiling.
19:41:23 <jcwren> That needs to be explained.
19:41:28 <zpg> i'm simply thinking, if that's the word definition ': include parse-word included ;', then like with cubed, i could feasibly just write 'parse-word included myfile' at the prompt.
19:41:37 <Quartus> Try it. What happens?
19:42:13 <zpg> undefined word
19:42:18 <zpg> (for a)
19:42:19 <Quartus> parse-word is not an undefined word.
19:42:26 <Quartus> Check your spelling.
19:42:44 <zpg> i wrote, 'parse-word included a'
19:42:49 <zpg> and get
19:42:53 <zpg> a? undefined word (-13)
19:42:58 <Quartus> oh right.  Yes, that's what you should be getting.
19:43:01 <Quartus> Sorry.
19:43:01 <zpg> note i'm not typing included parse-word a
19:43:09 <Quartus> No, that would fail differently, as it's also wrong.
19:43:33 <zpg> erm
19:43:37 <zpg> yes sorry
19:43:56 <zpg> i mean 'parse-word a included'
19:44:02 <Quartus> Right, that'll work.
19:44:05 <zpg> sure
19:44:28 <zpg> but my point is, if i write the cubed definition, i could also just write its contents following my operand.
19:44:34 <Quartus> Following?
19:44:40 <zpg> the:
19:44:53 <Quartus> Perhaps if you speak in code, I'll understand you better.
19:44:57 <zpg> '7. cubed' being the same as '7. over dup * 1 m*/'
19:45:04 <Quartus> So, preceding.
19:45:30 <zpg> ok, sorry, speaking lispspeak still i guess.
19:45:37 <Quartus> Likewise s" a" included is one way to pass a literal string to included.  So is parse-word a included
19:45:38 <zpg> so,
19:45:43 <zpg> '7. cubed' being the same as '7. over dup * 1 m*/'
19:45:44 <zpg> but
19:45:52 <zpg> i can't take the body of the include definition
19:46:09 <Quartus> No, you can't, because parse-word doesn't take its input from the stack.  It takes it from the input buffer.
19:46:12 <zpg> and then type the same logical order --> if 'include a' then, logically, 'parse-word included a'
19:46:24 <crc> not quite
19:46:27 <zpg> oh i see
19:46:36 <Quartus> In fact logic would dictate     :noname  parse-word included ; execute a
19:47:03 <zpg> now i'm officially confused.
19:47:05 <Quartus> or, more simply,  parse-word a included, which is the equivalent sequence.
19:47:34 <zpg> yes but all that's tripping me is why the word definition doesn't deal with the filename to include
19:47:42 <Quartus> parse-word parses the next word from the input buffer.  If you type     include foo, the next word in the input-buffer is 'foo'.
19:47:46 <zpg> and you can, when calling this word (include) put the filename at the end of the line.
19:47:54 <zpg> ahhh
19:47:56 <zpg> there's the answer :)
19:48:20 <zpg> can you see why i was confused? i'm not sure whether i conveyed what i expected to be happening properly.
19:48:57 <Quartus> I think I understand why you're confused.  You are thinking the stack is the only source and destination for data for a given word.
19:49:06 <zpg> essentially, yes.
19:49:16 <Quartus> The input-buffer is another source.
19:49:23 <zpg> ok, great, thanks for clearing that up.
19:49:26 <Quartus> Sure.
19:49:52 <zpg> I think if it weren't 3:50am, something would have twigged sooner, but so it goes.
19:50:23 <Quartus> :)
19:51:43 <Quartus> It's a bit like asking for input, without asking -- just takes the next word from the command line.  Consider the pseudocode : get-two-and-add  input-integer input-integer + . ;
19:52:02 <Quartus> Supposing input-integer to be a routine that asks the user to enter an integer.
19:52:34 <zpg> with you so far.
19:52:48 <zpg> oh i see your point
19:53:07 <Quartus> Likewise  : get-two-and-add  parse-word convert-to-integer parse-word convert-to-integer + . ;  (still pseudocode, but I hope you're following)
19:53:14 <zpg> yes i'm seeing Forth as all-stack so words that do things other ways were throwing me.
19:57:27 <zpg> well, i think running into these 'problems' early can only be a good thing
19:57:48 <Quartus> Yes, can't hurt. :)
19:57:54 <zpg> heh heh
19:57:59 --- part: Quartus left #forth
19:58:02 --- join: Quartus (n=trailer@CPE0001023f6e4f-CM013349902843.cpe.net.cable.rogers.com) joined #forth
19:58:02 --- mode: ChanServ set +o Quartus
19:58:07 <zpg> for now, i shall sleep on it, otherwise getting up will be impossible.
19:58:13 <Quartus> Yes, sleep is important.
19:58:45 <zpg> Indeed it is. Thanks again, night for now.
19:58:47 --- quit: zpg ("ERC Version 5.1.3 (IRC client for Emacs)")
19:59:09 --- join: timlarson (n=timlarso@user-12l325b.cable.mindspring.com) joined #forth
20:01:47 --- quit: Quartus ()
20:02:42 --- join: Quartus (n=trailer@CPE0001023f6e4f-CM013349902843.cpe.net.cable.rogers.com) joined #forth
20:02:42 --- mode: ChanServ set +o Quartus
20:03:56 --- quit: Anbidian (Connection timed out)
20:14:35 --- quit: I440r (Read error: 110 (Connection timed out))
20:59:21 --- quit: erider ("I don't sleep because sleep is the cousin of death!")
21:23:45 --- join: slava (n=slava@CPE0080ad77a020-CM000e5cdfda14.cpe.net.cable.rogers.com) joined #forth
21:23:46 --- mode: ChanServ set +o slava
22:15:16 --- quit: slava ()
22:31:45 --- join: snowrichard (n=richard@12.18.108.162) joined #forth
22:31:58 <snowrichard> hi
22:53:37 --- quit: snowrichard ("Leaving")
23:58:10 --- join: arke_ (n=Chris@pD9E05E57.dip.t-dialin.net) joined #forth
23:59:59 --- log: ended forth/06.10.01