2023-05-24 08:57:21 <KipIngram   > Seems like there has been a rash of Quora questions recently all related to things "not existing" when they're not observed.  It's a big misconception - that is NOT what the theory claims.  What happens is people conflate the "state" of a thing with its measurable properties.  The quantum STATE always exists.  But any given PROPERTY may or may not have a value when the system is in some particular state.
2023-05-24 08:57:40 <KipIngram   > What happens is that when you measure a property you push the system into a state that DOES have a value for that property.
2023-05-24 08:58:07 <KipIngram   > But even before you measure it's in SOME state.
2023-05-24 08:59:12 <KipIngram   > An electron either exists or doesn't exist - if it exists it exists all the time.  But it may not have a position unless you measure position.
2023-05-24 08:59:53 <KipIngram   > And whenever you measure a particular property, there is some "partner property" that you cause NOT to have a value.  For position it's momentum.
2023-05-24 09:01:28 <KipIngram   > I think the confusion arises because in classical physics the state usually IS a collection of properties.
2023-05-24 09:04:50 <KipIngram   > Unfortunately, classical states always wind up containing properties all of which can't exist at the same time, which is exactly the origin of quantum uncertainty.
2023-05-24 09:10:28 <KipIngram   > So, this is basically the top level structure of my system:
2023-05-24 09:10:32 <KipIngram   > Stay safe and well!
2023-05-24 09:10:34 <KipIngram   > Kip
2023-05-24 09:10:36 <KipIngram   > ____________________
2023-05-24 09:10:38 <KipIngram   > If you enjoy my answers, please consider supporting my work at https://kipingramsspace.quora.com/.
2023-05-24 09:10:58 <KipIngram   > Ugh.  Sorry.  :-(  I keep forgetting that my terminator copies with shift-ctrl-c instead of ctrl-c.
2023-05-24 09:11:15 <KipIngram   > : cold ...initialize everything...
2023-05-24 09:11:17 <KipIngram   > : warm  sp0 @ sp! snap
2023-05-24 09:11:19 <KipIngram   > : err  ...unsnap...
2023-05-24 09:11:21 <KipIngram   > : quit  rp0 @ rp! snap query interpret ok me [
2023-05-24 09:11:39 <KipIngram   > I have unsnap factored off into a word, and that's why I wind up needing to save that one return address across the unsnap operation.
2023-05-24 09:11:55 <KipIngram   > If I were to move it inline I wouldn't need to do that.
2023-05-24 09:12:38 <KipIngram   > Error recovery transfers control to err (that's not actually the label I use - err is a word).
2023-05-24 10:31:06 <KipIngram   > You know, the "standard" approach to meta-compile in Forth does presume that you're building a dictionary that has the same structure as the one you're running.
2023-05-24 10:31:45 <KipIngram   > That's what makes it possible to leverage the running system's tools for dictionary construction.  If you're writing a "new" system that approach falls flat and you have to do more from scratch.
2023-05-24 10:31:54 <drakonis    > something something futamura's projections?
2023-05-24 10:32:41 <KipIngram   > Uh... that's not something I'm familiar with.
2023-05-24 10:33:04 <KipIngram   > Reading about it now, though.
2023-05-24 10:33:31 <drakonis    > its partial evaluation
2023-05-24 10:35:09 <KipIngram   > The system I'm planning is different from the one I've got, so I'll have to write it all from scratch.  But I still want the system I write to be able to rebuild itself in the traditional way.
2023-05-24 10:36:00 <KipIngram   > In my case that mostly means keeping up with base addresses properly.
2023-05-24 10:36:18 <KipIngram   > Base addresses of the system I'm running vs. base addresses of the system I'm building.
2023-05-24 10:36:50 <KipIngram   > Normally they'll be the same.
2023-05-24 10:37:54 <drakonis    > its largely about metacompilation from what i understand
2023-05-24 10:38:31 <drakonis    > rather, chaining abstractions into increasingly lower levels
2023-05-24 10:39:01 <drakonis    > i want to do something like that with my forth implementation after building up enough of it
2023-05-24 10:39:28 <KipIngram   > I'm sure I'll wind up thinking about it in a less than completely "formal" way.
2023-05-24 10:39:39 <KipIngram   > Being an EE guy rather than a CS guy.
2023-05-24 10:39:50 <drakonis    > eh, that's not really an issue
2023-05-24 10:40:24 <drakonis    > but the gist of it is what i mentioned
2023-05-24 10:40:25 <KipIngram   > Main idea for me is that when I stuff a cell into a definition it's stored as an offset from the base of the system.
2023-05-24 10:40:34 <KipIngram   > The low level code turns those into addresses.
2023-05-24 10:40:46 <KipIngram   > So that process has to use the RIGHT base address.
2023-05-24 10:40:58 <drakonis    > high level machines generating lower level machines until you reach the lowest level
2023-05-24 10:41:13 <drakonis    > its a compiler compiler, if you will
2023-05-24 10:41:30 <KipIngram   > Sure.
2023-05-24 10:41:54 <KipIngram   > But at the same time, in the normal Forth way, it's "mostly" just "the compiler."  The same one you always use.
2023-05-24 10:42:00 <KipIngram   > Just with these "minor corrections."
2023-05-24 10:43:33 <drakonis    > yes.
2023-05-24 10:43:42 <drakonis    > which, to be honest, isnt too far from how forth normally operates.
2023-05-24 10:43:55 <KipIngram   > Right.
2023-05-24 10:44:25 <KipIngram   > After all, you can write a new QUIT loop and run it anytime you want to.
2023-05-24 10:46:24 <drakonis    > sometimes i wonder if i should've done something different
2023-05-24 10:47:12 <drakonis    > because low level programming is pretty cool
2023-05-24 10:48:07 <drakonis    > what i'm doing at my dayjob is the furthest away from that as possible
2023-05-24 10:49:18 <thrig       > ... in 20 years: seeking low level kubernetes programmer to ...
2023-05-24 10:49:21 <drakonis    > lol
2023-05-24 10:49:32 <drakonis    > i have to do kubernetes wrangling at work and i wish i was doing anything else
2023-05-24 10:49:50 <KipIngram   > Low level is cool, but honestly the high end stuff has a good bit of cool too.
2023-05-24 10:49:54 <drakonis    > as i stare longingly at my assembly code waiting for the moment to present itself so i can do this
2023-05-24 10:50:39 <drakonis    > high level stuff is cool as well, though going too high level and its just using things people already wrote
2023-05-24 10:51:42 <KipIngram   > That's true, and I do love feeling like I've done something entirely myself.
2023-05-24 10:52:08 <drakonis    > only consuming does not spark joy
2023-05-24 10:52:26 <thrig       > first, we collect some silicon, and then
2023-05-24 10:52:39 <drakonis    > it doesnt have to be that low anyways
2023-05-24 10:57:37 <KipIngram   > Sand.
2023-05-24 10:57:41 <KipIngram   > We collect sand.  :-)
2023-05-24 10:57:54 <drakonis    > zap some sand to give it life
2023-05-24 10:58:13 <KipIngram   > I get quite a kick out of the fact that that's basically what our whole electronics sector is made of.
2023-05-24 10:58:23 <KipIngram   > We're wizards, and we use sand in our spells.
2023-05-24 10:58:34 <drakonis    > ha, yeah.
2023-05-24 11:01:55 <KipIngram   > Bubble bubble, toil and trouble...
2023-05-24 11:02:32 <drakonis    > lightning and earth...
2023-05-24 11:03:59 <KipIngram   > So, I read that Liz Rather note on how breaking the compiler out into its own word, instead of having a STATE smart integration with the interpreter, simplifies meta compilation.  I think I see what motivated that.  But I'm not sure I actually need it - it's mostly about handling IMMEDIATE words during meta work, and I've removed most of the problematic ones from my design.
2023-05-24 11:04:18 <KipIngram   > At the moment I don't see that I'd have any trouble meta compiling with a more standard integrated interpreter/compiler.
2023-05-24 11:06:22 <thrig       > I recall eforth doing some tricks for metafoo
2023-05-24 11:11:49 <KipIngram   > I no longer have IF THEN, BEGIN AGAIN, etc., or any words of that ilk.
2023-05-24 11:12:43 <KipIngram   > Those conditional looping words ("me" words) I use are different, though, because they all need to have an offset cell compiled after then.
2023-05-24 11:12:51 <KipIngram   > I handle that with a bit in their header, though.
2023-05-24 11:13:07 <KipIngram   > It's still just a standard "immediacy-free" compilation.
2023-05-24 12:03:24 <KipIngram   > So right now I have a fairly substantial amount of machine code init stuff, before I launch the  Forth vm.  I think, though, that I may be able to cut that down - if I set the registers up right and establish a temporary stack zone, I should be able to run definitions out of the initially loaded image.
2023-05-24 12:03:50 <KipIngram   > What I can't do is store to variables, there, because those locations are in the code section and it comes in write-protected.
2023-05-24 12:04:10 <KipIngram   > But I think I'll see if I can leverage that into having more of the init be written in Forth.
2023-05-24 12:12:23 <KipIngram   > Ok, so inlining a sequence of primitives into a newly generated primitive would be an example of this "partial evaluation"?
2023-05-24 12:15:33 <KipIngram   > And it looks like compiling a Forth definition is precisely one of those Futamura projection things.
2023-05-24 15:04:22 <KipIngram   > Wow.
2023-05-24 15:04:27 <KipIngram   > https://www.livescience.com/animals/orcas/orcas-have-sunk-3-boats-in-europe-and-appear-to-be-teaching-others-to-do-the-same-but-why?utm_source=Nature+Briefing&utm_campaign=80cd7e3e52-briefing-dy-20230524&utm_medium=email&utm_term=0_c9dfd39373-80cd7e3e52-44313705
2023-05-24 15:04:35 <KipIngram   > The whales are fighting back...
2023-05-24 15:35:38 <KipIngram   > My gosh - there is such ridiculous inefficiency in our networking protocols.
2023-05-24 15:36:11 <KipIngram   > All in the name of historical compatibility.
2023-05-24 15:54:14 <thrig       > intel has lobbied for little endian sends, now and then
2023-05-24 15:55:19 <KipIngram   > I've not muddled into that part of it all in the networking context, but usually when I think about endian stuff, I wind up deciding that little endian is more sensible.
2023-05-24 16:22:31 <KipIngram   > Yeah, I think this "lean init" could work out nicely.  As far as I could tell, in the system I'm running now I could set six registers and jmp r15, and take it from there in Forth.  I'd  have to honor some limitations until I transfered to the live system, but it looks straightforward.
2023-05-24 16:24:05 <KipIngram   > Forth would malloc the necessary RAM regions and copy the various pieces of the system into their final location, and then I'd have a primitive that "transferred control" into the copy (basically would just change those registers to their final values).
2023-05-24 16:24:28 <KipIngram   > Then I could finish init (save and update termios, etc.)
2023-05-24 16:25:32 <KipIngram   > That's definitely how I'll approach this next system.
2023-05-24 16:25:56 <KipIngram   > It's tempting to go back and change the old one, but I'm not sure yet.
2023-05-24 16:28:38 <KipIngram   > Also, having a word (create) seems like a good idea.  It would take a code snip address on the stack and point the new word's cfa at it.
2023-05-24 16:28:41 <KipIngram   > Then
2023-05-24 16:28:49 <KipIngram   > : var  (var) create ;
2023-05-24 16:29:00 <KipIngram   > : :  (:) create ;
2023-05-24 16:29:01 <KipIngram   > etc.
2023-05-24 16:29:15 <KipIngram   > Pardon the logical flaw in that last one - you get the idea.
2023-05-24 16:29:29 <KipIngram   > Oh, sorry - both of those should say (create) instead of create.
2023-05-24 16:30:21 <KipIngram   > In past systems CREATE has always set the CFA to (var) and then I've had to diddle it after the fact to handle other situations.
2023-05-24 16:56:29 <KipIngram   > One of the features of this new system will be no headers whatsoever for "wipable" words.  I'm working those details out now.  Basically involves maintaining two areas I can put headers in, and every time .wipe comes along it'll correct links and delete the transient data.
2023-05-24 16:57:30 <KipIngram   > Links are 14 bits, into 16-bit aligned data, so that's 32k range.  So I'll probably open new transient regions 16kB above the permanent data.
2023-05-24 16:58:47 <KipIngram   > Or something along those lines.  Links need to temporarily be able to reach both directions, though once I wipe all forward ones will be gone.