00:00:00 --- log: started forth/18.12.10
00:14:47 --- quit: proteusguy (Ping timeout: 244 seconds)
00:17:08 --- join: proteusguy (~proteus-g@cm-134-196-84-98.revip18.asianet.co.th) joined #forth
00:17:08 --- mode: ChanServ set +v proteusguy
00:18:29 --- join: xek (~xek@apn-31-0-23-83.dynamic.gprs.plus.pl) joined #forth
01:06:32 --- join: ncv (~neceve@host165-120-111-163.range165-120.btcentralplus.com) joined #forth
01:06:32 --- quit: ncv (Changing host)
01:06:32 --- join: ncv (~neceve@unaffiliated/neceve) joined #forth
01:34:39 --- join: dddddd (~dddddd@unaffiliated/dddddd) joined #forth
02:05:13 --- quit: ashirase (Ping timeout: 268 seconds)
02:08:10 --- join: ashirase (~ashirase@modemcable098.166-22-96.mc.videotron.ca) joined #forth
03:08:30 --- quit: pierpal (Quit: Poof)
03:08:47 --- join: pierpal (~pierpal@95.239.223.85) joined #forth
03:20:31 <WilhelmVonWeiner> sk3ngm4n
03:20:38 <WilhelmVonWeiner> god damn
03:20:44 <WilhelmVonWeiner> I keep typing that into the wrong window
03:21:04 <WilhelmVonWeiner> had to change all my passwords after I blasted that into #concatenative the other day
03:21:20 <WilhelmVonWeiner> it's only on my local network but still, what a pita 
03:21:36 * WilhelmVonWeiner needs to disable screen blanking
03:39:09 --- quit: smokeink (Ping timeout: 240 seconds)
03:43:11 --- join: smokeink (~smokeink@42-200-117-62.static.imsbiz.com) joined #forth
03:53:10 <C-Keen> it's not a good password either
04:34:44 <zy]x[yz> i have a pretty good password.  you can use it if you want.  it's gek$77Kol
04:36:10 --- quit: libertas (Ping timeout: 246 seconds)
04:36:22 --- join: libertas (~libertas@a95-93-229-182.cpe.netcabo.pt) joined #forth
04:49:52 --- quit: pierpal (Ping timeout: 268 seconds)
04:51:51 <WilhelmVonWeiner> thanks zy]x[yz 
04:52:15 <WilhelmVonWeiner> C-Keen: It was only for the user accounts on my desktop machines. 
04:53:29 <WilhelmVonWeiner> you can't log in over the network, I just don't want my brother trying to play Dota 2 and accidentally formatting / as btrfs.
05:07:01 <C-Keen> I understand :)
05:19:20 <siraben> WilhelmVonWeiner: you shouldn't be reusing passwords
05:19:52 <siraben> Does your IRC client support remembering passwords?
05:20:00 <siraben> Or auto login
05:20:30 <WilhelmVonWeiner> my IRC client does auto login.
05:21:02 <WilhelmVonWeiner> That was just my password for my user account/screen lock.
05:21:29 <WilhelmVonWeiner> I've since changed it, but it's still trivially simple to crack
05:51:54 --- join: pierpal (~pierpal@95.239.223.85) joined #forth
06:13:13 --- quit: pierpal (Quit: Poof)
06:13:30 --- join: pierpal (~pierpal@95.239.223.85) joined #forth
06:18:59 --- quit: gravicappa (Ping timeout: 250 seconds)
06:21:54 --- join: gravicappa (~gravicapp@h109-187-52-39.dyn.bashtel.ru) joined #forth
06:30:57 <john_cephalopoda> Hey.
06:32:24 <john_cephalopoda> WilhelmVonWeiner: Well, as long as the HDD isn't encrypted a screen lock password is pretty non-critical. My screen lock passwords also tend to be short and simple.
06:32:52 <john_cephalopoda> My server password, on the other hand, is long. And non-local users need to verify with privkey via ssh.
06:33:52 <WilhelmVonWeiner> exactly
06:36:37 <WilhelmVonWeiner> only passwords I have that are long and secure and important are HDD and SSH keys
06:37:38 <WilhelmVonWeiner> though I'm one of those weirdos who turns his computer off when he goes away for more than 5 minutes. 
06:38:29 --- quit: smokeink (Ping timeout: 252 seconds)
06:41:37 <john_cephalopoda> I only turn it off over night.
06:41:58 <john_cephalopoda> At least my desktop, my laptop is turned off most of the time.
06:42:06 --- quit: pierpal (Ping timeout: 268 seconds)
07:03:10 --- quit: proteusguy (Ping timeout: 246 seconds)
07:04:57 --- join: proteusguy (~proteus-g@cm-134-196-84-98.revip18.asianet.co.th) joined #forth
07:04:57 --- mode: ChanServ set +v proteusguy
07:14:59 --- join: pierpal (~pierpal@95.239.223.85) joined #forth
07:30:44 --- quit: tabemann (Ping timeout: 268 seconds)
07:52:36 <proteusguy> siraben, you living in Bangkok?? What you doing in Thailand?
07:53:00 <siraben> proteusguy:  where'd you get that from?
07:53:05 <siraben> Yeah I do, I live here
07:53:13 <siraben> I am*
07:59:57 <john_cephalopoda> https://thecutecuttlefish.org/tmp/tiles.png
08:00:10 <john_cephalopoda> 8x8 px tiles in sixel graphics.
08:00:35 <john_cephalopoda> That could basically be used to create a game.
08:01:09 <zy]x[yz> nice R
08:02:07 <john_cephalopoda> :þ
08:02:20 <john_cephalopoda> The text "FORTH" is written with hlines and vlines.
08:02:32 <john_cephalopoda> I think I'll make the first game mostly sprite-based.
08:03:13 <zy]x[yz> I'd be all over sixels if they were a standard feature in most terminal emulators
08:06:02 <john_cephalopoda> I am implementing it by writing things to a buffer and then printing that buffer out with sixels.
08:06:56 <john_cephalopoda> Framebuffers are supported in basically any rendering engine, so porting that to an other rendering method would be quite trivial.
08:08:02 <zy]x[yz> makes sense
09:34:50 --- quit: proteusguy (Ping timeout: 246 seconds)
09:36:43 --- quit: ncv (Remote host closed the connection)
09:46:41 --- join: proteusguy (~proteus-g@cm-134-196-84-98.revip18.asianet.co.th) joined #forth
09:46:41 --- mode: ChanServ set +v proteusguy
09:47:09 --- quit: gravicappa (Ping timeout: 240 seconds)
10:25:01 --- join: dys (~dys@tmo-123-49.customers.d1-online.com) joined #forth
11:52:48 --- quit: xek (Remote host closed the connection)
11:53:15 --- join: xek (~xek@apn-31-0-23-83.dynamic.gprs.plus.pl) joined #forth
12:28:52 --- quit: Zarutian (Read error: Connection reset by peer)
12:28:59 --- join: Zarutian_2 (~zarutian@173-133-17-89.fiber.hringdu.is) joined #forth
12:36:10 --- nick: Zarutian_2 -> Zarutian
15:40:47 --- join: rdrop-exit (~markwilli@112.201.164.82) joined #forth
15:41:01 <rdrop-exit> Good morning Forthwrights :)
15:51:09 <crc> good evening rdrop-exit 
15:52:30 <rdrop-exit> Hi crc
15:52:55 <rdrop-exit> On my first cup of coffee
15:54:34 <crc> I don't do coffee often, but I'm well past my last cup of tea for the day
15:56:04 --- join: nonlinear (~nonlinear@unaffiliated/discrttm) joined #forth
15:58:44 <rdrop-exit> My morning routine is two double espressos before walking the dogs.
16:00:45 <rdrop-exit> I got to bed late, I usually try to get up before the sun gets too hot for the dogs.
16:08:22 <rdrop-exit> They're actually the dogs of two of my kids, but they offloaded them on me.
16:11:32 <rdrop-exit> What's new in the Forth world?
16:11:46 <crc> no pets for me; the only animals I've ever kept were fish
16:13:55 <rdrop-exit> I didn't plan on having pets, but at least it forces me to get some exercise.
16:14:16 <crc> I've been working on documentation and doing a bit of experimenting with swapping between multiple image files
16:15:29 <crc> I get my exercise by biking to and from my day job. 6-20 miles per day, depending on the route and weather.
16:16:14 <PoppaVic> That's what I like to see
16:16:35 <PoppaVic> I can watch people exercising all day long.
16:17:10 <rdrop-exit> Nice! I biked to work occasionaly when we were living in Paris. Haven't biked in 20+ years.
16:17:41 <rdrop-exit> Taking the dogs on long walks is pretty much it for me.
16:18:35 <crc> I do moderate walks (2-4 miles) too; 2-3 times per week.
16:19:11 <crc> a bit less now that it's getting uncomfortably  cold
16:19:52 <rdrop-exit> It never gets cold here, I'm in shorts all year around.
16:20:29 <rdrop-exit> Sometimes we wekeend in the "mountains" just to feel some chill.
16:22:03 <crc> -1C here currently, getting down to around -3 by the time I leave for work tomorrow
16:22:50 <rdrop-exit> Yikes! it's 28C right now, 8am.
16:23:25 <rdrop-exit> Partly sunny.
16:24:02 <rdrop-exit> The last time I saw snow was about 25 years ago.
16:25:00 <crc> We've had one snowstorm already; I'm hoping there's not much more
16:27:03 <crc> The cold makes typing difficult.
16:27:08 <rdrop-exit> I spent some time near the arctic circle, nortern Sweden, Norway, and Finland. I was absolutely miserable.
16:28:21 <rdrop-exit> Whenever I've had a choice, I've stayed away from cold climates.
16:28:35 <verisimilitude> Hello, rdrop-exit.
16:28:53 <rdrop-exit> Hello Verisimilitude
16:29:13 <crc> I prefer temperatures between 8-20C. When I was a little younger cold like I'm in now wouldn't have bothered me, but it gets more annoying every year.
16:32:19 <rdrop-exit> I grew up in San Francisco and Nice, neither of which get snow.
16:32:59 <rdrop-exit> San Francisco gets chilly in the morning, before the fog burns off.
16:37:02 <rdrop-exit> brb
16:39:43 --- quit: john_cephalopoda (Ping timeout: 252 seconds)
16:41:29 --- join: john_cephalopoda (~john@unaffiliated/john-cephalopoda/x-6407167) joined #forth
16:41:55 <rdrop-exit> I better go, it's already 29C and rising. Chat again later.
16:42:05 --- quit: rdrop-exit (Quit: Lost terminal)
17:40:30 --- join: tabemann (~tabemann@h193.235.138.40.static.ip.windstream.net) joined #forth
18:04:10 --- quit: tabemann (Ping timeout: 245 seconds)
18:07:08 --- quit: libertas (Ping timeout: 268 seconds)
18:51:20 --- join: dave0 (~dave0@47.44-27-211.dynamic.dsl.syd.iprimus.net.au) joined #forth
18:51:35 <dave0> hi
18:51:44 <crc> hi dave0
18:52:00 <dave0> hi crc 
19:29:18 --- join: libertas (~libertas@a95-93-229-182.cpe.netcabo.pt) joined #forth
19:36:09 --- join: tabemann (~tabemann@2602:30a:c0d3:1890:a433:523c:27b8:b5c8) joined #forth
19:42:39 --- join: smokeink (~smokeink@42-200-117-62.static.imsbiz.com) joined #forth
19:45:50 --- quit: dddddd (Remote host closed the connection)
19:56:01 --- quit: dave0 (Quit: dave's not here)
20:06:36 --- join: rdrop-exit (~markwilli@112.201.164.82) joined #forth
20:15:14 --- quit: libertas (Ping timeout: 252 seconds)
20:18:03 <tabemann> hey rdrop
20:18:15 <rdrop-exit> Hi Tabemann!
20:19:34 <tabemann> I'm wondering whether to code up a generic free-on-task-exit function, or force the programmer to come up with their own (since in many cases something different than just a free will be necessary)
20:19:47 <tabemann> (of course the programmer is myself)
20:20:52 <tabemann> I do have an atexit function for registering handlers to execute on task exit
20:20:57 --- join: gravicappa (~gravicapp@h109-187-52-39.dyn.bashtel.ru) joined #forth
20:21:07 <tabemann> hey gravicappa 
20:23:36 <rdrop-exit> That should be enough then
20:25:00 <tabemann> s h i t
20:25:04 <tabemann> I just realized something
20:25:13 <rdrop-exit> ohoh
20:25:19 <tabemann> I should pass closures their own xts when they're executed
20:25:47 <tabemann> so they can A) call themselves recursively and B) free themselves
20:26:01 <tabemann> (it's safe for a closure to free itself in attoforth)
20:26:46 <tabemann> the s h i t factor is that it was a pain to implement closures, and I don't want to do it over again
20:27:20 <rdrop-exit> Do you need them?
20:27:39 <tabemann> I like having closures (remember that I'm also a Haskell programmer)
20:29:04 <rdrop-exit> Then I guess you need to pay the piper
20:31:14 <tabemann> of course in many functional languages, anonymous lambdas can't recurse anyways unless they're bound to a name
20:32:22 <rdrop-exit> Of course... hum, I mean I'll take your word for it :)
20:33:13 <tabemann> my code for introducing a closure which binds both integer and floating point values is particularly ugly
20:33:35 <tabemann> I should have left in comments all over the place, since I don't understand how it works now
20:33:44 <rdrop-exit> Sounds complicated
20:34:28 <rdrop-exit> brb
20:34:51 <tabemann> a lot of my forth code isn't "good" forth code that is nice and factored and all that - I have a habit of trying to juggle way too much stuff on the stack
20:35:25 <tabemann> in more recent code that needs a lot of state what I've started to do is to write accessor functions that hide all the stack juggling
20:37:07 <rdrop-exit> Forth is highly factored code. (Charles H. Moore)
20:38:58 <tabemann> what I do more these days is save values in data structures as soon as they're produced, and then load them from where they are saved later when I need them, rather than juggle them around on the stack
20:39:36 <rdrop-exit> That defeats the purpose of the stack.
20:40:27 <tabemann> well yes, it reduces the number of items I keep on the stack; in many cases it reduces it from five or six items to two or three items
20:40:30 <PoppaVic> Just create a "struct stack" - or better yet, dynamic-allocate.
20:40:51 <rdrop-exit> =8-O
20:40:55 <PoppaVic> gods forbid you use a var "buffer" ;-)
20:41:00 <tabemann> well, yes, the data structures I refer to are heap-allocated
20:41:13 <tabemann> and they're data structures that need to be populated anyways
20:41:44 <tabemann> I'm just not saving the values on the stack once they've been stored in their proper places, even if I will need them later
20:42:32 <tabemann> in the code I wrote earlier on I'd load something from a data structure once, and then juggle it around if I needed it again later, even though this made dealing with the stack so much more difficult
20:42:53 <PoppaVic> not economical
20:43:27 <tabemann> now I load something each time I use it, right before I use it
20:48:07 <rdrop-exit> defeats the purpose
20:51:08 <tabemann> so what options are there?
20:51:24 <rdrop-exit> factor more
20:51:24 <tabemann> other than "juggle values on the stack" and "load and store values as needed"
20:52:50 <PoppaVic> the stack has almost identical semantics to plain old "load and store"
20:53:45 <PoppaVic> indeed, you can think of SP as being the "struct ptr", so you just need something similar.
20:54:44 <verisimilitude> Say, rdrop-exit, now that I notice you're back, I was wondering if you had any thoughts to share on those things of mine I'd shown you earlier, when you get the time; feel fee to just PM me, if you want, since machine code programming isn't strictly related to Forth.
20:55:12 <tabemann> except the only operation that is akin to a plain load on the stack is PICK
20:55:34 <PoppaVic> no
20:55:42 <tabemann> every other operation shifts around the indices of each thing on the stack
20:55:59 <PoppaVic> stack has over, dup, etc.. all that shit is a fetch & store
20:56:06 <rdrop-exit> verisimilitude, I've done a quick read through, I want to go over your pages more thoroughly first
20:56:16 <verisimilitude> Alright.
20:56:29 <tabemann> what I mean is that each index each thing is at changes when you do one of those
20:56:42 <rdrop-exit> You're assuming a underlying register machine, you're not coding to the stack machine model
20:56:43 <verisimilitude> I'll have another article on the twelfth; I prefer to release articles when the day and month match.
20:57:01 <verisimilitude> A real stack has no pick, yes.
20:57:22 <rdrop-exit> agree
20:57:57 <PoppaVic> of course, a stack is just an array in a skirt. ;-P
20:58:18 <rdrop-exit> On a stack machine you can't assume the stack is addressable
20:58:20 <verisimilitude> That's not the case under, say, an F18A, as just one example.
20:58:24 <tabemann> what I mean is more mental effort is necessary to keep track of a stack, because the order of things on the stack is constantly changing
20:59:02 <rdrop-exit> If you factor more, you won't need as much mental effort to track the stack
20:59:42 <tabemann> ideally you can order things so that everything just works out, with the occasional DUP or SWAP, but sometimes more complexity is unavoidable (e.g. setting up arguments for MOVE)
20:59:43 <verisimilitude> Oh, I don't recall if I told you, rdrop-exit, but there's a mention of a 33554432 article in that main article I showed you; just ignore that linked article.
21:00:00 <rdrop-exit> ok
21:01:00 <rdrop-exit> tabemann: the standard move is idiotic, ( src # dst -- ) is better
21:01:04 * tabemann hates dealing with MOVE because it requires setting up three different arguments, many of which involve adding different combinations of other arguments (base addresses, offsets, lengths) together
21:02:25 <rdrop-exit> I just define move in terms of a \move primitive that uses the ( src # dst -- ) order of arguments
21:02:47 <tabemann> functions that require three or more arguments are a fucking pain
21:03:19 <tabemann> because it's not just like state that one can factor away - one has to get all of those values together in the same place
21:03:52 <tabemann> two arguments aren't a problem, because if something isn't in the right order, it's just a simple SWAP
21:04:22 <verisimilitude> Well, you can always omit a general purpose memory move procedure and simply have one tailored to your specific program, instead.
21:05:00 <tabemann> MOVE has the advantage that it's implemented in C, so it's faster than any memory move operations written in Forth
21:05:15 <verisimilitude> That's ironic to read, in a Forth channel.
21:05:24 <rdrop-exit> :)
21:06:04 <tabemann> would that sound better if s/C/assembly ?
21:06:59 <rdrop-exit> I very rarely use any words with more than 3 arguments, 3 is easily manageable.
21:07:12 <verisimilitude> Yes, tabemann.
21:07:34 <PoppaVic> <shrug> Nothing is stopping a forth-er from writing the asm to pop to register/pointers and a count, and ripping the move.
21:08:34 --- quit: pierpal (Quit: Poof)
21:08:49 <rdrop-exit> If you're really having trouble, you could add more stack operators to you're Forth, such as lift swish spin etc...
21:08:53 --- join: pierpal (~pierpal@95.239.223.85) joined #forth
21:09:03 <PoppaVic> swish & spin - nice ;-)
21:09:14 <rdrop-exit> :)
21:09:19 <PoppaVic> (although Swish and Spit is more apropos ;-)
21:09:33 <rdrop-exit> swish ( x y z -- y x z )
21:09:42 <tabemann> rdrop: it's really that with MOVE it's not three arguments - it's four or five arguments once you take offsets, length limits, etc. into account
21:09:48 <rdrop-exit> spin ( x y z -- z y x )
21:10:11 <rdrop-exit> lift ( x y -- x x y )
21:10:24 <rdrop-exit> there's a few more
21:10:34 <PoppaVic> rdrop-exit: around that time, I'd get pissed and use PICK or even >r and r@ as necessary
21:10:51 --- join: libertas (~libertas@a95-93-229-182.cpe.netcabo.pt) joined #forth
21:11:00 <tabemann> like say you have two buffers, and you want to copy n number of bytes from offset a in buffer foo and offset b in buffer bar, but don't copy more than m arguments if n > m
21:11:19 <rdrop-exit> PoppaVic Wouldn't work on some stack machines
21:11:24 <PoppaVic> tabemann: I live in C. Copying data bugs the shit out of me. I avoid it.
21:11:38 <PoppaVic> rdrop-exit: yes, I understand limitations
21:12:38 <tabemann> I honestly use PICK a lot - yes, it's heretical, but it works nicely, leaves the stack intact, and so on
21:12:51 <rdrop-exit> =8-O
21:12:54 <PoppaVic> if you use it a LOT - you are just wrong
21:13:47 <rdrop-exit> Perhaps you're shuffling data around too much
21:14:47 <tabemann> usually it's just 2 PICK or 3 PICK
21:15:05 * PoppaVic sighs
21:16:01 <rdrop-exit> As Chuck said PICK is an abomination
21:16:01 <tabemann> is ROT better?
21:16:07 <rdrop-exit> Yes
21:17:17 <tabemann> I'm confused - *why* is ROT better?
21:17:21 <ttmrichter> PoppaVic: SPIT and SWALLOW maybe?
21:17:39 <PoppaVic> I think at that point you are better-off using HERE as a buffer
21:18:05 <rdrop-exit> Treating the stack as an array breaks the implicit locality of reference assumption of the stack machine model, at that point you're really coding to a register machine model rather than a stack machine model. 
21:18:09 <PoppaVic> ttmrichter: well, I was thinking 'dentist', but in yer case it might be 'suck' and 'swallow', I suppose
21:18:24 <verisimilitude> ROT is better because it's easier to implement than PICK.
21:18:41 <verisimilitude> You can just use : ROT -ROT -ROT ; as an example.
21:19:18 <ttmrichter> rdrop-exit: +1.  Once you start messing with offsets in the stack like that as a matter of routine, you're pretty much not using a stack as a stack.  :-/
21:21:17 <rdrop-exit> The stacks on a stack machine could be implemented as a register file. A stack is not meant to be addressed like an array.
21:22:01 <rdrop-exit> You don't even need a stack pointer to implement a stack in hardware, you could use a large shift register.
21:23:20 <tabemann> the stack in my case is implemented as an array in memory, as with most forths not implemented on specialized hardware - why choose primitives that make programming harder just because of ideological views on what machine model one is attempting to present
21:23:24 <rdrop-exit> ttmrichter: exactly
21:24:12 --- quit: pierpal (Read error: Connection reset by peer)
21:24:34 --- join: pierpal (~pierpal@95.239.223.85) joined #forth
21:24:50 <verisimilitude> I suppose that's part of why I don't actually use Forth all that often, tabemann; I don't have a stack machine and it can be frustrating to be so close to the hardware and yet so removed in some aspects.
21:27:17 <PoppaVic> tabemann: make life worth living... : array ( ... n - a) here >r dup , 0 ?do , loop r> ;
21:27:35 <PoppaVic> when yer done, just dp ! the ptr. Done
21:29:17 <tabemann> I mean, my forth has sp@, sp!, sp0, fp@, fp!, fp0, rp@, rp!, and rp0 dammit
21:29:35 <tabemann> it does not even attempt to hide the nature of the stack as being an array
21:29:43 * PoppaVic chuckles
21:29:52 <PoppaVic> very true in many places
21:29:59 <rdrop-exit> Forth is a continuation of the stack machine model into software, if you're going to code to a register machine model, why would you want to do it in Forth.
21:30:20 <PoppaVic> for the same reason CM did the first time around
21:30:32 <PoppaVic> "to get shit done"
21:30:37 <rdrop-exit> It's like trying to do procedural programming in a functional language.
21:31:01 <tabemann> because concatenative programming is really nice in many ways
21:31:17 --- quit: proteusguy (Remote host closed the connection)
21:31:45 <tabemann> and Forth has better support for metaprogramming than most languages
21:31:56 <tabemann> especially once you exclude Lisps
21:32:22 * tabemann is amazed by how much of attoforth he wrote in pure Forth
21:32:27 <PoppaVic> Meanwhile, yer still arguing in favor of "too much shit on the stack".
21:32:53 <tabemann> nah, I've tried to reduce how much I put on the stack
21:36:06 <rdrop-exit> Concatenative programming, why did they come up with this new buzzword?
21:36:35 <tabemann> blame the people behind Factor
21:36:57 <tabemann> which is a language trying to be both functional and, to use their terminology, concatenative
21:37:27 <rdrop-exit> Like the postscript guys they were inspired by Forth but tried to hide the origins
21:37:32 <tabemann> actually, no, not Factor
21:37:39 <tabemann> what's the language which inspired Factor
21:37:43 <tabemann> Joy, that's it
21:37:58 <PoppaVic> factor or joy - either makes me want to cry
21:42:16 <X-Scale> the days when Slava was all over Freenode defending his concatenative language
21:42:44 <tabemann> which language can he be blamed for?
21:43:10 <rdrop-exit> :-))
21:44:14 <X-Scale> tabemann: Factor
21:44:38 <PoppaVic> Take a nice, simple language - throw every kitchen sink in the arsenal at it - and then add glitz.
21:44:47 <PoppaVic> or glitter - same idea
21:44:53 <rdrop-exit> Good name, wonder where he got it.
21:45:33 <rdrop-exit> Sounds complicated
21:45:36 <verisimilitude> Was ``concatenative'' ever used to describe Polish notation or Reverse Polish notation?
21:45:44 <verisimilitude> I wouldn't know.
21:45:59 <PoppaVic> rdrop-exit: well, "Scientology" was taken
21:46:10 <rdrop-exit> :-))
21:46:37 <rdrop-exit> Don't know either
21:47:26 <rdrop-exit> There was another language called MINT, that pulled the same trick, reinventing much of Forth without acnowledging its existense
21:47:37 <tabemann> I haven't taken too much of a look at Factor - how bad is it really?
21:47:52 <rdrop-exit> Actually it was more than a language, it was a VM++
21:48:15 <ttmrichter> tabemann: Factor's ... well, it's ... OK?  Ish?
21:48:18 <verisimilitude> Well, would it be fair to call anything using RPN Forth?
21:48:26 <tabemann> no
21:48:28 <ttmrichter> If it's a Forth your after, Factor WILL NOT do the job.
21:48:36 <ttmrichter> *you're
21:48:51 <ttmrichter> It's a huge monstrosity at every level from its VM up to its library.
21:49:03 <ttmrichter> It is emphatically NOT structured on "simplicity".
21:49:07 <rdrop-exit> MINT stood for Machine Independent Organic Sowtware Tools
21:49:43 <tabemann> verisimilitude, I'd say no
21:49:51 <ttmrichter> Nor is it based on the principle of only doing what you need for the job at hand.  Its library is HUGE and covers a whole bunch of weird edge cases you'd think best left to app-specific code.
21:49:56 <verisimilitude> It seems more unfair to Lucasiewicz than Moore.
21:50:10 <PoppaVic> verisimilitude: anything using RPN sounds like an HP-calculator ;-)
21:50:43 <rdrop-exit> HP calculators had RPL
21:51:00 <PoppaVic> but, could they tapdance?
21:51:02 <tabemann> I'm not sure if you can even call Forth RPN, since parsing words take their parsed arguments after the words
21:51:37 <PoppaVic> you can call it's math RPN, and it makes the muggles run screaming - always a plus
21:51:47 <tabemann> lol
21:51:56 <rdrop-exit> RPL stood for Reverse Polish Lisp, and also for ROM-based Procedural Language
21:52:25 <tabemann> that's what they called it?
21:52:40 <rdrop-exit> https://en.wikipedia.org/wiki/RPL_(programming_language)
21:52:52 <tabemann> Lisp seems so different from a desk calculator
21:52:56 <PoppaVic> they could call it BOB, but it'd still be RPN ;-)
21:53:08 <tabemann> like it was notorious back in the day for eating lots of memory
21:53:21 <tabemann> back in the day when one megabyte was more RAM than one could think of
21:54:07 <rdrop-exit> The HP-calculator engineers were into Forth, some were FIG members back in the day
21:55:37 <rdrop-exit> I have two HP calculators, one of them has RPL, the HP48GX
21:56:02 <PoppaVic> I miss FIG
21:57:08 <rdrop-exit> Me too
21:58:01 <rdrop-exit> SVFIG is still around
21:58:25 <tabemann> FIG seems like something from some supposed good-ol'-days of yore from before the coming of the evil ANS Forth
22:00:11 <rdrop-exit> In a way, yes
22:01:24 <rdrop-exit> Vendor Forths de-emphasized some of Forth's unique strengths, and ANS Forth went even further
22:02:06 <rdrop-exit> brb
22:02:21 <tabemann> (of course my Forth is essentially an ANS FOrth, albeit somewhat incomplete, so what am I to say)
22:02:47 <PoppaVic> FIG was the user-group; the newsletter; the site; the people. FIG-Forth was the freeware, 100% open forth [reference] implementation.
22:03:49 <PoppaVic> I mostly felt the fees were pretty damned high for 6 issues a year of a really thin "magazine" with more ads than content.
22:03:58 <tabemann> I've looked at the source code for some of the FIG Forths, and sadly it's generally in too bad condition that one couldn't get it to run today in an emulator even if one wanted to
22:04:28 <rdrop-exit> FIG-Forth had many warts
22:04:59 <rdrop-exit> I miss FORML the most
22:05:02 <PoppaVic> <shrug> 79 was 'worse', and 83 was... weird.
22:05:47 <tabemann> didn't 83 mandate 16-bit cells... which had to be weird for Forth on 68K machines
22:06:33 <PoppaVic> Mostly, I remember F-PC and F83 "just working" - which was nice.
22:06:52 <PoppaVic> (and FIG, of course - Just Worked because it was Just Simple)
22:07:22 <rdrop-exit> HS/Forth was pretty good
22:07:30 <PoppaVic> Never tried it
22:08:57 <rdrop-exit> I've never tried to comply to a Forth standard, not worth the trouble
22:09:28 <tabemann> I follow Forth 2012 as a general guideline, but I both go beyond it, and not implement parts of it, as I see fit
22:09:59 <rdrop-exit> I find it very convoluted
22:10:13 <tabemann> there's some parts I don't understand, like <# #>
22:11:11 <rdrop-exit> You can read up on <# #> in any Forth book, I doubt they changed much there.
22:11:19 <PoppaVic> Good luck finding a good writeup on the print-formatters
22:12:28 <rdrop-exit> Perhaps Starting Forth, Forth: A Text and a Reference, or Mastering Forth?
22:12:43 <PoppaVic> Never had the latter 2
22:12:44 <tabemann> I have a dead tree Forth reference on hand
22:12:51 <rdrop-exit> I don't remember which book explains it well.
22:14:02 <tabemann> okay, I should get to bed soon
22:14:18 <rdrop-exit> Pictured numeric output in Forth was probably inspired by COBOL.
22:16:39 <rdrop-exit> Except our patterns are reversed.
22:16:56 <PoppaVic> well, the gforth info file has some on 'pictured', but I still find it agonizing.
22:17:10 <rdrop-exit> Good night, Tabemann
22:17:34 <tabemann> g'night guys
22:41:47 --- quit: gravicappa (Remote host closed the connection)
23:14:20 --- join: dave0 (~dave0@47.44-27-211.dynamic.dsl.syd.iprimus.net.au) joined #forth
23:14:29 <dave0> hi
23:14:37 <rdrop-exit> Hi dave0
23:14:56 <dave0> hi rdrop-exit 
23:16:53 <dave0> i think this is the 1 line coroutine for forth:   : yield r> r> swap >r >r ;    yes?
23:18:25 <dave0> i like the idea of coroutines, but i have never actually written one, because i usually code in c and it can't have them
23:20:46 <rdrop-exit> It would normally not be implemented as a high level definition, since it's normally just a couple of machine instructions.
23:20:58 <rdrop-exit> But yes
23:21:15 <dave0> cool!
23:23:12 <rdrop-exit> As a primitive it would just exchange the address at the top of the return stack with the instruction pointer.
23:25:03 <rdrop-exit> Be careful that the points at which you yield are stack neutral since the coroutines are sharing the same stack.
23:25:22 <dave0> there's no such thing in c
23:25:25 <rdrop-exit> *stacks
23:26:21 <rdrop-exit> There are ways to implement coroutines in C, can't recall the details off the top of my head. A Google search might bring something up.
23:27:16 <PoppaVic> it uses an obscene switch/case iirc
23:27:43 --- quit: smokeink (Ping timeout: 246 seconds)
23:27:46 <dave0> it's come up in ##c before
23:28:19 <dave0> PoppaVic: i've coded something like that before, i was mimik'ing zlib (which uses an obscene switch/case :-)
23:28:38 <dave0> it's tedious
23:30:27 --- join: smokeink (~smokeink@42-200-117-62.static.imsbiz.com) joined #forth
23:30:52 <rdrop-exit> Forth makes it trivial thanks to its separation of the stacks
23:32:39 <rdrop-exit> It does sound tedious
23:32:46 <rdrop-exit> (the C kludge)
23:49:48 --- quit: dys (Ping timeout: 250 seconds)
23:59:59 --- log: ended forth/18.12.10