No, I was apparently just bored & wondered what would happen. I expected to get shocked, but not that badly, since I would have thought that people getting shocked all the time would have prevented so much charge buildup. (In retrospect, that obviously only applies to the outer surface that everyone else touches, not the inner one.)
If the slides are plastic & there are any sticks nearby, kids could still potentially injure themselves...I once stuck a wet stick (it had rained recently) into a crack (between 2 pieces, not broken) in a plastic slide & got a big enough static shock that I just fell down the slide limp & laid there for a while until I could convince my muscles to move again. (Meanwhile, every time I have accidentally made contact with 120V wiring, it merely tingled annoyingly at the site of contact.)
If only the passwords (& not usernames or URLs or whatnot) are encrypted & no checksum or other verification is used, then entering the wrong master password could very well cause it to decrypt to completely useless but structurally valid passwords.
Of course, care would need to be taken to ensure the result is always valid...probably have a "password format" field that indicates what format the password is allowed to have (at least 1 of each of these types of character, at least 8 characters & no more than 16, that sort of thing), then do a "base conversion" of sorts so that valid passwords map to consecutive integers. The only remaining problem is if the format does not pack nicely into an integral number of bits, since then you might get out-of-range values with certain choices for the master password, but this can either be ignored (you rule some fraction of the master passwords out but still have to do a lot of searching) or handled by randomly (not necessarily uniformly...) choosing any value that is equivalent modulo the number of passwords allowed by the format.
I found that I can write much more efficient QBASIC code after learning & using Haskell. (^_^)
Now, if only graphics in Haskell were as easy as QBASIC. (Unless one of the million or so mutually-incompatible graphics-related packages on Hackage does everything I want but I missed it.)
Ooh, & can they penalize websites for showing a "mobile"-style interface in desktop browsers? Or overflowing the width so I have to scroll even in full screen on a 4K monitor?
The space requirement is not infinite for reversible computing unless it is also infinite for irreversible computing (& thus equally impractical), even if you want a polynomial slowdown. The paper proves this. That 3 GHz CPU either has finite external memory (& thus loops or stops after at most exponentially many steps (or, in the real world, suffers hardware failure)) or infinite external memory (in which case, you have already solved the infinity problem).
Reversible Space Equals Deterministic Space says that for a Turing machine running in time T(n) & space S(n), you can get the space & time both linear in T(n) (as I suggested) or space O(S(n) log T(n)) with time O(T(n)^(1+epsilon)) or space O(S(n)) with time exponential in T(n). So there is a tradeoff, but the space does not have to be (more than linearly) worse if you are willing to wait (way too long, of course, unless you are already worrying about the heat death of the universe), & not much worse for space or time in the middle case.
Hmm. I suppose that can be true in an iterative setting (needing to store some data from every iteration), & that the only hope of avoiding that is rewriting the whole loop to be fully reversible so it does not consume space every iteration. (It cannot take more space than linear in the run time, at any rate.) I was imagining recursive functions with stack allocation for each, but I should know better since I use tail recursion all the time. So I guess I was only right about iteration- & tail-recursion-free code.
On the other hand, it should not require more than an exponential increase (hah, only exponential) in space for any terminating & non-interactive computation, since with that you could store every possible state of the original irreversible machine. For non-terminating computation, it is at worst linear in the runtime, as aforementioned.
B=A XOR B (leaving A unchanged) is a reversible operation & is what I meant. More generally, B=f(A) XOR B is reversible (in fact, self-inverse), where f can be any (even irreversible) function.
Sure, you need to save the input to otherwise-irreversible steps, but the point is that you can erase a known value, & since there was some method to compute the intermediate values in the first place, they can be removed from memory in reverse order. (This is a known method—I did not come up with it.) Then you only need enough memory to store the maximum intermediate storage size (which is not all intermediate results unless the computation is a single list of originally-irreversible steps with no subroutines & such), & you can eventually end up with just the answer (& any inputs) remaining in memory.
Reversible computing in no way requires infinite storage...you just compute something, copy the answer, & then un-compute it (by computing each value in reverse order & XORing it with its original copy, for example). You then only need storage for the maximum size of temporary data plus the final answer, just like now. You get a speed penalty for all that un-computation, of course, but not infinite storage. Plus, you can still expend energy occasionally to erase data (such as the data left over from correction of hardware errors), just as long as you do not do so much as to incinerate your computer.
Making use of reversible computing, we could build fully 3-D circuitry since there would be much less power to dissipate (although still some to correct hardware errors & perhaps to clean up crashed processes). This would in turn get around no longer being able to make smaller transistors, & thus could be one future direction. Fabrication might be more tricky, but more money could go into such projects if it is not going into smaller, smaller, smaller. Software would similarly require changes, but again, once there is no easy way forward, harder ones will be attempted, like has happened with methods of gold & oil extraction.
One use would be as a glasses-free 3D display (if they used something like a lenticular layer, although it would need to be active to adjust for viewing distance). Of course, the GPU would need to catch up, as you say.
In fact, it might make sense to have a 4K panel configured as an HD 3D display that allows screen rotation (& just double up the pixels in the currently-vertical direction)...that way, you only need twice the GPU power of an HD display rather than 4X. If the lenticular layer can be switched off entirely, it could even switch to full 4K (at a lower frame rate if necessary) for things like viewing text & relatively-static images.
"They" has historically been used as such, & some still use it that way. But of course, that has the same problems as "you" not distinguishing number does.
Did they try finding an entropy source on-calculator like Linux uses for/dev/random? It seems that reading from an unconnected address occasionally yields different values...maybe characterize the distribution to get a lower bound on its entropy, then let it run automated for however many seconds or minutes it takes to accumulate enough. It would be easier on the user than rolling a die a bunch. (Of course, it might be hard to rule out systematic trends in the bits returned without intimate knowledge of the physics of the hardware involved.)
For that matter...what about the slight bias of actual physical dice rolled by humans? You only get ~258 bits from 72d12, assuming it is perfectly random. You need extra rolls to get the full 256 bits needed (with a sufficiently high probability), plus some strategy (hashing?) to mix the slightly spread-out entropy into a maximum-entropy key.
If they use a flash drive with a (properly-implemented) hardware write protect switch, it might only allow one-way transfer, so this is still potentially useful as the return channel.
You do not necessarily need a more efficient CPU to block this. Less efficient would also do—just make every operation consume as much power as the worst.
People have done this on TI calculators (& likely other systems with similarly little shielding & sufficient clock rates). No hardware support needed—just cause some long enough trace (e.g. on the data bus) to oscillate at the correct frequency. Granted, a 6 MHz Z80 can pretty much only only do AM radio (& can only be picked up right next to the radio), but the principle is not new.
You could use reversible computing to crack (classical computing-based) encryption, so it would only take however much energy you need to keep the system shielded from the environment. The only potentially-unknown bits that need to be erased are those used for error correction.
I once got a rather disconcerting shock (painful tingling) from a single 9V battery while attempting to disconnect it from a circuit. I must have had something conductive on my hands. It was similar to the feeling of accidentally touching both prongs of a partially-inserted 120V plug.
On the other hand, I got a much worse shock from a plastic slide...it was so bad that I fell down the slide & could not move for a bit afterward. (I did go out of my way to poke a wet stick into a crack & reach the metal pipe holding it up, though.)
Slashdot Mirror
No, I was apparently just bored & wondered what would happen. I expected to get shocked, but not that badly, since I would have thought that people getting shocked all the time would have prevented so much charge buildup. (In retrospect, that obviously only applies to the outer surface that everyone else touches, not the inner one.)
If the slides are plastic & there are any sticks nearby, kids could still potentially injure themselves...I once stuck a wet stick (it had rained recently) into a crack (between 2 pieces, not broken) in a plastic slide & got a big enough static shock that I just fell down the slide limp & laid there for a while until I could convince my muscles to move again. (Meanwhile, every time I have accidentally made contact with 120V wiring, it merely tingled annoyingly at the site of contact.)
If only the passwords (& not usernames or URLs or whatnot) are encrypted & no checksum or other verification is used, then entering the wrong master password could very well cause it to decrypt to completely useless but structurally valid passwords.
Of course, care would need to be taken to ensure the result is always valid...probably have a "password format" field that indicates what format the password is allowed to have (at least 1 of each of these types of character, at least 8 characters & no more than 16, that sort of thing), then do a "base conversion" of sorts so that valid passwords map to consecutive integers. The only remaining problem is if the format does not pack nicely into an integral number of bits, since then you might get out-of-range values with certain choices for the master password, but this can either be ignored (you rule some fraction of the master passwords out but still have to do a lot of searching) or handled by randomly (not necessarily uniformly...) choosing any value that is equivalent modulo the number of passwords allowed by the format.
Skitter would approve, too. Well, unless she thought someone was competing with her.
It is fine...Haskell ignores extra parentheses. (Or maybe they did not feel like specifying (or looking up...) the precedence of their operators.)
I found that I can write much more efficient QBASIC code after learning & using Haskell. (^_^)
Now, if only graphics in Haskell were as easy as QBASIC. (Unless one of the million or so mutually-incompatible graphics-related packages on Hackage does everything I want but I missed it.)
Ooh, & can they penalize websites for showing a "mobile"-style interface in desktop browsers? Or overflowing the width so I have to scroll even in full screen on a 4K monitor?
The space requirement is not infinite for reversible computing unless it is also infinite for irreversible computing (& thus equally impractical), even if you want a polynomial slowdown. The paper proves this. That 3 GHz CPU either has finite external memory (& thus loops or stops after at most exponentially many steps (or, in the real world, suffers hardware failure)) or infinite external memory (in which case, you have already solved the infinity problem).
Reversible Space Equals Deterministic Space says that for a Turing machine running in time T(n) & space S(n), you can get the space & time both linear in T(n) (as I suggested) or space O(S(n) log T(n)) with time O(T(n)^(1+epsilon)) or space O(S(n)) with time exponential in T(n). So there is a tradeoff, but the space does not have to be (more than linearly) worse if you are willing to wait (way too long, of course, unless you are already worrying about the heat death of the universe), & not much worse for space or time in the middle case.
Hmm. I suppose that can be true in an iterative setting (needing to store some data from every iteration), & that the only hope of avoiding that is rewriting the whole loop to be fully reversible so it does not consume space every iteration. (It cannot take more space than linear in the run time, at any rate.) I was imagining recursive functions with stack allocation for each, but I should know better since I use tail recursion all the time. So I guess I was only right about iteration- & tail-recursion-free code.
On the other hand, it should not require more than an exponential increase (hah, only exponential) in space for any terminating & non-interactive computation, since with that you could store every possible state of the original irreversible machine. For non-terminating computation, it is at worst linear in the runtime, as aforementioned.
B=A XOR B (leaving A unchanged) is a reversible operation & is what I meant. More generally, B=f(A) XOR B is reversible (in fact, self-inverse), where f can be any (even irreversible) function.
Sure, you need to save the input to otherwise-irreversible steps, but the point is that you can erase a known value, & since there was some method to compute the intermediate values in the first place, they can be removed from memory in reverse order. (This is a known method—I did not come up with it.) Then you only need enough memory to store the maximum intermediate storage size (which is not all intermediate results unless the computation is a single list of originally-irreversible steps with no subroutines & such), & you can eventually end up with just the answer (& any inputs) remaining in memory.
Reversible computing in no way requires infinite storage...you just compute something, copy the answer, & then un-compute it (by computing each value in reverse order & XORing it with its original copy, for example). You then only need storage for the maximum size of temporary data plus the final answer, just like now. You get a speed penalty for all that un-computation, of course, but not infinite storage. Plus, you can still expend energy occasionally to erase data (such as the data left over from correction of hardware errors), just as long as you do not do so much as to incinerate your computer.
Making use of reversible computing, we could build fully 3-D circuitry since there would be much less power to dissipate (although still some to correct hardware errors & perhaps to clean up crashed processes). This would in turn get around no longer being able to make smaller transistors, & thus could be one future direction. Fabrication might be more tricky, but more money could go into such projects if it is not going into smaller, smaller, smaller. Software would similarly require changes, but again, once there is no easy way forward, harder ones will be attempted, like has happened with methods of gold & oil extraction.
Eventually the resolution becomes so high that you start getting interference between adjacent pixels' light...& then you get a holographic display.
One use would be as a glasses-free 3D display (if they used something like a lenticular layer, although it would need to be active to adjust for viewing distance). Of course, the GPU would need to catch up, as you say. In fact, it might make sense to have a 4K panel configured as an HD 3D display that allows screen rotation (& just double up the pixels in the currently-vertical direction)...that way, you only need twice the GPU power of an HD display rather than 4X. If the lenticular layer can be switched off entirely, it could even switch to full 4K (at a lower frame rate if necessary) for things like viewing text & relatively-static images.
"They" has historically been used as such, & some still use it that way. But of course, that has the same problems as "you" not distinguishing number does.
Did they try finding an entropy source on-calculator like Linux uses for /dev/random? It seems that reading from an unconnected address occasionally yields different values...maybe characterize the distribution to get a lower bound on its entropy, then let it run automated for however many seconds or minutes it takes to accumulate enough. It would be easier on the user than rolling a die a bunch. (Of course, it might be hard to rule out systematic trends in the bits returned without intimate knowledge of the physics of the hardware involved.)
For that matter...what about the slight bias of actual physical dice rolled by humans? You only get ~258 bits from 72d12, assuming it is perfectly random. You need extra rolls to get the full 256 bits needed (with a sufficiently high probability), plus some strategy (hashing?) to mix the slightly spread-out entropy into a maximum-entropy key.
If they use a flash drive with a (properly-implemented) hardware write protect switch, it might only allow one-way transfer, so this is still potentially useful as the return channel.
You do not necessarily need a more efficient CPU to block this. Less efficient would also do—just make every operation consume as much power as the worst.
date '+%-m.%d%y%-H%M%S'
Logically would be 2015/3/14. Or rather, that is big endian & the other way little endian. I suppose 3/14/2015 is, then, American endian...
People have done this on TI calculators (& likely other systems with similarly little shielding & sufficient clock rates). No hardware support needed—just cause some long enough trace (e.g. on the data bus) to oscillate at the correct frequency. Granted, a 6 MHz Z80 can pretty much only only do AM radio (& can only be picked up right next to the radio), but the principle is not new.
You could use reversible computing to crack (classical computing-based) encryption, so it would only take however much energy you need to keep the system shielded from the environment. The only potentially-unknown bits that need to be erased are those used for error correction.
& of course, the line installation people would have been towing the party line.
I once got a rather disconcerting shock (painful tingling) from a single 9V battery while attempting to disconnect it from a circuit. I must have had something conductive on my hands. It was similar to the feeling of accidentally touching both prongs of a partially-inserted 120V plug. On the other hand, I got a much worse shock from a plastic slide...it was so bad that I fell down the slide & could not move for a bit afterward. (I did go out of my way to poke a wet stick into a crack & reach the metal pipe holding it up, though.)