WOAAAAHHHH I Posted! (significant Progress On Functions)

Learn ~ATH turned 1 today!

yaaaay!

So I think that my explanations of things hasn't been very clear so far, and while I can't promise that they will improve, I do intend to teach programming in person at my school, which might help me to know how to make this tutorial better. Maybe, maybe not. 

May things go well!

Welcome.

If its not obvious, this blog will teach techniques in a version of ~ATH Specifically, drocta ~ATH. And yes, I'm serious. I believe that I probably am the author of the longest ( possibly up to third longest) ~ATH program. Specifically, bubble sort. Further, I believe I am the author of the first ~ATH interpreter. (I am the drocta of drocta ~ATH) Link here: http://www.mspaforums.com/showthread.php?50314-ATH-interpreter This blog is intended to serve as a tutorial on writing things in drocta ~ATH. First I will go over the syntax. Then how to make conditional like things. Then how to make finite loops. Then perhaps storing "numbers". Then copying "numbers" Then comparing "numbers" Then lists In such a way I intend to work our way up to you understanding how to write bubble sort in drocta ~ATH. After that, we might even implement brainf*** in it. Or a universal Turing machine. Of course, when I say "numbers", the quotes are there for a reason. Numbers are not built into drocta ~ATH. One has to build them. Now how do I tag things...? Ah, that's how. In case it wasn't clear, the interpreter for drocta ~ATH does not attempt the impossible. It cannot trigger the apocalypse. It's just a python script that interprets ~ATH scripts. Don't worry if you don't already know how to program. I intend to make the posts fairly accessible.

Conditionals and (finite) loops

In drocta ~ATH, the control flow (what part of the program is run when) is almost entirely determined by ~ATH loops.

The only case where it isn't is when the object initially pointed to by THIS dies. That ends the program immediately. 

This post will show in more detail the basics of its usage.(also introduces the variable NULL)

Is there anything in this post that needs to be clarified?

In a program, you might want something to only happen if something else is true, or you might want it to happen provided that something had not happened.

In many programming languages you would use a command called if.

drocta ~ATH does not have an if statement.

Instead, you create a loop on an object, and inside the loop kill the object.

A little morbid, but isn't ~ATH always?

for example:

SOMECODEHERE ~ATH(SOMEVAR){ SOMEVAR.DIE(); SOMEOTHERSTUFF } SOMEOTHERSTUFF 

However, this isn't the only way. There is another way that is likely preferable in most situations. I just thought this way was the most obvious, and would be an easy way to explain the other method, which is quite similar.

The loop doesn't exactly wait for the object to die, but rather repeats so long as the variable points to an object that is alive. The variable can be made to point to an object that is not alive, either by make the object it points to DIE(), or by making it so it points to a different object that is ALREADY DEAD.

(How can you expect to kill it, when it is ALREADY DEAD?!? haha)

So if the object you wanted the part of the script to run if it was alive was important, and you didn't want to kill it, you could just do this:

BIFURCATE [IMPORTANTOBJECTVAR,IMPORTANTOBJECTVAR]BLAH; BIFURCATE BLAH[V,V]; ~ATH(V){ BIFURCATE [V,NULL]V; BIFURCATE V[JUNK,V]; OTHER CODE TO ONLY EXECUTE IF IMPORTHATOBJECT IS ALIVE } 

Thats nice to be able to do, isn't it.

In fact, it leads nicely into how to make loops that go around a fixed number of times.

suppose if you had

BIFURCATE [BLAH,NULL]V; ~ATH(V){ BIFURCATE V[BLAH,V]; DO OTHER STUFF, POSSIBLY WITH BLAH  }  MORE STUFF 

V would initially be alive, so it would go into the loop, but then V would be made to point to the NULL object, which is dead, so it wouldn't loop the second time.(it would skip to after the loop

that would do the stuff in the loop once.

now what if you wanted to do it twice?

Just make it so it has to bifurcate the thing twice before moving on! Like so:

BIFURCATE [BLAH,NULL]V; BIFURCATE [BLAH,V]V; ~ATH(V){ BIFURCATE V[BLAH,V]; DO OTHER STUFF, POSSIBLY WITH BLAH  }  MORE STUFF 

 this way it will go through the loop, pop off the one side of V, doing the other stuff in the loop. V will still point to something alive after this, so it will do it again, but this time, when it pops off one side of V, the result will be the NULL object, so it will stop.

Thats a loop that goes around twice!

This can be extended to as many number of repetitions as follows:

BIFURCATE [BLAH,NULL]V; BIFURCATE [BLAH,V]V; BIFURCATE [BLAH,V]V; BIFURCATE [BLAH,V]V; ETCETERA BIFURCATE [BLAH,V]V; ~ATH(V){ BIFURCATE V[BLAH,V]; DO OTHER STUFF, POSSIBLY WITH BLAH  }  MORE STUFF 

where the loop will go around however many blahs there are attached to the NULL, because it will keep popping the BLAHs of until it reaches NULL.

The variable V is being used to store how many more loops need to be executed, Which is a number.

V is being used to store a number. 

You might be thinking something along the lines of

"Well this is all very nice, but that seems to only allow for loops that loop a predetermined amount of times."

NOT SO!

You can have another loop that makes a variable point to a number, which would then be in another loop! For example, the following will add two numbers in A and B, store the result in C, copy that result to CTEMP, and then print "some text" the ammount of times in CTEMP!

SOME CODE TO GET A AND B HERE import bluh BLAH; BIFURCATE [BLAH,A]ATEMP; BIFURCATE [BLAH,B]BTEMP; BIFURCATE ATEMP[JUNK,ATEMP]; BIFURCATE BTEMP[JUNK,BTEMP]; BIFURCATE [BLAH,NULL]C; BIFURCATE C[JUNK,C]; ~ATH(ATEMP){ BIFURCATE ATEMP[JUNK,ATEMP]; BIFURCATE [BLAH,C]C; } ~ATH(BTEMP){ BIFURCATE BTEMP[JUNK,BTEMP]; BIFURCATE [BLAH,C]C; } BIFURCATE [BLAH,C]CTEMP; BIFURCATE CTEMP[JUNK,CTEMP]; ~ATH(CTEMP){ BIFURCATE CTEMP[JUNK,CTEMP]; print some text; } print DONE!; 

YAY! We just added two numbers together! In similar ways, we can also subtract, multiply, divide, etcetera! 

if some of this was unclear I would appreciate requests for what needs to be clarified.

Is there anything in this post that needs clarification?

My ~ATH keeps crashing whenever I run a non-computer exploding code, or if I press enter. Why is this?

Based on the username which recently followed this blog at the same time as I received this ask (which I won't say what it was because you asked this on anon, and haven't received permission), I'd guess that you may be running a different version of ~ATH than the one I document here :P

Unfortunately, I don't have a specification for the version you have.

If you have such a specification, or the executable for it, I'd be happy to take a look if you could send it to me, haha.

If on the off chance you are using the version I document here, then presumably you have a syntax error or something in your code?

ok, made some small commits...

(no features added, but cleaned up some code and added example programs)

yup.

it has the basis for how I am going to make functions if I make them, and cleaned up the code for BIFURCATEion, and removed some lines that were commented out.

if you want the new version it is on the github.

no real difference when it runs though.

(if something you wrote doesn't work with the new version, try using BIFFURCATE instead of BIFURCATE to use the old code. You probably won't need to, though. It works fine for me. and you probably haven't written anything in it anyway, because you kind of have to uh, want to, I guess)

yeah, can i make ~ATH continue to generate variables? like if one part of the program dies it generates another variable? because i've been trying to do that lmfao

Hi. Not sure what you mean by continue to generate variables. If you mean like how in lisp you can like, automatically generate a new variable name and then use that variable name, then no, drocta ~ATH doesn't have a feature like that, but I'm guessing that's not what you mean.

Variables are just like, names in your program. If you want more objects, you can just continue bifurcating objects to get more objects.

drocta ~ATH does not support parallelism or concurrency or whatever (though presumably canonical ~ATH would, in some sense. At least, it appears to handle circumstantial simultaneity.), So, if you are referring to drocta ~ATH, then I'm not sure what you mean when you refer to part of the program dying. Though, given that in canonical ~ATH, there is the expression

[THIS,THIS].DIE();

then it seems like, presumably, it should be possible to have something like

THIS.DIE();

in order to describe part of the program dying (ending), without another part doing so.

But, again, drocta ~ATH does not support anything like that. Feel free to make a fork of it which does though. Please let me know if you do!

Is drocta ~ATH case- and whitespace-sensitive? For instance, would "BIFURCATE 2NULL[JUNK,BLAH];" do the same thing as "bifurcate 2NULL [JUNK, BLAH];"? Also, is there a difference between calling .DIE() on an object and setting it to NULL? Your tutorials seem to be written as if there were a difference. And finally, I'm still unsure about what "BIFURCATE [CMP0,ZEROCHAR]D;" and "D.DIE();" are supposed to do in regards to interpreting the user-inputted character.

drocta ~ATH is case sensitive in most cases, and white space sensitive in some cases. line breaks/new lines are not neccessary for example.

if I said "bifurcate 2NUL[JUNK,BLAH]; that would by a typo on my part. It should be BIFURCATE.

if people want I could make it not case sensitive, but currently it is.

there is a VERY IMPORTANT (if subtle) difference between setting a variable to null and calling .DIE on an object.

in drocta ~ATH, there are variables and objects. Every variable "points to" or "references" an object. The object that a variable points to does not necessarily stay the same. if you have some variable "C", and then you say BIFURCATE SOMETHING[C,JUNK];

instead of pointing to what it was pointing to before, it points to the left half of whatever SOMETHING is pointing to.

This doesn't make the object no longer exist however. It might be that no variables point to it anymore, but it still is stored in memory.

More than one variable can point to a given object.

If variable A and B both initially point to the same object, and then you change A so that it points to a different object, B will still point to the object that they were pointing to at first.

so if A and B both point to some object (which is initially alive), and then A is made to point to the object initially pointed to by NULL (which is initially dead), then A will point to an object that is dead, but B will still point to an object that is alive.

In contrast, if D and F are pointing to the same object, which is initially alive, and one says "D.DIE();", the object that D points to will die (become dead). D and F still point to the same object, but this object is now dead. So both D and F point to a dead object.

about the user input part:

BIFURCATE [CMP0,ZEROCHAR]D;D.DIE();

determines some object, temporarily pointed to by D, which has the object pointed to by CMP0 as its left half, and the object pointed to by ZEROCHAR as its right half. It then kills this object.

the purpose of this, is so that if one has some character object (from the input statement), and wants to know if it is '0', then one can determine the object that has the object pointed to by CMP0 as the left half, and the object that you want to test as the right half. If the object you are testing IS '0', then the object that you get should be the same one that you killed, so it should be dead. If it is not '0' but rather, say, 'z' or just some object that doesn't have a corresponding character, it will result in some other object, which has not been killed, so it is still alive.

I hope I cleared up some of your questions.

okay, this might be a liiittle specific, and more HS oriented, but still. can you power a First Guardian using ~ATH? and if so, what are some ways?

This is a slightly off of the usual topic of this blog, which is more about a language which I made up and is based on and named after the language in the comic, and attempts to be as close to the comic while still being possible to implement and use, (the language in the comic is not particularly well documented), but I’ll answer it to the best of my abilities.

I’m not sure what you mean by “power”.

“Can I write a first guardian character that has some of their behavior be based on ~ATH in some ways?” : I don’t see any reason why not. If you can do ectobiology with a puppet and a cueball, why not with a computer running a program?

“Can I make a first guardian character who is a first guardian because of the continual execution of a ~ATH script?” : While you can of course write whatever you want, I’m not sure that this is consistent with what is said in acts 1-7 (I have chosen to disregard everything after act 7) about first guardians. It seems like an entity either is or is not a first guardian, and that this fact is established at the time of that entity’s creation. It seems to me like what happens with first guardians is: using ectobiology, the genetic code from some players’ subconscious-or-whatever is combined with some other source(s), and the result is a first guardian.

Oh, I suppose if you just mean “an entity has the powers of a first guardian as a result of a ~ATH script”, then, uh, I guess that doesn’t contradict anything. How would I depict such a script? Well, I don’t know that anything that we’ve seen of the language gives any particularly clear direction for what such a script would look like. If you want it to just have the keywords we’ve seen, possibly re-interpreted to mean something different, I guess one idea could be to like, say bifurcate an existing first guardian into parts with names that seem relevant, and also whatever entity is to have the abilities of a first guardian, and then like, un-bifurcate (unbifurcation is not something shown in the comic, but is something I’ve added to my language, in order to make it usable) the other entity, but with some component of the first guardian mixed in somehow? Though if you did that, you would probably want to justify why, if ~ATH can do that that easily, why it doesn’t happen all the time.

There is very little in terms of rules that the story gives for how ~ATH behaves. If you want to have a ~ATH script “power” a first guardian, just make up some stuff. If you want to depict the actual script, then look at all the pages of the comic that depict code from it, see what it says they do, and just make something up that seems to aesthetically fit.

The language that I have defined (”drocta ~ath”) does not provide any means of doing this, because the language I designed was designed to technically be usable, while also resembling the language in the comic.

I suppose that, as all first guardians get their power from the green sun, and the green sun was created by the circumstantially simultaneous destruction of, uh, either universes A and B, or specifically of A2 and B1, not sure which, and this was in some ways tied to the Möbius Double Reacharoud virus, you could argue that all first guardians get their powers from, something somewhat connected to a ~ATH script.

Why can’t I add tags to an answer to an ask?

Do you know of any ~ATH implementations or dialects besides yours and mine?

Actually, yes kinda. Sorta anyway. There is a compiler of sorts that is intended to be ~ATH based, though I don't think it matched canon all that well.

It did have one feature which I found interesting though. It had a command which would create a variable thing which was truthy iff there was a process currently running with a given name, so you could have in a ~ATH loop something that loops until another program is closed. It was a pretty cool feature, but the syntax for it was odd. The author misinterpreted the panel where Sollux deletes the different virus folders he had, so the command was called rm -rf or something like that.

It also had a command to run an executable (by file name) iirc.(which allowed for easy implementation of the robin hood and friar tuck programs)

It also was an editor of sorts, but it had a small window that I don't think was resizeable. It worked (iirc) by doing some string replacement to turn the program into a c(++?) program, which it then compiled.

I'll try to find it  so I can link it. I don't think it represents ~ATH all that accurately, but the using another program as one of the objects seemed like a neat and probably accurate feature (given the mobius double reacharound)

tl;dr yes

Happy 10/25

Today is the 10 year anniversary of the destruction of the universe frog. Such an occasion is traditionally celebrated by destroying the universe.