Okay, This Might Be A Liiittle Specific, And More HS Oriented, But Still. Can You Power A First Guardian

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?

I made a parser

I made a parser for ~ATH in addition to the interpreter. I might make the interpreter use the parser at some point in the future, or I might not. If I made the interpreter use the parser, the code for the interpreter would probably be a little cleaner, and possibly a little faster.

The parser is available from my github.

To use it, call tokenize on the text, and then read_all_from on the result of tokenize.

The output will be a list of lists

https://github.com/drocta/TILDE-ATH-Parser

(haven't updated lately because of other unrelated projects, and also other reasons that aren't necessary to describe)

Hello again all!

So recently I started kind of working on this again for a bit. I have fixed some bugs with the parser that I haven't pushed yet. I am also writing an improved interpreter that will use the parser instead of the hacky thing that just goes through strings.

However, for the time being, even after I release this version, I would recommend maybe using the older version for a while if anyone is using it, because this version is probably even more buggy.

However, you know how a few posts ago (but more than a year ago (wow) ) I posted that post where I said that I didn't think bifurcate can be used to split values into more than 2 values?

Well I still kind of think that, but on the map page for homestuck on act 6, it says split Act_6[Act_1,Act_2,Act_3,<etc>];

So this is something I intend to implement, and something I am implementing.

And like I said before I would like it to be done with repeated bifurcation, as a sort of syntactic sugar.

And I am thinking I want it to be like

[a,b,c] means the same thing as [a,[b,c]]

so split Z[A,B,C];

would be the same as

BIFURCATE Z[A,BCTEMP]; BIFURCATE BCTEMP[B,C];

and that split [A,B,C]Z;

would be the same as

BIFURCATE [B,C]BCTEMP; BIFURCATE [A,BCTEMP]Z;

But the way the splits would be done could also be backwards

so [a,b,c] could be the same as [[a,b],c]

I'm pretty sure I prefer the first way, but the second way is actually easier to implement.

or at least cleaner looking to implement.

Why doesn't my code look clean ever?

Anyway, my reason for this post is this:

Does anyone have any opinions about how split is implemented?

This blog still exists

Hi, I haven’t posted much here in quite some time.

So, is this blog abandoned? I wouldn’t say so. I intend to post more ~ATH content here at some point. I have other projects and obligations, which is why I’ve been not doing as much with it recently (”recently”: understatement of the year), but if anyone has any questions about drocta ~ATH, or would like to request that I do something in particular with it, I think I’ll probably respond within a reasonable amount of time.

Right now though I thought I would link to two blogs that I think you are likely to appreciate if you like this blog.

The first is @sbahjsic http://sbahjsic.tumblr.com/ which is for a programming language and assorted connected software meant to be, well, sbahjsic . like sweet bro and h---- jeff. (Warning though, that blog has some javascript alerts when you view it. Also it has moving parts which might be bad if you get nauseous easily or something? idk.) The blog theme there is a work of art to behold. This is likely to appeal because it is also a homestuck related programming language, and also it is great.

The second is @tilde-he which is where I post most of my non ~ATH related tumblr posts. This is somewhat likely to maybe appeal because it is by the same person as this blog (me).

Again, if you have any questions or comments about my version of ~ATH, or, really, any version that you can point out, feel free to send them, and I’ll try to respond within a reasonable amount of time.

Alright, cheers

Heyho, I now red alot of your sources and i started to understand your interpretation of ~ATH. You do alot of things with the bifurcate command.. I actually thought that bifrucate JUST splits the programm in different colors like here : "bifurcate THIS[THIS(red), THIS(blue)]; " I think that you can actually split your script into N colors while N > 0. like this: bifrucate THIS[THIS(COLOR(0),THIS(COLOR(1),THIS(COLOR(2),THIS(COLOR(3),THIS(COLOR(4),THIS(COLOR(5),THIS(COLOR(6)] and so on.

Yes. I do use BIFURCATE often.

Personally, I doubt that one could say

BIFURCATE A[D,B,C]; (for some names and colors for a b c and d),

because of the "Bi" part of the word "bifurcate", meaning two. (or in some cases, "both")

Further, I would defend my use of it to BIFURCATE things other than  THIS with http://mspaintadventures.com/?viewmap=6 which, for the start of act 5, says

BIFURCATE ACT_5[red(ACT_1), blue(ACT_2)];

which seems to indicate that things other than THIS can be BIFURCATED.

To split something into more than 2 parts, I would just bifurcate it multiple times. *

I don't know what the etiquette is for whether I should click publish or answer privately, so I am going to pick one and hope for the best.

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.

reading binary numbers from the user, continued.

when we left off, we had code to interpret one binary number from user input, and output it as a unary number. In this post we will add the second user input, and maybe make a thing that converts from unary to binary, and then outputs it.

The code for that was the following:

import blah BLAH; print please enter whatever character you will be using for binary zero.; INPUT ZEROCHAR; BIFURCATE ZEROCHAR[ZEROCHAR,JUNK]; import chrcmp CMP0; BIFURCATE [CMP0,ZEROCHAR]D; D.DIE(); print please enter whatever character you will be using for binary one.; INPUT ONECHAR; BIFURCATE ONECHAR[ONECHAR,JUNK]; import chrcmp CMP1; BIFURCATE [CMP1,ONECHAR]D; D.DIE(); BIFURCATE [NULL,NULL]2NULL; BIFURCATE 2NULL[OUTNUM,JUNK]; print please input the binary number you want.(it will be converted to unary); INPUT BINNUM; ~ATH(BINNUM){ BIFURCATE [OUTNUM,OUTNUM]G; BIFURCATE G[NCOPY,OUTNUM]; ~ATH(NCOPY){ BIFURCATE NCOPY[JUNK,NCOPY]; BIFURCATE [BLAH,OUTNUM]OUTNUM; }  BIFURCATE BINNUM[CHAR,BINNUM]; BIFURCATE [CMP0,CHAR]NEQ0; ~ATH(NEQ0){ BIFURCATE [BLAH,OUTNUM]OUTNUM; BIFURCATE 2NULL[NEQ0,JUNK]; } } print ok, going to print it out in unary, with each digit on one line. If the number you entered was large you might want to close the program instead of hitting enter.; INPUT JUNK; BIFURCATE [OUTNUM,OUTNUM]GOUTNUM; BIFURCATE GOUTNUM[OUTNUMCOPY,JUNK]; ~ATH(OUTNUMCOPY){ BIFURCATE OUTNUMCOPY[JUNK,OUTNUMCOPY]; print 1; }

ok, so what do we need to do after that?

Well we need to make it get two numbers, right?

Yes. Yes we do.

But getting one number was kind of long, wasn't it.

Luckily we don't have to have the entire thing there twice, much of it we can jusst have it in there once.

we COULD define a function, but I haven't added that to the interpreter yet, so yeah...

so a significant portion of that was initialization stuff that doesn't need to be duplicated. the first 14 lines in fact!

so pretty much we just duplicate everything but the first 14 lines.

gee, now I sound lazy for not writing this part earlier.

anyway, here goes:

import blah BLAH;

print please enter whatever character you will be using for binary zero.;

INPUT ZEROCHAR;

BIFURCATE ZEROCHAR[ZEROCHAR,JUNK];

import chrcmp CMP0;

BIFURCATE [CMP0,ZEROCHAR]D;

D.DIE();

print please enter whatever character you will be using for binary one.;

INPUT ONECHAR;

BIFURCATE ONECHAR[ONECHAR,JUNK];

import chrcmp CMP1;

BIFURCATE [CMP1,ONECHAR]D;

D.DIE();

BIFURCATE [NULL,NULL]2NULL;

BIFURCATE 2NULL[OUTNUM,JUNK];

print please input the first binary number you want.(it will be converted to unary);

INPUT BINNUM;

~ATH(BINNUM){

BIFURCATE [OUTNUM,OUTNUM]G;

BIFURCATE G[NCOPY,OUTNUM];

~ATH(NCOPY){

BIFURCATE NCOPY[JUNK,NCOPY];

BIFURCATE [BLAH,OUTNUM]OUTNUM;

} 

BIFURCATE BINNUM[CHAR,BINNUM];

BIFURCATE [CMP0,CHAR]NEQ0;

~ATH(NEQ0){

BIFURCATE [BLAH,OUTNUM]OUTNUM;

BIFURCATE 2NULL[NEQ0,JUNK];

}

}

BIFURCATE [BLAH,OUTNUM]UINNUM1;

BIFURCATE UINNUM1[JUNK,UINNUM1];

BIFURCATE 2NULL[OUTNUM,JUNK];

print input the second binary number:;

INPUT BINNUM;

~ATH(BINNUM){

BIFURCATE [OUTNUM,OUTNUM]G;

BIFURCATE G[NCOPY,OUTNUM];

~ATH(NCOPY){

BIFURCATE NCOPY[JUNK,NCOPY];

BIFURCATE [BLAH,OUTNUM]OUTNUM;

} 

BIFURCATE BINNUM[CHAR,BINNUM];

BIFURCATE [CMP0,CHAR]NEQ0;

~ATH(NEQ0){

BIFURCATE [BLAH,OUTNUM]OUTNUM;

BIFURCATE 2NULL[NEQ0,JUNK];

}

}

BIFURCATE [BLAH,OUTNUM]UINNUM2;

BIFURCATE UINNUM2[JUNK,UINNUM2];

BIFURCATE [UINNUM1,UINNUM1]CUINNUM1;

BIFURCATE CUINNUM1[SUM,JUNK];//haha, some junk

BIFURCATE [UINNUM2,UINNUM2]CUINNUM2;

BIFURCATE CUINNUM2[UINNUM2CPY,JUNK];

~ATH(UINNUM2CPY){

BIFURCATE UINNUM2CPY[JUNK,UINNUM2CPY];

BIFURCATE [BLAH,SUM]SUM;

}

print ok, going to print the sum out in unary, with each digit on one line. If the numbers you entered were large you might want to close the program instead of hitting enter.;

INPUT JUNK;

BIFURCATE [SUM,SUM]GSUM;

BIFURCATE GSUM[SUMCOPY,JUNK];

~ATH(SUMCOPY){

BIFURCATE SUMCOPY[JUNK,SUMCOPY];

print 1;

}

ok. That worked. I haven't made it convert the output to binary yet. I started this the day of the other post, but there was a bug I didnt get around to fixing in it that I didn't find the fix for until today.

that bug was that in the part where it changes the binary number to a unary number, the first time around, the unary number starts at zero and increases to what it should be...

...but I forgot to include the line to reset it back to zero for the second number.

but in works now.

I might make the part where it converts from unary to binary now instead of later, but I have to do stuff.

Sorry for having such a slow post rate, it is partly because I am busy and partly because I am lazy. mostly the [FORMER,LATTER].

hey, it adds the numbers that were entered in binary...

So a future improvement is to make it so it outputs it in binary as well.

Another possible future post is something that shouldn't work but the interpreter has a certain bug that might be amusing, and will not negatively affect many things.

specifically, if you have a "}" inside of a print statement, and you are jumping to the end of a loop, it will jump to the inside of the print statement, and execute the text as code. This is a bug, not a feature, so you should not rely on it when writing stuff. It might be fun to mess with though.

I might add user defined functions to the interpreter soon...

I don't feel that this post really explained much of anything, but I have to do stuff now, so I am going to post this, and possibly modify it later with clarifications.

Feel free to send me messages asking about how some part works.

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!

re: "computationalalchemist answered: You could use Prolog-style lists for split."

"computationalalchemist answered: You could use Prolog-style lists for split."

I'm not totally sure what you mean, but my best guess as to what you meant is probably pretty similar to how I making it.

I implemented it and I think it works, I need to double check though.

With what I have now when I use 

split [THIS,THIS,THIS,THIS,THIS,THIS,NULL]COUNTER; ~ATH(COUNTER){ print "bananas"; BIFURCATE COUNTER[JUNK,COUNTER]; }EXECUTE(print "ok";); print "whee!";

it yields 

bananas bananas bananas bananas bananas bananas ok whee!

Which seems to make sense to me, and also, fits with how lisp lists work, and apparently also prolog lists.

also where it says split it will also accept bifurcate. they are actually treated as the same command.

import statements aren't fully implemented yet though.

I think I will put this version on github pretty soon.

Thank you for the advice.