2023-09-05 00:03:16 <KipIngram   > Aha.  I figured out how to use the alpha mode of the bulk of hte keyboard.  There are three alpha modes - the default is the standard HP-42S one that uses the group key followed by the item key.  The other two modes use the full keyboard, one mode uppercase one lower.
2023-09-05 00:32:27 <KipIngram   > I checked my calculator clock again (I last did it six days ago and noted down the exact time I did it).  It had gained 16 seconds.  I calculated an RTC correction factor and loaded it in.  I'll check it again in a week or so.
2023-09-05 01:14:37 <KipIngram   > https://www.youtube.com/watch?v=ea_ybeslGpA
2023-09-05 01:14:54 <KipIngram   > ^ More on the HP-48 style firmware for the DM-42.
2023-09-05 01:16:44 <KipIngram   > MrMobius: You probably ought to watch that.  It looks to me like it would make my calculator into the sort of thing you were recommending the other day.
2023-09-05 01:17:00 <KipIngram   > And you can run both models side-by-side; it's easy to switch back and forth.
2023-09-05 01:19:35 <KipIngram   > His built-in help system looks particularly nice.  You can open help and it will just take you to the pertinent place.
2023-09-05 01:20:19 <KipIngram   > No separate "program entry" mode - you just put stuff between special brackets that look like single char versions of << and >>; that program item goes onto the stack, and you can save it in a variable.
2023-09-05 01:20:24 <KipIngram   > Those are then executable.
2023-09-05 01:20:43 <KipIngram   > Not too different at all from putting your code between : <namE. and ; eh?
2023-09-05 01:20:54 <KipIngram   > : <name> and  ;
2023-09-05 01:21:10 <KipIngram   > I'll probably want try this out at some point.
2023-09-05 01:27:17 <KipIngram   > Oh yeah - you definitely want to watch that last video I linked.
2023-09-05 01:35:05 <KipIngram   > Oh, interesting.  His first attempt was to just shove the pieces into the hardware.  Free42, the intel library, etc.  He ran out of RAM.  So now he's about to talk about "starting from scratch."
2023-09-05 01:35:49 <KipIngram   > I'm already wondering how well I could do using this very compact F18A based Forth.
2023-09-05 01:36:08 <KipIngram   > And implement everything from scratch.
2023-09-05 01:36:33 <Zarutian_iPad> how much ram did he have?
2023-09-05 01:50:58 <KipIngram   > 96 kB.
2023-09-05 01:51:22 <KipIngram   > On the DM42.  My docs say I've got about 72 kB for "user stuff."
2023-09-05 01:51:30 <KipIngram   > As a Forth fan, that seems like a ton to me.
2023-09-05 01:51:55 <KipIngram   > He's describing his internals - he shares some characteristics with Forth, but it's noT "a Forth."
2023-09-05 01:52:17 <KipIngram   > Of course, he has to have some degree of typing, so it can't be exactly a Forth.
2023-09-05 01:52:36 <KipIngram   > But what he's describing seems an awful lot like that typed "Octave like" system I've mused on.
2023-09-05 01:55:48 <KipIngram   > He uses { ... } for lists, [ ... ] for arrays, " ... " for text, and that << ... >> for code.
2023-09-05 01:56:30 <KipIngram   > A reference to any type of object can be stored in a cell, so that's where it's like that system I talked about.  Any object can sit on the stack.
2023-09-05 01:56:44 <KipIngram   > I think that's just essential for anything I'd think of as a "scientific" platform.
2023-09-05 01:57:07 <KipIngram   > I think you just can't be confined to integers as your only true "first class" sort of data.
2023-09-05 01:57:36 <KipIngram   > When you're working "at the metal" on the system implementation aspects of things, traditional Forth's integer-only approach makes great sense.
2023-09-05 01:57:59 <KipIngram   > But when you're up at the working application level, I think it needs to be more friendly.
2023-09-05 01:58:18 <KipIngram   > Forth might give you + for integers, f+ for floating point, etc.
2023-09-05 01:58:44 <KipIngram   > But on a calculator you only have one + button.  So that translates into one function needing to be able to do the right thing to anything you might want to "add."
2023-09-05 02:04:13 <KipIngram   > I like how he handles the menus.  Really takes advantage of all that screen space.  And I like his auto-completion.
2023-09-05 02:04:29 <KipIngram   > MrMobius: You were mentioning that aspect of the 48 a night or two ago.
2023-09-05 02:04:58 <KipIngram   > Wow - he claims 100x to 1000x the speed of the original calculators.
2023-09-05 02:05:09 <KipIngram   > Mostly from being on a 32-bit platform instead of a 4-bit Saturn.
2023-09-05 02:06:25 <KipIngram   > Oh, he supports algebraic expressions as a type as well.  That's ' ... '
2023-09-05 02:07:44 <KipIngram   > The help system is triggered by pressing and holding a key.  So pressing and holding SIN would take you directly to the help section on that function.  Nice.
2023-09-05 02:42:05 <KipIngram   > Mrmobius: Here's his latest update; this video was just posted a week ago.
2023-09-05 02:42:07 <KipIngram   > https://www.youtube.com/watch?v=nEDGWjpwBv0
2023-09-05 02:46:44 <MrMobius    > KipIngram: all of this just sounds like the original 48
2023-09-05 02:47:16 <MrMobius    > I skimmed the video and he seems to be making some firmware from scratch inspired by the 48 from what I can tell
2023-09-05 03:20:53 <KipIngram   > Yes, my impression is that most of his "work" has been on implementing a leaner system.
2023-09-05 05:29:29 <KipIngram   > Actually that's a kind of work I enjoy.  Taking something conceived by someone else, that I've already gotten to try out and know I like, and make it "better" in some way.  Smaller, faster, etc.
2023-09-05 05:30:07 <KipIngram   > I'm sure that Chuck and his disciples like Jeff Fox would contend that doing it (well) in  Forth would make it substantially smaller and simpler.
2023-09-05 05:30:17 <KipIngram   > That was his general position on such things.
2023-09-05 05:41:54 <KipIngram   > Somehow they never quite explained, *exactly* where those savings would originate from.
2023-09-05 05:44:13 <KipIngram   > I feel like part of it is in avoiding having your working data in RAM and moving it to and from the stack on every function call.  Forth sort of works with it "in place" in a way that other languages don't.
2023-09-05 05:45:01 <KipIngram   > Partially at least - sure, you still use @ and !.  But you move things in, work with them for "a while" and move them back out - instead of a round trip to the stack on every function call.
2023-09-05 05:46:05 <KipIngram   > It would be interesting to try to instrument that for various languages - what portion of the effort just involves moving data from one place to another?  That seems like it ought to be fairly well quantifiable.
2023-09-05 05:47:52 <KipIngram   > This F18A architecture doesn't really make calls theselves any more efficient.  If you do N calls one after another, that's going to consume N cells.  The gain comes from intermingling primitives - very often they'll go right into those same cells, so in that sense many of them are "space free."
2023-09-05 05:48:37 <KipIngram   > That makes me feel like the compactness advantage of this architecutre will be more pronounced the closer to the metal you are.
2023-09-05 05:49:06 <KipIngram   > That an assumption, though - I dont have any data to prove it.
2023-09-05 05:54:33 <KipIngram   > Oh, by hte way, another way of doing graph backgrounds (or parts of it, at least) might be to just load full bitmap images.  The grid, that sort of thing.  Then label it appropriately, and draw the curve.
2023-09-05 05:55:04 <KipIngram   > Those would be much more useful bitmaps than these cutesy "off screen" files they've got loaded on the thing.
2023-09-05 05:55:15 <KipIngram   > Though some of those are pretty neat, actually.
2023-09-05 05:55:27 <KipIngram   > It rotates through them, every time you turn it off.
2023-09-05 18:01:21 <MrMobius    > I've heard the "data in place" argument before. if you consider that most programs spend their time in loops, the time it takes to pass arguments on the stack is negligible
2023-09-05 18:01:36 <MrMobius    > assuming any of them even make it to the stack and aren't in registers
2023-09-05 18:02:27 <MrMobius    > I tried for example to statically analyze 6502 assembly and use zero page for locals but for that you need to know what calls what so they don't overwrite each others' locals
2023-09-05 18:03:05 <MrMobius    > it works and is fast but the next best way is just to free up some zero page registers by pushing their values to some type of stack
2023-09-05 18:03:53 <MrMobius    > so you easily find the break even point and see that as long as you do enough accesses in your loop, how you pass things doesn't much matter
2023-09-05 19:46:18 <KipIngram   > Well, sure - you can find a value to set your loop iteration to to push the overhead down as low as you want.  But you don't get to just choose that - it comes with the application setting.
2023-09-05 19:46:33 <KipIngram   > Not all applications provide the same opportunities to run tight loops.
2023-09-05 19:58:47 <KipIngram   > If you can find a solution approach that gives you that gift, you certainly should - just one part of solving a problem well.
2023-09-05 20:08:42 <KipIngram   > If calls are a low proportion of your code, then it doesn't matter if they aren't as efficient as possible.  But Forth explicitly encourages us to emphasize calls - the advice is more or less "more calls is better."  So one would hope that such a language would make those calls as efficient as possible, and Forth does - calls don't move any data around.  They do exactly and only *calls* - nothing more.  It
2023-09-05 20:08:44 <KipIngram   > can't get any more efficient than that.
2023-09-05 21:07:22 <Zarutian_iPad> been musing on porting eForth to CommanderX16
2023-09-05 21:08:25 <Zarutian_iPad> and I am cogitating on if I should support two kinds of docol
2023-09-05 21:09:53 <Zarutian_iPad> nope only one kind but each xt takes three bytes instead of just two
2023-09-05 21:10:41 <Zarutian_iPad> same format as jsrfar CX16 KERNAL provides
2023-09-05 21:11:21 <Zarutian_iPad> two bytes address abd one byte bank select
2023-09-05 21:15:05 <Zarutian_iPad> s/abd/and/