Merry Christmas!

How exactly would one go about downloading and running your ~ATH interpretation? Where can we download it and what is needed to run it?

“Hi! My interpreter is on my github account [here], along with a number of example files.

To run it, you need to have python 2.7 installed. (Other versions of python 2 may also work. I don’t think it quite works in python 3, but running it through a python 2 to python3 converter should probably give you a working python 3 version)

You can get python 2 at https://www.python.org/downloads/ .

The current version of python 2 is 2.7.13 . Currently that python download page has a link directly to the download on it. (If anyone is reading this post much later than January 1 2016 and the page has changed in the meantime, feel free to send me an ask asking where the current download link for python 2 is).

Once you have python 2 installed, download the interpreter from my github, https://github.com/drocta/TILDE-ATH . There should be a green button labeled “Clone or download”. If you click this, one of the options it will give will be “download ZIP” . Choose this option to download a .zip file of all the files for drocta ~ATH.

Unzip these files into a folder somewhere. Put the .~ATH files that you want to run in the same folder. Use python2 to run the python file interp_2.py . The program will then expect you to type in the filename of the .~ATH file you want to run and then press enter once. It will then load and run the ~ATH program. When it has finished running the program, it will say "press enter to close" . (this is so you can see the output of your ~ATH program before it closes, in case you run it in certain ways.). When you press enter, the python program will finish.

More details on how to run interp_2.py, in case you don’t know how to:(I am assuming you are on windows. if this is not the case, please send me another ask. It should work fine on other OSs, but these instructions for how to run interp_2.py with python might be slightly different)once python 2 is installed, if you open the command line, navigate to the folder with interp_2.py, and type “python interp_2.py” (without spaces), it should run it. Alternatively you can double click on the interp_2.py, it will probably work.One potential problem you might have is if you have python3 installed as well as python2. In this case you have to make sure you run it with the right version of python. If you are using the command line,“C:\Python27\python.exe interp_2.py” instead of “python interp_2.py” should probably work.

If any of this is unclear or you want any more help with this, please do not hesitate to send another ask.

I’m very pleased that this is still interesting for people, and am happy to help!

User input, and a basic calculator.

Most programs people use have some form of user input. A calculator isn't much use if it always uses the same numbers after all!

~ATH of course accepts user input and output as shown in the file Roxy sent Jane.

Also I just found out you can put more than one read more line in one post.

The input command has the syntax:

INPUT VARNAME;

What this does is when program execution meets this line, the program pauses execution, allowing the user to input text. When the user hits enter, program execution will continue and the variable VARNAME will be made to point to an object corresponding to the text the user entered.

This object is such that the left half is the object that corresponds to the first character. If there is no character after that, the right half will be the NULL object. Otherwise the right half will be the object corresponding to the input without the first character. If they hit enter without inputting any characters the object will just be the NULL object.

Now that we have that all explained, we can start to make programs that actually take user input!

As you might have guessed from the title, the thing we will be making is a very basic calculator. All it does is add two numbers, like in the last example.

But in this, it will get the numbers from the user!

One simple way to do this is to use the length of the input text as the number: The way we define what we call numbers just so happens (heh) to be such that if we interpret the object for the input string as a number, the number will be the same as the length of the input!

This isn't the greatest solution, but it is easier than other methods. We will use this method first and then move on to other methods that are harder to write, but will be nicer when using the end program.

HERE WE GO:

ok, so like I said, much of it is pretty much the same as that previous program, so we might as well just include said here:

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!; 

so pretty much what we need to do it put the code to get A and B where that goes(at the beginning), as well as stuff to tell the user how to print stuff.

Like I said, the objects from the input commands can be interpreted as numbers.

so this becomes:

print INPUT SOMETHING WITH THE NUMBER OF CHARACTERS AS THE FIRST NUMBER YOU WANT TO ADD; INPUT A; print INPUT SOMETHING WITH THE NUMBER OF CHARACTERS AS THE SECOND NUMBER YOU WANT TO ADD; IMPORT B; 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!; 

So yeah. That should work. I still need to test this, but I am pretty dang sure that this works.(have to go do homework now) In the next post I will explain how to make it so that the user can type in the number as an actual number!

@ karkathateseveryonesposts

Anon in that ask was me, not rping as you say but what I meant from computer-exploding code is I was unsure if ~ATH was supposed to crash once running a code like Sollux's.  Also, there couldn't be a syntax error as the program crashes if I press enter with no code on it yet.

Ah! My apologies for my misunderstanding, I interpreted the reference to computer exploding scripts combined with your handle to [ justification for why I misinterpreted snipped for brevity].

You don’t type the script in when you run the program. You need to first save the script as a seperate file, and then when you run the interpreter, type in the filename.

The last bit of the interpreter says like

filename=raw_input() filelink=open(filename,'r') script=filelink.read(-1) result_obj=evalScript(script,NULL_obj) raw_input("press enter to close")

I probably should have made it more clearly ask for a file name instead of just having a prompt with no explanation.

(also, wow, this reminds me that this code was written in python 2.7 and not python 3. Maybe I should update it to use python 3? There’s also many other things about it that ought to be improved but it isn’t high on my priorities..)

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?

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?

How often should I post stuff?

I am still here, and I am wondering what my update schedule for this tutorial should be.

Its been a week or two since I last posted part of the tutorial, so I feel like I probably should have posted during that time, but I haven't.

I will probably post one today.

Do you have any suggestions for what type of update schedule I should keep on this tutorial?

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.

Syntax explanation post completed, and Hello, World.

I have completed the syntax explanation post, and I think it is fairly clear now.

If you find any part of the post to be unclear, and that it requires further explanation,  please say so so that I can improve it.

Now that that post is in an acceptable form, We can get on to writing our first few ~ATH programs.

print Hello, World.; THIS.DIE(); 

That wasn't so hard, was it?

I feel I should note that the syntax of the print command is not entirely finalized, it might change sometime later.

EXPLANATION:

The first line of the program says to output the text "Hello, World." 

The 2nd line of the program says to end the program. This is because the variable THIS initially points to a object that is only alive when the program is running. If the object is ever not alive, the program stops.

oh gosh why is this a bullet-ed list I am not good with tumblr

To run a drocta ~ATH program, you need the interpreter (available from the github), and python 2.7 (the interpreter can be easily modified to run with python 3, but it is written to work in 2.7)

Open interp_2.py with python, and when the program comes up, type in the filename of the ~ATH program, and hit enter, this will run the ~ATH program.

With this example, it should output the text

Hello, World.

Now, of course, this is a relatively simple program, but at least its something.

Depending on how you are running the interpreter, the program might close immediately after outputting the text.

That might not be what we want.

To make the program not close until we specifically tell it to, we use the following:

print Hello, World.; ~ATH(THIS){ } THIS.DIE(); 

EXPLANATION:

The first line is the same as in the first program. It outputs "Hello, World."

The second line is different, this says to start a loop, which will continue until the object pointed to by the variable THIS is dead.

The third line says to go back to the corresponding ~ATH statement.

The fourth line is never executed, because the loop above it will continue until the object pointed to by THIS dies, and if that object dies the program ends. If it were to be executed it would make the object pointed to by THIS die, and the program would end as a result.

This program should be the same, except that it will keep running until you close it manually.

Now you have hello world written in two different ways!

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)

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?

So, I just found this and have no clue what's going on. Could you maybe make, like, a simple guide to programming ~ATH? I understand how your python works, but not how to program ~ATH.

Hi!That is sort of what this blog was meant to be.I was trying to explain how to write programs in it, starting with “how do I represent numbers in it?” but then I started prioritizing other projects.I do want to get back to this one though.Perhaps I can give a brief summary in this ask response, and you can tell me what parts you would like clarification on? I will attempt that. I would appreciate it if you tell me what parts of this explanation you are unclear on, or say more about what you don’t understand about how to use drocta ~ATH.

(drocta ~ATH, as a reminder, is my interpretation of how ~ATH could work, which attempts to stay as true to the comic as it can, while still being turing complete, and also possible to implement in reality)In drocta ~ATH there are things called objects. Every object (except for possibly one depending on the specific version of the interpreter, but that isn’t an important detail.) is initially alive. Once an object dies, it cannot be made alive again.Every object has a left half, and a right half, which are both objects. Just because an object is dead does not mean that its left or right halves are dead. Similarly, just because both an object’s left and right halves are dead does not mean that the object is dead.

Also, for any two objects (possibly the same object), there is an object such that the left half of it is the first object, and the right half of it is the second object.

(skippable sidenote : Yes, this would mean that there are infinitely many objects, but they are only /really/ created by the interpreter when they become relevant, so really there are only ever finitely many that the computer is keeping track of)

A variable, in drocta ~ATH, refers to an object. However, it often does not always refer to the same object at different points during the program.

For example, suppose you want some variable to refer to a number which changes during the program. The way that the number which the variable refers to changes is by changing what object the variable refers to.

There are two ways to change what object a variable refers to.

1:Suppose you have three variables names VAR1, VAR2, VAR3.BIFURCATE VAR1[VAR2,VAR3];will take the left half of the object that VAR1 points to, and make VAR2 point to it, instead of whatever it was pointing to before, if anything, and it takes the right half, and makes VAR3 point to it instead of whatever it was pointing to before, if anything.

2:Again, with three variables VAR1, VAR2, VAR3:BIFURCATE [VAR1,VAR2]VAR3;will take the object pointed to by VAR1, and the object pointed to by VAR2, and finds the object such that the left half is the first one, and the right half is the second one, and makes VAR3 point to this object.

Also, when you initially declare an variable it makes a new object for it.

Now, in order to make an object dead, you take a variable (named, say, examplevariable) which currently points to it, and put examplevariable.DIE();and then the object will be dead. Note that this does not make examplevariable point to a different object, which is the same as the one it pointed to before except for being dead. This actually changes the object.In fact, this is the only operation that actually changes an object.

loops:How do you do control flow with this?Well, you use ~ATH loops.

A ~ATH loop looks like this:

~ATH(SOMEVARIABLENAME){//SOME CODE GOES HERE}

What this will do, is it will check if the object currently pointed to by SOMEVARIABLENAME is dead, and if it is not, it runs the code which is {between the curly brackets}. Then, it checks again if the object currently pointed to by SOMEVARIABLENAME is dead, and if not, runs the code inside again. This keeps on repeating until a time that it checks if SOMEVARIABLENAME currently points to an object which is dead, and it is, at which point the program keeps running after the curly brackets.

Note that which object the variable name points to may be changed by the code inside the curly brackets, and probably will be. Changing which object the variable is pointing to is the main way to make the loop exit.

speaking of, let’s get to numbers:

drocta ~ATH doesn’t have numbers as a built in thing. You have to make up your own numbers. But there is a sort of standard way to do so. Where by “standard” I mean, “it is the way that makes the most sense / is the most obvious, and is the way I usually do it”

if some object is the positive integer n, then an object x which has n as the right half, and some object which is alive as the left half, then that object x is n+1 .1 is an object where the left half is a dead object, and the right half is anything.

The reason for this is because this way you can make loops which do things n times, for n>0.

say the object representing n is pointed to by VAR1 , and VAR2 doesn’t point to anything you care about, but it does point to something which is alive, and VAR3 points to an object which represents 1, but you aren’t using it for anything else. You can make a loop like this:

~ATH(VAR2){BIFURCATE VAR1[VAR2,VAR1]; //decrease VAR1 by 1BIFURCATE [VAR2,VAR3]VAR3; /* increase VAR3 by 1, except if this is the last time through the loop, in which case this makes a small error, but one which will be fixed later *///put the stuff you want in the loop here.//Don’t do things to VAR1, VAR2, or VAR3 that you don’t undo though. 

}BIFURCATE VAR3[JUNK,VAR3]; //removes the extra thing that was added to VAR3.

The result of this is that it will do the code you put in the middle n times, and that VAR3 will still store the number n afterwards.

Following processes like these, it is possible to do basically anything you could with a “counter machine / minsky machine” .

Fortunately, there are also things which make things a bit more convenient than using a minsky machine.

In much the same way that you can create numbers, you can also make lists.Just put the successive entries in the list as left halfs of objects, and have the right halves be the list as made so far. (so, basically, the left half is the first element, and the right half is the rest).A caveat here is to make sure that the left half is never a dead object, because that can make it so that the end of the list is detected pre-maturely. However, you might at some point (if you write a lot of drocta ~ATH, which, I am not certain why you would, haha) find that useful to cut the remaining part of a list off.

Of course, when I say to put something as the left half or right half of an object, feel free to switch that in each case. It doesn’t matter as long as you are consistent.

oh, I left out the parts about how to do input and output .

there are some example files on the github for you to check out which have that?

Please let me know if you have any further questions. I’m not sure which parts of this need clarification, so if part of it is unclear, you would be doing me and any other readers of my blog a favor by asking me to clarify them, so please do not hesitate to ask me to clarify any specific part, or to ask me any other question about ~ATH.

Thank you for your interest,

~drocta / ~hE