00:00:00 --- log: started forth/21.06.24
00:14:38 --- join: rain3 joined #forth
00:22:49 --- quit: mark4 (Ping timeout: 120 seconds)
00:27:44 --- join: mark4 joined #forth
02:13:14 <cbridge_> <ttmrichter> That's the key.  You only pay the cost for the address once: in the token table.
02:13:39 <cbridge_> <ttmrichter> So if the token is smaller than an address you're saving space (at the expense of speed, typically).
02:13:56 <cbridge_> <ttmrichter> My STM8 Forth uses token threading because it's just such a cramped space.
02:15:42 <cbridge_> <neuro_sys> Was it so that token threading limits the number of words you can have?
02:15:53 <cbridge_> <neuro_sys> To the cell size, that is.
02:16:18 <cbridge_> <neuro_sys> As in for 1 byte tokens, you could have only 256 words.
02:17:51 <cbridge_> <ttmrichter> If you're in that cramped a space, that's rarely an issue.  :D
02:17:58 <cbridge_> <ttmrichter> But there's ways to extend that.
02:18:34 <cbridge_> <ttmrichter> My tokened Forths are 8-bit tokens, but there are some reserved tokens.
02:19:54 <cbridge_> <ttmrichter> Essentially F0-FF are hard-coded to words that read the very next token and index into adjunct tables from that.
02:20:51 <cbridge_> <ttmrichter> Giving me in effect 4096 more words that are slightly slower to access (another layer of indirection).
02:21:11 <cbridge_> <ttmrichter> I don't think I've ever gone beyond F1, and most of the time I don't even go into F0.
02:43:52 <cbridge_> <neuro_sys> Makes sense
02:46:05 --- join: Glider_IRC__ joined #forth
02:46:56 <cbridge_> <boru> KipIngram; I have the figForth source (for the 6809) if you want it. It's a scan of a hard listing.
02:48:57 --- quit: Glider_IRC_ (Ping timeout: 120 seconds)
03:06:49 <crab> howdy
03:20:33 --- quit: crab (Quit: WeeChat 3.0.1)
03:40:47 <cbridge_> <proteusguy> So in two hours (7:30p GMT+7 BKK Time) we're going to attempt to multi-way live stream a demo of a forth implementation targeting a 6502 running on a javascript emulator. :-)  Read the end of this blog report for details on how you can join! https://blog.biggestfan.live/post-2021-06-23-new-business/
06:30:55 <cbridge_> <MrMobius> is there a way to exit a BEGIN/AGAIN loop other than EXIT?
06:49:53 --- quit: Glider_IRC__ (Connection closed)
06:51:08 --- join: Glider_IRC joined #forth
07:05:40 --- quit: jyf2 (Ping timeout: 120 seconds)
07:08:14 --- join: jyf2 joined #forth
07:46:00 <cbridge_> <crc> I'm not aware of anything that'd be standard for that
08:06:24 <cbridge_> <KipIngram> boru: Thanks - that would be cool to have around.  I learned assembly programmingon the 6809; I imagine I remember it fairly well.
08:06:51 <cbridge_> <KipIngram> proteusguy: How did the stream go?
08:07:53 <cbridge_> <KipIngram> MrMobius: I'm not sure about standard ways, but it seems like it would be fairly easy to implement a BREAK word.  You're just after a jump to just past the loop?
08:10:08 --- quit: proteusguy (Ping timeout: 120 seconds)
08:14:17 <cbridge_> <boru> Heh, I cut my teeth on the 68XX as well.
08:14:47 <cbridge_> <boru> Let me upload it somewhere.
08:16:58 <cbridge_> <MrMobius> KipIngram, right. the question though is if that already exists in forth. i dont want to leave it out of the forth im working on if it's something common but seems safe to leave out otherwise
08:23:30 --- join: proteusguy joined #forth
08:23:30 --- mode: ChanServ set +o :proteusguy
08:27:28 <cbridge_> <boru> KipIngram; https://filebin.net/cmd4jmhyqt2y4225/kip.tar.xz (figForth 6809 source, figForth manual, figForth TinyPascall compiler)
08:28:19 <cbridge_> <boru> Err, meant to privmsg that. This isn't ##warez...
08:41:08 --- quit: cbridge_ (Connection closed)
08:41:19 --- join: cbridge_ joined #forth
08:41:23 --- quit: cbridge_ (Quit: bye)
08:41:33 --- join: cbridge_ joined #forth
08:41:36 --- quit: cbridge_ (Quit: bye)
08:41:46 --- join: cbridge_ joined #forth
08:41:49 --- quit: cbridge_ (Quit: bye)
08:41:58 --- join: cbridge_ joined #forth
08:42:01 --- quit: cbridge_ (Quit: bye)
09:15:57 --- quit: mark4 (Connection closed)
10:19:54 --- join: cbridge_ joined #forth
10:21:49 <cbridge_> <brainfunnel> KipIngram: hmm, in this forth I'm looking at, in the boot.fth it defines CREATE as : CREATE    HEAD 1 1+ , ;  makes me wonder what it'd look like if it weren't token threaded? i suppose similar except the implementation of HEAD would be different internally.
10:21:51 <cbridge_> <springb0k> IBM & CDC were using 'threading' in the 'popular' sense since the '60s.
10:24:27 <cbridge_> <KipIngram> CREATE itself isn't very hard - it's the "DOES" part of the feature that complicates the implementation and is easier on direct threaded.
10:25:13 <cbridge_> <KipIngram> springb0k: Well, I take your word for it; I'm not that up on my computing history.  I assume it was Chuck or one of his cronies that coined the Forth usage at some point.
10:26:27 <cbridge_> <KipIngram> brainfunnel: I once spent a couple of days trying to "generalize" create/does into an arbitrary number of levels, but I didn't really get it to go anywhere very interesting.
10:27:13 <cbridge_> <springb0k> I'm sure they did.  Just pointing out that the rest of the world didn't take a word from the Forth world and redefine it.  Vice versa.
10:29:09 <cbridge_> <brainfunnel> KipIngram: haha, I suppose thats why "DOES" isn't implemented in this particular boot.
10:31:30 <cbridge_> <KipIngram> :-)
10:36:18 <cbridge_> <neuro_sys> From the Wiki article, the PDF is OCR'ed, you can search for "thread". http://web.mit.edu/Saltzer/www/publications/MIT-MAC-TR-030.ocr.pdf
10:38:39 <cbridge_> <neuro_sys> Although it's also referring to the meaning of the thread in Forth sense I think.
10:38:53 <cbridge_> <neuro_sys> A metaphor for a sequence of instructions.
11:12:52 <cbridge_> <MrMobius> KipIngram, interesting. does me do a jump or jsr?
11:13:37 <cbridge_> <MrMobius> ya Fortran started out in the mid 50s and became threaded at some point
12:42:41 <cbridge_> <KipIngram> ME does a jump, MrMobius.
12:43:22 <cbridge_> <KipIngram> Always to the beginning of the most recently compiled word - it's not an "adjustable" jump.
12:43:45 <cbridge_> <KipIngram> I have it in conditional forms too, like 0=me and <=me and so on.
12:44:08 <cbridge_> <KipIngram> The same "complete" set of conditionals that I have for conditional single and double returns.
12:44:28 <cbridge_> <KipIngram> Those items - conditional recursion, conditional return, are really the full extent of my conditional control flow words.
12:44:37 <cbridge_> <KipIngram> I don't have the classic structures.
12:44:55 <cbridge_> <neuro_sys> The standards don't make a distinction between colon words and primitives right?
12:45:10 <cbridge_> <KipIngram> The compiler is smart enough to use a flag in the header to know whether to put an offset to start of word after the word it just compiled, so I don't need immediate words for any of those.
12:45:24 <cbridge_> <KipIngram> There's not supposed to be a distinction - correct.
12:45:45 <cbridge_> <KipIngram> That's one of Forth's "graceful features" - that words you add behave in every way like the "built-in" words.
12:47:08 <cbridge_> <neuro_sys> KipIngram: Is your Forth available online?
12:59:17 <cbridge_> <MrMobius> KipIngram, so you basically have to make a whole new word for your BEGIN loops?
13:14:17 <cbridge_> <KipIngram> neuro_sys: No, not yet.  I want to get it to a more complete state first.
13:14:40 <cbridge_> <KipIngram> MrMobius: Well, I don't HAVE to.  I usually do.  But I can do this if I want to:
13:14:57 <cbridge_> <KipIngram> : foo ... code ... .: bar ... code me ;
13:15:06 <cbridge_> <KipIngram> and the loop will go back to bar instead of foo.
13:15:21 <cbridge_> <KipIngram> By using .: instead of : I can later delete the name bar from my dictionary.
13:15:32 <cbridge_> <KipIngram> I would usually write that like this, though:
13:15:36 <cbridge_> <KipIngram> : foo ...code...
13:15:42 <cbridge_> <KipIngram> .: bar ... code ... me ;
13:16:21 <cbridge_> <KipIngram> But yes, all of my jumps go to the beginning of the code associated with the most recent name in the dictionary.
13:16:52 <cbridge_> <KipIngram> I've been using that model for a while  now, and don't find it to be inconvenient in any way.  I'm generally looking for opportunities to factor, and that helps me do that.
13:22:43 <cbridge_> <dave0> maw
13:26:40 <cbridge_> <crc> maw
13:26:46 <cbridge_> <dave0> maw crc 
13:55:37 --- quit: rain3 (Ping timeout: 120 seconds)
13:57:30 <cbridge_> <KipIngram> maw dave0
14:02:32 <cbridge_> <dave0> maw KipIngram 
14:46:20 --- join: Glider_IRC_ joined #forth
14:49:13 --- quit: Glider_IRC (Ping timeout: 120 seconds)
15:44:21 --- quit: cbridge_ (Quit: bye)
15:44:32 --- join: cbridge_ joined #forth
18:14:22 --- join: Jo_Anna joined #forth
18:15:27 <Jo_Anna> hi proteusguy
18:23:11 --- quit: Jo_Anna (Quit: Leaving)
20:28:41 --- join: crab joined #forth
20:52:34 --- quit: crab (Ping timeout: 120 seconds)
20:54:50 --- join: crab joined #forth
20:58:09 --- quit: Adran (Ping timeout: 120 seconds)
21:08:50 --- join: Adran joined #forth
21:33:32 --- quit: crab (*.net *.split)
21:55:34 --- join: crab joined #forth
23:59:59 --- log: ended forth/21.06.24