00:00:00 --- log: started forth/18.11.08
00:11:28 --- join: wa5qjh (~quassel@175.158.225.200) joined #forth
00:11:28 --- quit: wa5qjh (Changing host)
00:11:28 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
00:20:50 --- join: proteusguy (~proteus-g@110.164.126.166) joined #forth
00:20:50 --- mode: ChanServ set +v proteusguy
00:32:58 --- join: dave0 (~dave@47.44-27-211.dynamic.dsl.syd.iprimus.net.au) joined #forth
00:45:19 --- quit: pierpal (Quit: Poof)
01:01:45 --- quit: nighty- (Quit: Disappears in a puff of smoke)
01:25:57 --- join: john_cephalopoda (~john@unaffiliated/john-cephalopoda/x-6407167) joined #forth
01:33:56 --- join: nighty- (~nighty@s229123.ppp.asahi-net.or.jp) joined #forth
01:34:00 --- quit: ncv (Remote host closed the connection)
01:34:22 --- join: ncv (~neceve@2a02:c7d:c5c9:a900:6eaf:6ef7:3b81:d5f6) joined #forth
01:34:22 --- quit: ncv (Changing host)
01:34:22 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
02:02:57 --- quit: ashirase (Ping timeout: 268 seconds)
02:10:32 --- join: ashirase (~ashirase@modemcable098.166-22-96.mc.videotron.ca) joined #forth
02:27:14 --- quit: john_cephalopoda (Quit: Trees can see into your soul. They lurk everywhere.)
02:44:09 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
03:01:35 <pointfree> johnnymacs: That sounds really nifty.
03:01:35 <pointfree> When I gave a talk about paper & pencil electronics, Sam Falvo said you can make a membrane keyboard by punching holes in paper with a hole-puncher and sandwiching that between two pieces of paper with electrical contacts.
03:01:35 <pointfree> http://www.0xff.in/bin/SVFIG-Aug25-2018-AndreasWagner-paper-and-pencil-electronics.pdf
03:04:12 --- join: john_cephalopoda (~john@unaffiliated/john-cephalopoda/x-6407167) joined #forth
03:07:09 <pointfree> I'm currently exploring inkjet printing oled displays https://www.youtube.com/watch?v=ZesXSJ0inBg
03:16:23 <john_cephalopoda> Hmm, I wonder if the inkjet printer gets along with the inks needed for that..
03:20:06 <pointfree> john_cephalopoda: It's best to buy empty cartridges instead of trying to clean them.
03:22:56 --- quit: proteusguy (Remote host closed the connection)
03:23:08 <john_cephalopoda> pointfree: Inkjets shoot ink out of heated channels. I'd imagine that the consistency of the ink is quite important for it to work properly.
03:23:31 <pointfree> regarding the paper calculator, one can also inkjet print organic transistors. The problem now is that they have a shelf life of only ~1yr.
03:26:00 <pointfree> john_cephalopoda: Most people are buying piezoelectric inkjet printers for this, but thermal inkjets work almost as well.
03:28:01 <WilhelmVonWeiner> does Chuck post anything anywhere anymore?
03:28:21 <pointfree> "Inkjet and Screen Printed Electrochemical Organic Electronics" http://www.diva-portal.org/smash/get/diva2:22986/FULLTEXT01.pdf
03:29:16 <pointfree> WilhelmVonWeiner: He doesn't do social media anymore, but he'll be at Forth Day.
03:29:38 <WilhelmVonWeiner> I missed EuroForth 2018 :(
03:30:09 <WilhelmVonWeiner> At least, I think that was in september.
03:51:00 <WilhelmVonWeiner> "What Forth needs now is a scalpel and a big bottle of hydrogen-peroxide. The scalpel is to remove the ugly warts, which are ANS-Forth and Forth-200x." LOL
03:51:03 <WilhelmVonWeiner> LOL LOL LOL
03:51:21 <WilhelmVonWeiner> I never realised CLF was this savage
03:59:36 <rdrop-exit> I must have missed that one. LOL
04:02:36 --- nick: xek__ -> xek
04:05:31 <WilhelmVonWeiner> I think he has a point. Either we need a Forth standard - or a standard Forth
04:06:07 <WilhelmVonWeiner> I mean 200x is huge
04:06:22 <WilhelmVonWeiner> and people thought F83 was bad
04:07:04 --- join: pierpal (~pierpal@host210-193-dynamic.245-95-r.retail.telecomitalia.it) joined #forth
04:08:29 <rdrop-exit> I don't think Forth is suited to traditional language standardization efforts.
04:10:02 --- quit: wa5qjh (Quit: http://quassel-irc.org - Chat comfortably. Anywhere.)
04:10:11 <siraben> Then again Lisps could be considered not to be as well.
04:10:28 <WilhelmVonWeiner> Yeah, I suppose. 
04:10:32 <siraben> There should be some sort of standard for the base words, I think. 
04:10:41 <siraben> And ways to extend the language's syntax.
04:11:21 <siraben> ^Forth should adopt some sort of system like Scheme's SRFI (Scheme Requests For Implementation) for people to propose optional extensions to a language.
04:11:25 <siraben> the language*
04:12:02 <rdrop-exit> I've never considered Forth to be a computer language in the traditional sense.
04:12:34 <WilhelmVonWeiner> If Lisp is a computer langauge, so is Forth
04:12:38 <WilhelmVonWeiner> and Lisp definitely is
04:12:54 <WilhelmVonWeiner> Forth assumes an underlying dual-stack model after all, or at least emulates one
04:12:56 <rdrop-exit> If you say so
04:13:51 <siraben> Definitely not in the "traditional sense".  Lisps has macros, Forth has compile-time/run-time hooks which are like macros but more fundamental.
04:15:01 <rdrop-exit> The best way to standardize Forth is to standardize a virtual processor, preferably one for each common word-width.
04:15:04 <pointfree> I use forth as more of a spontaneous user interface and operating system.
04:15:07 <pointfree> To me, the word "program" implies non-interactive and largely predetermined.
04:15:33 <siraben> I think a VM model would be good.  Pin down the semantics of words like NEXT
04:16:57 <rdrop-exit> Forth is all about semantics, not syntax parsing rules.
04:19:34 <pointfree> I'm fine with a standard core wordset implemented as an optional library on a non-standard forth. A compatibility layer, but not so procrustean to everything else.
04:20:15 <WilhelmVonWeiner> I think CORE and CORE-EXT mostly make sense 
04:20:21 <WilhelmVonWeiner> some cruft could be sliced clean out
04:26:57 <rdrop-exit> A proper Forth never hides the underlying machine (whether that machine is a real one or a virtual one.
04:27:07 <pointfree> I'd be in favor of a forth package manager negotiating a minimal surface-area standard algebraically.
04:27:24 <pointfree> Dependency conflicts are not a problem with hyperstatic scope -- a Nix package manager for free. The problem is compacting the dictionary in such a package management scheme.
04:33:44 <rdrop-exit> Wow, that escalated quickly :)
04:42:21 <john_cephalopoda> I like ANS Forth a lot. It offers a good mechanism to add extensions.
04:42:55 <john_cephalopoda> S" CORE" ENVIRONMENT? .
04:43:09 <john_cephalopoda> That tells you if CORE is available in the FORTH you are using.
04:44:43 <john_cephalopoda> You can simply check if the features you need are available and extensions could hook into ENVIRONMENT? 
04:53:05 <WilhelmVonWeiner> or you add a line in the README/header of your program
04:53:10 <WilhelmVonWeiner> "Requires CORE"
04:54:13 <WilhelmVonWeiner> make ANS forths include a vocabulary ANS-CORE, ANS-CORE-EXT etc
04:56:43 <WilhelmVonWeiner> FIG-Forth with some kind of TRY CATCH THROW 
04:57:40 <WilhelmVonWeiner> Is that a word? TRY? Tries the next word in the input stream and returns TRUE or FALSE depending on the success of the subsequent word?
04:59:04 <john_cephalopoda> Hmm, gforth doesn't seem to accept "Requires CORE"
04:59:54 <WilhelmVonWeiner> well, REQUIRES requires a source file
04:59:57 <rdrop-exit> 3.2.7 Obsolescent Environmental Queries
05:00:00 <rdrop-exit> This standard designates the practice of using ENVIRONMENT? to inquire whether a given word set is present as obsolescent. If such a query, as listed in table 3.6, returns true, the word set is present in the form defined by Forth 94. As these queries will be withdrawn from future revisions of the standard their use in new programs is discouraged.
05:01:10 <john_cephalopoda> Huh
05:01:21 <john_cephalopoda> Environmental queries sound like a useful thing.
05:01:45 <john_cephalopoda> How else can I find out if the words I am using are supported?
05:01:45 <rdrop-exit> A.3.2.7 Obsolescent Environmental Queries
05:01:49 <rdrop-exit> When reviewing the Forth 94 Standard, the question of adapting the word set queries had to be addressed. Despite the recommendation in Forth 94, word set queries have not been supported in a meaningful way by many systems. Consequently, these queries are not used by many programmers. The committee was unwilling to exacerbate the problem by introducing additional queries for the revised word sets. The 
05:01:55 <rdrop-exit> committee has therefore declared the word set environment queries (see table 3.6) as obsolescent with the intention of removing them altogether in the next revision. They are retained in this standard to support existing Forth 94 programs. New programs should not use them.
05:02:34 <WilhelmVonWeiner> So what, you should just cross your fingers and hope all of ANS is included?
05:02:47 <WilhelmVonWeiner> 200x, even
05:02:49 <KipIngram> You can FIND the word; that returns a flag.  Doesn't tell you what the word does, but it does tell you if there's a dictionary entry there.
05:02:58 <WilhelmVonWeiner> KipIngram: good point
05:03:12 --- quit: john_cephalopoda (Quit: Trees can see into your soul. They lurk everywhere.)
05:04:01 <KipIngram> I assume the interest in this is driven by portability considerations.  I've just never done much programming that made me too interested in portability.
05:08:06 <WilhelmVonWeiner> well, portability between Forth distributions would be nice
05:08:11 <rdrop-exit> If portability were a priority on a project, I would implement a portable VM.
05:08:29 <WilhelmVonWeiner> I'd use Retro Forth
05:10:04 <rdrop-exit> I doubt very much I'd ever rely on ANS Forth for any portability requirements.
05:10:20 <rdrop-exit> Too many gotchas
05:11:40 <WilhelmVonWeiner> Too much specificity
05:13:04 <KipIngram> I never felt like portability was a concern of Chuck's either.
05:14:59 <rdrop-exit> I don't think Chuck's ever shied away from rewriting his Forth to suit a new project.
05:15:51 <rdrop-exit> I can just imagine his eyes glazing over at some of the EuroForth talks.
05:17:01 <WilhelmVonWeiner> You have to admit though, there is a disalignment between our reality and chuck's reality
05:17:31 <WilhelmVonWeiner> he's not working on top of 30 million likes of abstraction, he writes to the chip's ROM
05:18:51 <rdrop-exit> I'd say there's a misalignment between those who principally use Forth as a desktop language and those who don't.
05:19:21 <WilhelmVonWeiner> I think Forth is suited to either
05:19:42 <rdrop-exit> Not using the same standard.
05:20:56 <WilhelmVonWeiner> I wouldn't want a Forth standard on a micro anyhow
05:21:21 <WilhelmVonWeiner> I'd want to be provided with the minimum reasonable toolkit
05:25:15 <rdrop-exit> You'd think since the vendors are mostly selling Forth into the embedded market they would have geared standardization towards embedded project concerns.
05:28:30 --- join: john_cephalopoda (~john@unaffiliated/john-cephalopoda/x-6407167) joined #forth
05:31:45 <rdrop-exit> SWMBO just arrived, gotta go. Chat again soon.
05:31:52 --- quit: rdrop-exit (Quit: Lost terminal)
05:34:32 <KipIngram> WilhelmVonWeiner: I feel the same re: Forth for embedded.
05:35:06 <KipIngram> I'd want to be able to make every scrap of code directly relevant to my application - any "baggage" that was there to support having the code run on other platforms would be annoying to me.
05:41:53 <WilhelmVonWeiner> That's what cross-compilers are for, innit
05:47:46 --- quit: jedb (Quit: Leaving)
05:54:52 --- join: jed (~jed@199.66.90.113) joined #forth
05:55:15 --- quit: jed (Client Quit)
05:56:04 --- join: jed (~jed@199.66.90.113) joined #forth
05:56:17 --- quit: jed (Remote host closed the connection)
05:56:54 --- join: jedb (~jedb@199.66.90.113) joined #forth
05:58:22 <KipIngram> Seems right to me.
06:02:29 --- quit: reepca (*.net *.split)
06:02:29 --- quit: DKordic (*.net *.split)
06:02:30 --- quit: malyn (*.net *.split)
06:02:30 --- quit: Labu (*.net *.split)
06:02:30 --- quit: WilhelmVonWeiner (*.net *.split)
06:02:30 --- quit: jn__ (*.net *.split)
06:02:41 --- join: reepca (~user@208.89.170.250) joined #forth
06:02:57 --- join: WilhelmVonWeiner (dch@45.58.35.111) joined #forth
06:03:01 --- join: DKordic (~user@178.221.182.186) joined #forth
06:03:53 --- nick: WilhelmVonWeiner -> Guest66115
06:04:03 --- join: Labu (~Labu@labu.pck.nerim.net) joined #forth
06:05:52 --- join: malyn (~malyn@unaffiliated/malyn) joined #forth
06:12:41 --- join: jn__ (~nope@aftr-109-90-232-81.unity-media.net) joined #forth
06:14:32 --- quit: Guest66115 (Quit: leaving)
06:14:42 --- join: WilhelmV1nWeiner (dch@ny1.hashbang.sh) joined #forth
06:17:14 --- quit: WilhelmV1nWeiner (Client Quit)
06:17:23 --- join: WilhelmV1nWeiner (dch@ny1.hashbang.sh) joined #forth
06:20:53 --- nick: WilhelmV1nWeiner -> wilhelmvonweiner
06:20:57 --- quit: wilhelmvonweiner (Client Quit)
06:21:06 --- join: WilhelmVonWeiner (dch@ny1.hashbang.sh) joined #forth
06:21:31 --- nick: WilhelmVonWeiner -> Guest12370
06:23:44 <Guest12370> I HATE FIGHTING WITH FREENODE AND IRSSI
06:23:46 --- join: Keshl_ (~Purple@24.115.185.149.res-cmts.gld.ptd.net) joined #forth
06:23:53 --- part: Guest12370 left #forth
06:24:41 --- quit: Keshl (Read error: Connection reset by peer)
06:24:45 --- join: WilhelmVonWeiner (dch@ny1.hashbang.sh) joined #forth
06:24:54 <WilhelmVonWeiner> kill me, dear god
06:25:00 <zy]x[yz> what's the problem?
06:25:22 <WilhelmVonWeiner> sometimes my irssi will relog for no apparent reason
06:25:44 <WilhelmVonWeiner> and to regain my name I can't be muted in a channel
06:26:06 <WilhelmVonWeiner> and I don't know which channels have unregistered users muted and I don't care to learn
06:26:16 <WilhelmVonWeiner> and so I have to go through and leave the all to regain
06:26:22 <zy]x[yz> huh?  you just /msg nickserv ghost
06:26:36 <WilhelmVonWeiner> but then I /quit and relaunch irssi and freenode has me locked out me name again
06:26:55 <WilhelmVonWeiner> zy]x[yz: wasn't working, said user WilhelmVonWeiner wasn't online
06:27:05 <zy]x[yz> weird
06:27:17 <WilhelmVonWeiner> gonna switch it all out with suckless' ii probably
06:27:24 <WilhelmVonWeiner> sick of stuff breaking
06:27:36 <zy]x[yz> i never noticed you're a hashbang person until now
06:28:04 <WilhelmVonWeiner> I don't use the irc much ebcause i'm not great at remianing in social circles 
06:28:15 <WilhelmVonWeiner> but I appreciate the services
06:28:44 <zy]x[yz> yeah, first thing i did when i made a user there was to comment-out the autolaunch of weechat
06:32:40 <WilhelmVonWeiner> I ran `rm -rf * .*`
06:32:50 <WilhelmVonWeiner> and then rebuilt everything 
06:33:00 <zy]x[yz> haha, probably not a bad idea
06:33:13 <WilhelmVonWeiner> so for months I had an account but couldn't figure out how to get back into the irc
06:43:46 --- quit: WilhelmVonWeiner (Quit: leaving)
06:44:15 --- join: WilhelmVonWeiner (dch@ny1.hashbang.sh) joined #forth
06:45:55 <john_cephalopoda> Regarding embedded Forth and low-level stuff that is used to make it run on a specific platform: I would handle it by implementing most of Forth in Forth itself and only write the most important functions in a language like C or assembly. There would be an "arch" directory which would contain the architecture-dependent part.
06:46:31 <zy]x[yz> yup
06:47:22 <john_cephalopoda> That way one would only have to implement a few functions in the arch-dependent backend code and the rest of the system would be a nice, portable frontend.
06:49:13 <WilhelmVonWeiner> that's the usual way it's done
06:49:32 <WilhelmVonWeiner> the canonical way maybe, I can't verify it's the usual way.
06:51:02 <zy]x[yz> you can also import modules by looking through a defined series of paths like most languages do, with the arch-specific paths coming before the generic paths, so that way you have sort of an overlay where you can implement optimized versions of modules for specific architectures
06:51:58 <zy]x[yz> that's my master plan, if i can ever muster up the motivation to actually work on mine
06:53:04 <john_cephalopoda> A thing I like about forth is, that it doesn't care about implementation of the word. You could create a drawing command set for forth and offer various implementations (ASCII art, opengl bindings, vulkan bindings) and it would all work with the same word. You could just drop in a new implementation and it will run, without any crazy .so hell.
06:53:31 <zy]x[yz> i don't see how that's specific to forth
06:54:35 <zy]x[yz> as long as you stick to a defined abi, anything can work like that
06:54:59 <john_cephalopoda> Hmm, right.
06:55:26 <john_cephalopoda> It seems more intuitive with Forth though.
07:27:59 --- quit: dave0 (Quit: dave's not here)
07:45:52 --- quit: tabemann (Ping timeout: 260 seconds)
09:27:42 <WilhelmVonWeiner> Retro has a lot of really useful words using this concept called quotations
09:28:04 <WilhelmVonWeiner> sometimes I'm dying for a native implementation in something like gforth
09:28:35 <WilhelmVonWeiner> So you can enclose an anonymous function in square braces, `[ like so ]` and the xt goes on the stack
09:28:56 <WilhelmVonWeiner> there are words like `bi@` which apply that quotation to the top two stack items
09:37:14 <WilhelmVonWeiner> `[ @val + ] sip n:dec rot` vs `DUP DUP VAL @ + DUP 1- ROT`
09:37:23 <WilhelmVonWeiner> makes it so much more readable
09:40:31 --- quit: ncv (Ping timeout: 252 seconds)
09:41:08 --- join: ncv (~neceve@90.194.11.55) joined #forth
09:41:08 --- quit: ncv (Changing host)
09:41:08 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
09:41:16 <WilhelmVonWeiner> in fact I think I've used sip wrong there LOL
09:42:50 --- quit: ncv (Remote host closed the connection)
09:42:50 <WilhelmVonWeiner> you get my point though. Anonymous functions on the stack and words to utilise them = Good
09:44:34 --- join: ncv (~neceve@2a02:c7d:c5c9:a900:1ec6:932f:1b02:d27e) joined #forth
09:44:34 --- quit: ncv (Changing host)
09:44:34 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
10:23:34 <KipIngram> Maybe I just code a different way, but why is that better than giving the word a name and just using it?
10:27:08 <zy]x[yz> i find it useful for passing things off to higher-order words
10:27:18 <zy]x[yz> like a sort function that takes a comporator, for example
10:27:57 <KipIngram> Yeah, that makes sense.  But you could do that with the xt of a named word too, right?
10:28:07 <zy]x[yz> yeah, but it's just convenient to see it inline right there
10:28:13 <KipIngram> I think I grok the benefits of treating xt's as data.
10:28:41 <KipIngram> But I try to keep my definitions short; moving the def off to its own place and referencing it by name makes the definition that references it shorter.
10:28:48 <KipIngram> But I do see that as a style thing - different strokes.
10:29:08 <KipIngram> I just cringe a little when I start seeing Forth code that looks like C functions.
10:29:25 <zy]x[yz> anonymous inline functions is not c-like
10:29:25 <KipIngram> Like 15-20 lines long for one definition, with indentation etc etc.
10:29:39 <KipIngram> I'm talking just about the layout of code on the page.
10:29:53 <zy]x[yz> : give does  pools [] [: does > if drop exit then break -;] each  insert ;
10:30:08 <zy]x[yz> ^ an example of where i use one in my buddy-memory implementation
10:30:20 <zy]x[yz> each iterates a linked list and executes the xt
10:30:36 <zy]x[yz> (oops, should have been "pools[]")
10:31:50 <zy]x[yz> i think it's taken to a bit of an extreme when i see these forths where all control flow words just take xts
10:32:10 <zy]x[yz> like   <condition> [ quotation ] if
10:32:49 <KipIngram> Yes, and I'm pretty convinced that sacrifices at least some performance, since you are, in fact, having to move the xt onto the stack instead of having it "in place" in the code.
10:33:10 <zy]x[yz> i get the idea, and i guess logically it makes sense, but i think that's just too far down the road of sacrifing usability for ideology
10:33:19 <zy]x[yz> yeah, plus the performance implications
10:33:33 <KipIngram> ^ I agree.  But I guess it's great that Forth will stretch to whatever a person wants it to be.
10:33:53 <KipIngram> I'm not opposed to it in any "religious" sense.  :-)
10:35:33 <crc> Performance is an issue, though my VM's instruction set is built around using xt's from the stack. (jump, call, conditional call all take the target address from the stack).
10:36:42 <crc> I can reduce the hit by having the processor recognize common instruction sequences internally, allowing the stack overhead to be bypassed
10:37:34 <crc> (I've only done this in experiments so far, but it works fine and does offer some benefits to overall performance)
10:37:42 <zy]x[yz> nice
10:39:37 <koisoke> even a naive implementatoin is just one extra level of jmp indirection vs if .. then, so probably hard to pick out of very unoptimized compiler output
10:50:37 <crc> I have conditional calls, but not conditional jumps, so a traditional style if/then or loop construct would generally need to compile an anonymous function anyway.
11:23:24 --- quit: ncv (Remote host closed the connection)
11:23:45 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
11:55:47 <john_cephalopoda> Hmm, how does one read the next letters in Forth? VARIABLE seems to read ahead somehow but I can't seem to find a way how a name can be read that way in Forth that doesn't use weird constructs.
11:59:41 <DKordic> `` name ''?  
12:00:46 <DKordic> For example: `` name wrd  cr type ''.  
12:01:31 <koisoke> PARSE?
12:01:33 <koisoke> or WORD
12:02:26 <koisoke> question mark was mine, so PARSE  or WORD
12:07:10 <crc> 6.1.0695 ACCEPT
12:07:47 <crc> 6.1.2450 WORD
12:07:58 <crc> 6.2.2008 PARSE
12:08:12 <crc> These are the common ones
12:10:00 <crc> hmm, also 6.2.1390 EXPECT, though this one is flagged as obsolete 
12:23:19 --- quit: jedb (Ping timeout: 268 seconds)
12:27:46 <john_cephalopoda> Thanks
12:31:20 <KipIngram> John: It's WORD.
12:31:37 <KipIngram> I thought EXPECT read from the keyboard.
12:31:49 <KipIngram> Into an arbitrary buffer.
12:31:59 <KipIngram> QUERY reads from the keyboard into the TIB.
12:32:07 <KipIngram> (text input buffer - where commands get parsed from).
12:32:14 <KipIngram> QUERY is how you refill TIB with a new line of stuff.
12:32:32 <KipIngram> then the phrase BL WORD parses out the next word and puts it somehwere as a counted string.
12:32:48 <KipIngram> In old FIG style Forths it put it right where it would need to be if it became the next word in the dictionary.
12:33:15 <KipIngram> So CREATE would run BL WORD and then move the HERE pointer and fill in the additional header information (link, CFA, etc.)
12:37:52 <crc> You are correct on EXPECT/ACCEPT; it's been quite a while since I've used a Forth with parsing words
12:39:07 <KipIngram> My system is still pretty standard in all of that, except I don't put the names themselves in the dictionary entries (they go in a symbol table), so I don't put the word at HERE.
12:40:10 <KipIngram> And my QUERY (which I think did later get renamed ACCEPT as you alluded) can navigate my command history, so it's a bit more involved than just TIB <count> EXPECT
12:45:01 <crc> I dont have any parsing words in a standard retro system.
12:45:58 <crc> the standard listener reads in and processes tokens as they're entered, but doesn't expose anything for looking ahead.
12:54:19 <crc> On the unix implementation it can be added using something like:
12:54:24 <crc>   :eol?    (c-f)
12:54:24 <crc>     [ ASCII:CR eq? ] [ ASCII:LF eq? ] [ ASCII:SPACE eq? ] tri or or ;
12:54:24 <crc>   :word    (-s)
12:54:24 <crc>     [ #1025 buffer:set
12:54:24 <crc>       [ c:get dup buffer:add eol? ] until
12:54:25 <crc>       buffer:start s:chop ] buffer:preserve ;
12:57:20 <crc> This wont work on systems without a traditional keyboard+terminal though (e.g., iOS, javascript+html, or embedded targets)
13:01:03 --- quit: Zarutian (Ping timeout: 244 seconds)
13:02:53 --- join: Zarutian (~zarutian@173-133-17-89.fiber.hringdu.is) joined #forth
13:41:40 --- join: wa5qjh (~quassel@175.158.225.200) joined #forth
13:41:40 --- quit: wa5qjh (Changing host)
13:41:40 --- join: wa5qjh (~quassel@freebsd/user/wa5qjh) joined #forth
13:44:06 --- join: pierpa (5ff5c1d2@gateway/web/freenode/ip.95.245.193.210) joined #forth
14:34:59 --- join: wa5qjh_ (~Thunderbi@freebsd/user/wa5qjh) joined #forth
14:40:47 <john_cephalopoda> crc: What forth implementation is that code for?
14:41:20 <crc> forthworks.com/retro
14:42:54 <crc> it's my own personal forth dialect
14:45:58 <john_cephalopoda> Oh, wow, I actually saw that channel in the IRC list.
14:46:23 <john_cephalopoda> I think I'll try to port my scripts to it eventually.
14:48:17 --- join: rdrop-exit (~markwilli@112.201.162.180) joined #forth
15:31:01 <WilhelmVonWeiner> zy]x[yz: quotations in Forth Forth?!
15:33:03 <WilhelmVonWeiner> john_cephalopoda: if I'm doing something that doesn't involve byte level manipulation I use retro
15:33:17 <WilhelmVonWeiner> everything postfix is so logical to me
15:34:04 <john_cephalopoda> Unfortunately retro doesn't seem to be very verbose.
15:34:13 <WilhelmVonWeiner> elaborate?
15:35:44 <john_cephalopoda> Well, I give it a file, run rre and it doesn't tell me anything. Just quits. 
15:36:14 <john_cephalopoda> Of course there are billions of syntax errors in that program, but a short notice like "Hey, I don't get what you write in line 2" would be useful.
15:36:17 <WilhelmVonWeiner> I mean if you want to see something, run `listener`, that's the binary contained within rre
15:36:36 <WilhelmVonWeiner> I highly recommend you look at the doc/ folder.
15:36:38 <john_cephalopoda> Oh, the README doesn't mention it.
15:37:10 <WilhelmVonWeiner> I usually write retro, one terminal with nano myfile, one terminal with `less doc/Glossary.txt`
15:38:26 <john_cephalopoda> Hmm, it's getting late. I'll try to convert my Mandelbrot set viewer to Retro tomorrow.
15:39:14 <john_cephalopoda> Night!
15:39:18 <WilhelmVonWeiner> peace
15:39:29 --- quit: john_cephalopoda (Quit: Trees can see into your soul.)
15:45:46 --- quit: wa5qjh_ (Remote host closed the connection)
15:46:13 --- join: wa5qjh_ (~Thunderbi@freebsd/user/wa5qjh) joined #forth
15:48:55 --- quit: pierpal (Ping timeout: 252 seconds)
15:49:11 --- quit: irsol (Quit: leaving)
15:50:24 --- join: irsol (~irsol@unaffiliated/contempt) joined #forth
16:05:35 --- quit: nighty- (Quit: Disappears in a puff of smoke)
16:09:09 --- quit: wa5qjh_ (Remote host closed the connection)
16:09:10 --- quit: wa5qjh (Remote host closed the connection)
16:25:17 --- quit: WilhelmVonWeiner (Quit: leaving)
16:41:56 --- join: jedb (~jedb@199.66.90.113) joined #forth
17:18:09 --- join: pierpal (~pierpal@host210-193-dynamic.245-95-r.retail.telecomitalia.it) joined #forth
17:34:43 --- join: nighty- (~nighty@kyotolabs.asahinet.com) joined #forth
17:35:12 --- quit: johnnymacs (Read error: Connection reset by peer)
18:23:48 --- join: dave0 (~dave@47.44-27-211.dynamic.dsl.syd.iprimus.net.au) joined #forth
18:25:10 <dave0> hi
18:29:22 <KipIngram> Hi Dave.
18:29:29 <dave0> hi KipIngram 
18:29:31 <dave0> sup?
18:29:56 <KipIngram> Reverting out some recent changes to my Forth; want to try handling that a different way.
18:30:00 <KipIngram> git rocks
18:31:22 <dave0> i don't use source control but i probably should, especially when experimenting with an algorithm
18:44:52 <KipIngram> git is easy to "slow start" with.  It's amazingly powerful, but you don't have to learn it all at once.
18:45:19 <KipIngram> You can get started with 1) git init 2) git add <file> 3) git commit -a
18:45:33 <KipIngram> Knowing how to use .gitignore is handy as well.
18:47:03 --- quit: dddddd (Remote host closed the connection)
19:00:32 --- quit: ncv (Remote host closed the connection)
19:09:08 --- quit: pierpa (Quit: Page closed)
19:28:30 --- join: tabemann (~tabemann@rrcs-162-155-170-75.central.biz.rr.com) joined #forth
19:44:19 --- quit: tabemann (Ping timeout: 252 seconds)
20:25:26 --- join: tabemann (~tabemann@2602:30a:c0d3:1890:1870:3255:3792:ba89) joined #forth
21:09:18 --- quit: dave0 (Read error: Connection reset by peer)
21:09:39 --- join: dave0 (~dave@47.44-27-211.dynamic.dsl.syd.iprimus.net.au) joined #forth
23:59:59 --- log: ended forth/18.11.08