It sounds stupid, but you guys know flip flops, if the input is 00 then it is dual state and leaks memory to get back to its orignoal state, well I looked at commandblockguys: Memory leaks as a feature and thought, that if that is the coveted 00 state being stored as a var, can we reveares this process and create a var that then is leaked that many times? Can we utlize this both ways?

Could you clarify your question?

When a memory leak happens because you used Goto out of a control flow block, the object that's leaked is not a variable like X or Str1 but an entry on the operator stack that represents the block that was skipped out of.

Yea and you can measure that in the form of a variable, like it represents, in theory, the Third state, like in a flip flop input 00, its both 10 and 01

What I’ve been doing is I’ve been trying to work on a way to write things to it like right now the program you made allows us to recall the amount of times that go true for the amount of times you’ve leaked, and if we figure out a way to go the other way, then technically we can use that as a third state in binary. This experiment is more a sized version to test the theory possible as possible with this and it’s also possible with the ones and zeros

Edit by administrator: please don't multi-post within 24 hours

Trying to understand:
So
1. leaking memory with goto changes memory contents
2. We can read that value in basic (?)
3. You want to use that as a variable (??)
Is your issue "cant decrement the value"? Like, "i can add 1 but not subtract"?
If that, I'm fairly sure that *isnt* a thing you can do.

Yea we can read it, and if we can write to it then we can have a system based on it. Like the number is stored in leaked, like if 1 on and 0 is off, this section is gone completely, and we count how long of s gone


I'm working on a write into read without the usage of any var name

Edit by administrator: posts combined. Please don't multi-post within 24 hours.

So, you plan to use the memory leak value as a variable, but its not, say, A-Z?
(as in, "I will put this number into the area where we track memory leaks, and then, I'll read it later. That's a variable!)
I don't see any reason *why* you'd want to do that, but then again, I could say the same about stuff I've done.
So, if you're trying to write a value using memory leaks, and read it later, thus using it as a variable, you *can*, but I can't think of any time that'd be a good idea (your variable leaks memory, that's a *lot* worse than any variable's memory usage)

I'm trying to understand what you're talking about here, and I think you may be mixing up one or more of several concepts:

1. S-R (set-reset) flip-flops typically have two inputs, the eponymous set and reset lines. Set asserted with reset release will set the flip-flop, reset asserted with set released will reset the flip-flop, both released does nothing, and both asserted is an illegal state. Both released does not change the state (nor does it go into a floating state). And there's no way to turn time backwards to go back to a previous state.
   
2. Tri-state buffers. The three states are 0, 1, and high-impedence. These are not binary devices: they require at least two inputs, one for the data value (i.e., 0 or 1) and one for the enable (i.e., output the input, or go high-impedence). This is three states with 2 bits, perfectly legal.

Yes, I am, what I'm talking about is like the concept behind it, like the idea of creating an extra state, like what commandblockguy said about end stack as data storage like reading or writing data in the idea of leaking data, like the concept of creating a value of the leak that we measure and store as a var but can we assign a value to the leak? I don't think Im making sense, but like its the concept that the flip flop input of 00 presents, like not like the third state of Binary, but like in a flip flop, it ethier is a 1 or a 0, but since the ouptut is both 0 and 1 in both places, it creates an output (correct me if I'm wrong beucase I am yapping at this point) of un known, so the idea is that if we record one output of the flip flop, which should be binary, 1 or 0, instead its dissalowed in the ideal math state becuase a flip flops input will never be 00 but if it is or in this case with the ESADS we find that we are recalling data that doesn't exist
PS: sorry for double posting and also I came up with this idea at 10 so I think the analogy I made with binary is most definitely wrong

Each stack entry effectively only holds a reference to the command that started the block, so it's not possible to directly store a value in it. With that being said, it is possible to distinguish between different stack entries, which you can use for data storage.

For example, this program lets you type in a number, and once you press enter, it will print out the digits you entered in reverse order:
Code:


I'm not sure exactly how much data you can store this way, but it's substantially more than the 999-entry limit for lists. I ran a modified version of this that always enters 0 for about 20 minutes and it got up to 3000 entries with no errors.

Wow, that’s actually really cool, my question is if we can emulate this down to pure circuitry and if we can do a similar thing in case of 00 in binary like quantity how many times the message appears. Yea if we can emulate logic circuitry to do a similar thing, like have an output of 00 be quatified as one and then if we get another we store it as two, like a similar thing

Sorry, I still don't think I understand your question. Are you asking if you can do something similar to this with just logic circuitry, or if you can implement logic circuitry using this?

I think you might be confused about where the "storage" is coming from in the TI-BASIC example: the data is still being stored in the calculator's memory (which is finite in size), it's just being stored in a place that's mostly hidden from BASIC programs (and users in general) but is readily accessible to the calculator's OS. There's nothing magic about this, it's just taking advantage of behaviors of the BASIC interpreter that are basically bugs in order to stash data somewhere in memory that isn't meant to be used that way.

Ah, so its still a built in functionality and the only reason it can be done is that the Basic reader works like that. Ok. Well, just like my freind said to me, "Your not that guy" so I think that I am wrong.