You don’t know how he does stuff like this. What does this even mean? It’s nonsense. Is it even syntactically viable?? Are you allowed to color text like that??? ARGH. Maybe you should ask him about it some time.
You see, at first glance, this code does look syntactically viable, but only if we don’t pair the brackets in the way the coloring implies. If we write the code like this:
Then it’s a loop bound to the lifespan of Universe 1. Inside that main loop, it’s running a loop bound to the inverse of Universe 2′s lifespan - my guess being that this loop only runs while Universe 2 is dead.
If Universe 2 is ever registered as ‘alive’, the program waits for the blue THIS to die, and then continues. And when the main Universe 1 loop ends, it will wait for the red THIS to die, and finally exits.
In other words: This program will exit when U1 is dead, U2 is alive, and both ‘bifurcated’ iterations of THIS are dead.
However, the red/blue coloring implies that the brackets are paired in a completely nonsensical way.
I’m with Karkat here, This is nonsense. You can’t put the top half of one code block inside another - at least, not in any language I’ve worked with. I’m sure there are weird, esoteric languages that do it, but it’s definitely not the syntax du jour.
This ‘merged bracket’ interpretation is probably the correct one, though, since the colors match up. The reason this compiles at all is probably due to the special behavior of bifurcate THIS[], which we’re not privy to.
I do have a theory about what bifurcate is doing here, but… oh my god , guys, this is so silly. Will I post it? I’m going to post it.
What if we’re meant to do the same?
If we view these two loops as not inside each other, but adjacent to each other in 3D space, then this code makes a lot more sense. Suddenly we’re just looking at two simple death loops - one which which exits when U1 dies, and one which exits when U2 lives.
They’re not blocking each other, because they’re probably executing on different threads, which may be the true function of bifurcate. Viewed like this, this code becomes a simple, multithreaded script that works similarly to my original interpretation - the difference being that now, the colors match up properly. It’s kind of beautiful, to be honest.
Now that I’m viewing this program as two threads, it seems as if the blue loop waits for the red thread to die before it can exit, and vice versa.
If I’m right about this, it means that this program is deadlocked - neither thread can exit, because it’s waiting for the other one. The two threads are back to blocking each other, and this program will never exit.
This code, when executed, immediately causes the user’s computer to explode, and places a curse on the user forever, along with everyone he knows, and everyone he’ll ever meet.
Not surprisingly, later on you would run this code in a fit of stupidity.
None of this, however, explains why it curses the user.
I think I need to borrow Karkat’s ~ATH manual.
