Programming - Blog Posts
Two questions: 1: did you actually make ~ATH, and 2: what was that Sburb text-game that you mentioned on an ask on another blog
While I was back in highschool (iirc?) I made a thing which I titled “drocta ~ATH”, which is a programming language with the design goals of:
1: being actually possible to implement, (and therefore, for example, not having things be tied to the lifespans of external things)
2: being Turing complete, and accept user input and produce output for the user to read, such that in principle one could write useful programs in it (though it is not meant to be practical to do so).
3: matching how ~ATH is depicted in the comic, as closely as I can, with as little as possible that I don’t have some justification for based on what is shown in the comic (plus the navigation page for the comic, which depicts a “SPLIT” command). For example, I avoid assuming that the language has any built-in concept of numbers, because the comic doesn’t depict any, and I don’t need to assume it does, provided I make some reasonable assumptions about what BIFURCATE (and SPLIT) do, and also assume that the BIFURCATE command can also be done in reverse.
However, I try to always make a distinction between “drocta ~ATH”, which is a real thing I made, and “~ATH”, which is a fictional programming language in which it is possible to write programs that e.g. wait until the author’s death and the run some code, or implement some sort of curse that involves the circumstantial simultaneous death of two universes.
In addition, please be aware that the code quality of my interpreter for drocta ~ATH, is very bad! It does not use a proper parser or the like, and, iirc (it has probably been around a decade since I made any serious edits to the code, so I might recall wrong), it uses the actual line numbers of the file for the control flow? (Also, iirc, the code was written for python 2.7 rather than for python 3.) At some point I started a rewrite of the interpreter (keeping the language the same, except possibly fixing bugs), but did not get very far.
If, impossibly, I got some extra time I wouldn’t otherwise have that somehow could only be used for the task of working on drocta ~ATH related stuff, I would be happy to complete that rewrite, and do it properly, but as time has gone on, it seems less likely that I will complete the rewrite.
I am pleased that all these years later, I still get the occasional message asking about drocta ~ATH, and remain happy to answer any questions about it! I enjoy that people still think the idea is interesting.
(If someone wanted to work with me to do the rewrite, that might provide me the provided motivation to do the rewrite, maybe? No promises though. I somewhat doubt that anyone would be interested in doing such a collaboration though.)
Regarding the text based SBURB game, I assume I was talking about “The Overseer Project”. It was very cool.
Thank you for your questions. I hope this answers it to your satisfaction.
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?
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)
User defined functions can be used now! Also PRINT2 added!
PRINT2 prints a string object as a string. If you give it something that is not a string object it will probably crash, or output the empty string.
Now, to import user defined functions use
importf filename as FUNCTIONNAME;
Why didn't I put this up earlier?
because I have other projects and because sometimes I am busy/lazy.
OK!
So to make a function to import, you pretty much make a ~ATH file like normal, except the object passed into the function is put into the variable ARGS, and when you want to pass the output object of the function out, you have it as an argument to the DIE method.
It can either be when saying THIS.DIE(RETURNOBJ); or ANYOTHERVARIABLE.DIE(RETURNOBJ);
The object your killing doesn't have to be the one tied to the life of the function or anything.
Oh I should clarify, the THIS variable/object will refer to the current function, not the file that called it.
It CAN be returned, and will be dead when you exit the function.
PROGRESS!
FUNCTIONS WORK.
LESS SPAGHETTI CODE.
although this starts to make me wonder if maybe this strays too far from what ~ATH is like in comic,
but w/e.
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)
planned features and feedback.
I am planning two features to add.
one us user defined functions.
the second is, uh, it would let you make an object that would have itself as one of its components or one of the component of one of its components etc.?
the third one I am not sure if I think it is dumb yet, but I was thinking maybe functions being objects that you can bifurcate together to make functions.
which would allow for macros kind of?
which of these three features are good ideas, (as in, for each, it is a good idea)?
I am so bad at updating. (and a side note)
I am still intending to update this.
but I am not good at time management.
I have like 2 hours of free time after school, (because of certain inefficiencies on my part) so that's my stupid excuse.
I am working on writing some responses to some requests for clarification, and then I will do the second part of the converter TO binary.
the print command can have the end of a loop in.
The contents of the print command can be executed.
so if you say:
import blah A; import bleh B; ~ATH(A){ ~ATH(B){ print heh } ~ATH(NULL){ print giant frogs alert; B.DIE(); } }
it should print
"heh } ~ATH(NULL){ print giant frogs alert giant frogs alert"
this of course, is not particularly useful as far as I can tell, except possibly for quines, and possibly obfuscation. but really, is it possibly to write anything in ~ATH that isn't obfuscated?
speaking of not obfuscated, I have started working on adding a feature for user defined functions. I have it pretty much worked out how it will work, but I am not sure how I want to make the user DEFINE the functions. so I haven't been doing NOTHING with regards to this.
unary to binary (back again, an objects journey) (part 1)
ok, so last time I didn't actually get to converting from unary to binary again.
So I guess I will do that here. (HAHA I JUST GOT IT TO DIVIDE WITH REMAINDER. APPLYING THAT TO THE CONVERSION IN PART 2)
so to do this we have to find the largest power of two not greater than the number, then the largest power of two not greater then what is remaining of the number, and repeat until we reach zero.
OR we can
find the largest power of two not greater than the number, then for each power of two less than the number, if it is not greater than it, use a 1 and subtract it from the remaining number.
and then for both of these, of course, reverse the result at the end so it is in the right order.
I think so far the second one of these sounds better.
but come to think of it, repeated integer division by two might work well.
that is, instead of repeated doubling, and then checking which one is larger, it might be faster to do repeated halving. (with a remained of either zero or one)
this could be then used to make a integer base 2 logarithm, with a remainder thing.
and instead of checking each power of two less than it, we could just find the integer base 2 log, and the base 2 log of the "remainder" and the base 2 log of THAT remainder and so on.
that seems like its the best way to me so far, but how do we take the integer logarithm AND get the log remainder thing?
getting the logarithm is fairly simple, just keep dividing by the number until you reach 1.
but how do you get the remainder part? and also how do you do the integer division in the first place with these number like things that we have created?
well lets answer the first of those questions first.
It seems like the remainder of the logarithm is probably related to the remainders of the divisions that make it up.
so lets look at taking the integer base 2 logarithm of 9:
9 4 (rem 1) 2 1
that took 3 halvings, and there was one remainder of one.
what if we try on 10 or something though?
10 5 2 (rem 1) 1
that also took 3 steps and one remainder, but the remainder was on a different step.
now lets try 11
11
5 (rem 1) 2 (rem 1) 1 (rem 0)
now wait, theres a pattern here, which might allow for converting it even faster.
the remainders of the divisions are the remainders of the logs expressed in binary!
we COULD turn them back into unary, so we could take the log of it again,
but what we are doing it converting it into binary anyway! (so that would be a silly step)
so if we look at what we were doing with the repeated division again, but looking at the numbers in binary, it will be pretty evident how to convert it in a better way.:
lets try 9 again (which is 1001)
1001
100 (rem 1) 10 (rem 0) 1 (rem 0) 0 (rem 1)
whats that? the remainders are the number we want in binary?
and now that I think of that it was kind of obvious?
yes. I for some reason did not think of that earlier.
so yeah, thats what we will do, we will repeatedly integer divide the number by 2 until we reach zero, and the remainders will be the number in binary.
but wait, we haven't even written out how to divide the number by two in the first place!
well turns out its not actually that hard to do.
in a loop (that keeps looping provided the number is not zero) subtract one, and if its still not zero, subtract one again. if it is zero after the first subtracting, the remainder of that division is 1. (only the last loop will cause the remainder to be 1) count the number of times where 2 was subtracted.
so like for 5 that would be
5 3 1 1 2 0 2 (remainder 1)
so that gives the correct answer (2 with remainder zero)
ok, now to implement this integer division by 2 in drocta ~ATH (wow! already? that was fast! /sarcasm)
//given that NUM is the variable that has the name we are halving BIFURCATE [NUM,NUM]2NUM; BIFURCATE 2NUM[NUMCPY,JUNK]; BIFURCATE [BLAH,BLAH]2BLAH; BIFURCATE 2NULL[SUBCOUNT,REMAINDER]; ~ATH(NUMCPY){ BIFURCATE 2BLAH[UNEVEN,JUNK]; BIFURCATE NUMCPY[JUNK,NUMCPY]; BIFURCATE [NUMCPY,NUMCPY]2NUMCPY; BIFURCATE 2NUMCPY[NUMCPYCPY,JUNK]; ~ATH(NUMCPYCPY){ BIFURCATE [BLAH,SUBCOUNT]SUBCOUNT; BIFURCATE NUMCPY[JUNK,NUMCPY]; BIFURCATE 2NULL[UNEVEN,NUMCPYCPY]; } ~ATH(UNEVEN){ BIFURCATE [BLAH,REMAINDER]REMAINDER; BIFURCATE 2NULL[UNEVEN,JUNK]; } } BIFURCATE [NUMCPY,NUMCPY]2NUMCPY; BIFURCATE 2NUMCPY[NUMDIV2,JUNK];
ok, that should divide the number by 2, put the result in NUMDIV2, and put the remainder in REMAINDER.
this takes linear time based on the size of the unary number. (provided I didn't make a mistake)
so now it is time to make sure it works, hold on a second while I check it. (I mean, im not going to post this until after I check it, so it doesn't really make sense to tell you to wait, because you just keep reading, but as I am writing this, I am about to test it.)
ok, I tested it. and it didn't seem to work, but then I realized that I made a mistake in making the test. (I checked the wrong variable)
but yeah, turns out that works...
ok, so now we need to repeatedly divide the number by two to get the remainders.
and we need to store these remainders in a list or something.
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!
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?
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.
Burning midnight code, the hum of neon mixing with caffeine buzz—it's all a grind. But that's how we edge closer to the truth, byte by byte. We don't sleep; we dream in data, chasing the horizon of the next fix, the next breakthrough. It's not the hours that kill you—it's the silence between keystrokes.
I was gonna post a video of a prototype of a thing I programmed but it took too long and I'm hungry so ill post it later
My online school offered me a really cool programming class where you build the entire decorative light box thingy. I made much more complex one but my family member put it in a bag when I told them not to and the ground wire snapped. But thats fine. 🙂 👌
I hate debugging problems caused by changing coefficients. I am being outsmarted by a quantity.
Btw, does anyone know if there’s a nightshade/glaze type program for text?
I realize that’s kind of a big ask since it’d have to cover more ground — text on websites, on saved documents, etc. — but I’m wondering if it exists.
There is literally NOTHING better than having an actually exciting idea for a project. Being able to write it all down is so amazing.
I need to stop blaming myself for my teammates not talking to me. Their past experiences, misconceptions, and pre-existing biases are not my fault.
As I grow my knowledge in programming, I realize just how shitty my code is smh
the lack of open source ar glasses that aren’t terrible is seriously tragic. i have so many ideas and literally all i need is the ability to render text directly on my field of vision
i take http rate limits extremely personally. where you see "secondary rate limit exceeded", i see:
Essentials You Need to Become a Web Developer
HTML, CSS, and JavaScript Mastery
Text Editor/Integrated Development Environment (IDE): Popular choices include Visual Studio Code, Sublime Text.
Version Control/Git: Platforms like GitHub, GitLab, and Bitbucket allow you to track changes, collaborate with others, and contribute to open-source projects.
Responsive Web Design Skills: Learn CSS frameworks like Bootstrap or Flexbox and master media queries
Understanding of Web Browsers: Familiarize yourself with browser developer tools for debugging and testing your code.
Front-End Frameworks: for example : React, Angular, or Vue.js are powerful tools for building dynamic and interactive web applications.
Back-End Development Skills: Understanding server-side programming languages (e.g., Node.js, Python, Ruby , php) and databases (e.g., MySQL, MongoDB)
Web Hosting and Deployment Knowledge: Platforms like Heroku, Vercel , Netlify, or AWS can help simplify this process.
Basic DevOps and CI/CD Understanding
Soft Skills and Problem-Solving: Effective communication, teamwork, and problem-solving skills
Confidence in Yourself: Confidence is a powerful asset. Believe in your abilities, and don't be afraid to take on challenging projects. The more you trust yourself, the more you'll be able to tackle complex coding tasks and overcome obstacles with determination.
Database of Databases
Discover and learn about 924 database management systems
This is an interest resource that aims to catalog the different database systems in existence and allows you to search and filter through them:
It also has "leaderboards" for views and uses:
A lot of the information doesn't seem very deep but it does give you a good overview of the features and support in each one of it's entries.
I found it interesting. Perhaps you will find it useful.
Enjoy! 🤓
I made the USS Enterprise using graphics.py! Very simple but I like how it turned out :D ✨
How to fully solve what happened to Malaysian Flight m370, what to do, how to put it together & why it works, together with if the US military ever shot it down & or it was some s*ici*e situation
so for Flight m370, I would like to comb through all given underwater sonar, ocean floor sound wave measuring devices, I would need any willing civilian, commercial, & military data for satellite, on ground weather, weather satellite, other planes wifi, radar, etc, boats radar, wifi, etc data, together with sound wave propagation data for a flying plane that size as it creates its given pressure wave (which those can be much much more numerous as they track volcanos & other such things for even smaller asteroid/meteorites that explode in our upper atmosphere, together with particles hitting our upper atmosphere creating specific soundwave styles) same for any given light sensor/detectors for satellites & on the ground based sensors & detectors, same for ocean/sea buoys that do the same thing.
The flight happens to create specific waves that, with the given weather mapping data, can only have attenuated out in a highly understood & able to be fully calculated manner, from here that gives us the schlieren imaging we need for higher altitude & reflective light interference models needed from radar satellite mapping of all waves that gain higher fidelity through ocean buoys, sonar, & soundwave mapping. From here, we gain movement data, that we filter from position to position, working forwards to backwards, us gain a position in front of the plane to the position where is was for a change of given total pressure differences specifically so that way the higher fidelity wave mapping gets used for reflective, defractive, & refractive filtering for interference frequencies for closer to the air plane capture of different air pressure mapping, that lines up with soundwave captures from further away that now line up with the planes most probable positioning.
From this positioning we gain light reflection & absorption of the plane, radar/wifi wise changes the reflection but also how much, as it moves through the air & its given shape, absorbs different wifi & so on signals. Think doppler shifts for wifi that now get reflected because its moving as fast as it is. This means it interferes with the given wifi signal heading towards it to shift signal db mapping. That mapping gives you specific location triangulation, which matches the probable plane positioning. This positioning then gains greater probability. This probability then gains exacting attenuation of heat & air movement soundwave mapping with light wave alterations (interferences, heat, densities, & electrostatic electromagnetic effects) that give you exacting color likeliness as well, from satellites & simple boat/other airplane data, to even the buoys together with how light & sound mapping for particle collisions in our upper atmosphere are detected & sensed.
From here we gain a pinpoint location of the airplane & all given people around involved. To the point, where yes as weird as it is for you all, you can vibrationally see & know lightwave interference wise the people inside as well, even some conversations had if they were loud enough. The detail & fidelity is harder as that requires better & more accurate data with larger amounts to help. But! you can get blobs of people to even good shaping provided it, in those moments, has enough data to correct the fuzziness of the movement & so on.
Anyways, this (without gov't military data) can put this to rest as to what & where it all went & had happened. To be clear & fair, the military for sure, mostly likely several of them, have satellite data that could easily pick out what was going on with this flight. They could conclusively say it was shot down or not. A big poofy fireball isn't hard to see on even older crappy satellites. But so too, for that soundwave sonar data. They can all act as triangulation points, to what happen & when. Even for it flying, but that's been de-noised data for earthquake, boat, whales, & more data mapping for a long time now. They are extremely sensitive, for what its worth.
Which, has me thinking the military could, unfortunately, very well be involved. But this would easily clear it up, if it was the case they never were.
Scary sidenote, at all times this is data & easily calculated & used data being created all the time & used all the time by corporations, gov't, military, & more. In fact, hackers & regular people can get access to it with no trouble. A few routers & a few cell phones & you have many ways to listen to people from a few houses down without having any issues what-so-ever, like many people believe you would. You can absolutely see inside of peoples homes. Because its "bleeding edge" for consumers its not for people with money & an incentive to use it. I.e. your gov't & military that like to spy on the rest of the world, to even their citizens with almost impunity. Hackers, truthfully, haven't really not been able to & they just like playing around to and or using it to their advantage all the same. You are always watched, always listened to, always manipulated & always being turned into something for something, for whatever reason it is for whomever it is. It's why I know they were listening to me almost a decade ago & why I know a level of constant verbatim studies that I said should work out the way they are written in the studies that have kept steadily coming out are mine, to multiple youtube videos, to too many different things.
Those calculations aren't terribly hard now, they are github opensource de-noising, interference, wifi beam forming, radar beam forming, soundwave interference for voice to de-humming, etc programs. All of them can even be found in most graphics cards tools for voice amping, clarity, to making the video look a little more detailed, colorful, blurry, so on & so on. Effectively, all of this has been around for more than 2 decades & only gotten faster & better for even larger data models that now can use large language modeling, neural networking, "multiple dimension" neural networking (chatgpt stuff), branch networking (then logic branch networks that just use dimension neural networks that have it head to a more specific neural network model to make it faster to calculate larger data sets faster), & even simple old school chaos theory mathematical programming, which can now take advantage of the protein folding stuff like deepmind/alphafolding stuff.
This means, its extremely easy, it would be possible to do on your standard mid-tier phone, although it would take like 30min or something, but still nothing that bad. So, yes, for people & cars, planes, & more to be tracked & hunted down by your gov't its easier than ever. But that's real time data stuff, so everything is usually behind about 3-30 mins. This is old data, this would take like a few minutes to fully calculate & brute force everything until you have more than enough to know if the military shot flight m370 down & or they didn't, while then you can comb through all data of them online & around & know how much it was planned & what they were saying outloud, writing on papers (its that good yes) to any number of events leading up to the tragedy. Fully removing the mystery of the flight & what happened.
That's why I would do first, for that one. Then second, after doing it, I would let you watch it all & make for conclusions & resolutions to find closure for it all & know what you need to know. While also giving you a horrifying glimpse into all those with money & power; what they intend to do to you with it & why you shouldn't think its okay unless you don't live in America as it is now.
https://youtu.be/UdTLnZQAZNw
A re-explanation of my programming & math behind a play on roko basilisks being like "God" & other things for what's it worth as an operating system I want to make from scratch and put out there.