Post Reply 
 
Freshness Rating:
  • 0 Votes - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
~ATH 17: A Primer
Offline 08-01-2017, 02:32 PM (This reply was last modified: 08-02-2017 02:25 PM by memedIntoOblivion.)(Edited by memedIntoOblivion.)
Reply: #1
Information ~ATH 17: A Primer
~ATH 17
A Primer
©612 Jaimee Michen
Graciously published by )(IC et al., as Crockercorp, Inc.

Table of Contents
Foreword
What's New in ~ATH 17
Chapter 1: Goodbye World
Chapter 2: Graves
Chapter 3: Concepts
Chapter 4: Arrays
Chapter 5: Bifurcation
Chapter 6: Threads
Chapter 7: Predestination
Closing Thoughts



Foreword

Let's all just be completely honest. This language is excessively sophisticated and butt ugly.

I don't mean to harsh your mellow, friends, but no one uses ~ATH because they like how it looks. Ask any long time programmer, they'll all tell you it's beyond insufferable to work with. Let me get something out of the way up front: you are not in for a fun time tonight.

So why am I passionate about ~ATH? If I hate it so much, why would I write a book about it, you ask? Why would I want other people to experience the kind of suffering I've endured to know as much as I know about this god-awful language?

The answer is simple: I've found the beauty of it. It's all true, every word: this language really is every bit as bad as people say. But it's an elegant badness. A sanctioned badness. A badness that makes sense, once you've gotten to know it well enough.

Altering reality and twisting fate simply takes a lot of time and a lot of raw computational power. Higher level languages like ^CAKE and DIS* are too slow and abstracted to fully realize that kind of strength. If you wanted to use a language like, oh, I don't know, say, @LAS, to do the kind of hard number-crunching you can do in ~ATH, you'd be waiting around for hours for the damn thing to compile. And that's not even to speak of the computational complexity at runtime. "Loops of effectively interminable construction," the haters whine. I can hear them even now, from miles away. What they don't realize is how much worse their favorite languages do exactly the same thing under the hood. Out of sight, out of mind? Yeah, right. Tell that to the end user who has to sit around until the day they die waiting for their damn Minesweeper to load.

So, for all the dignity and self worth you have to sacrifice to tolerate working with ~ATH, that's what good comes of it. The ability to actually get things done. Eventually. But even "eventually" is more than you can say for other languages, and that's the whole point, I guess. Look, communing with the dark powers that be is just really hard for computers, okay? Or for anyone, really. If there's one reason ~ATH is worth learning, it's that it doesn't hide anything from you. As reality-altering programming languages go, it's the equivalent of C: without writing assembly, it's about as close as you'll ever get to something that does exactly what you say with no extra bullshit.

A note for human readers
To any humans out there reading this, unfortunately I don't think you'll be able to follow along with the examples on your computers. Sorry, but ~ATH only works on troll computers. Our computers are biotech, so we're able to plug in living creatures as peripherals. The ~ATH runtime requires a compatible driver for a yellow-blooded grub's thinkpan-sponge to be installed and active. Your version of the compiler is packaged with a dummy driver. If you can somehow secure a yellow-blooded grub, you might be able to get it to work properly, but don't quote me on that, because it seems considerably more likely you'd just get your USB port lousy with grubsauce and consequently short circuit your computer. Also, no offense, but I'm not convinced your species even has the guts to brutalize an innocent wiggler by the sort of means necessary to rig up a system like that.

My sincerest condolences to that human boy on the forums who seemed perpetually confused about why his code didn't do anything. Poor sap had himself convinced it was because he was just bad at programming. What was his name? James Eggburp? Well, never mind that.

As for my fellow trolls, have your grubs at the ready, turn the page, and prepare to be bored to sleep.

This video is my theme song and also my spirit animal
Visit this user's website Find all replies by this user
Edit this reply Quote this message in a reply
Offline 08-02-2017, 12:48 AM
Reply: #2
RE: ~ATH 17: A Primer

What's New in ~ATH 17

Newcomers to ~ATH can go ahead and skip this section.

If you're anything like me, I'm sure you remember ~ATH 1.0 with a "fondness" so black as to border on concupiscent. Who could forget the
~ALL{CAPS.KEYWORDS();} that violated our glance nuggets, or the way you basically couldn't ever make anything that wasn't a virus or an evil curse.

We have more interesting things to get into, so I'll keep this brief. ~ATH 17 has introduced case-insensitive keywords. To the relief of everyone with good sense, the following two programs are now equivalent:

~ATH(THIS) {} EXECUTE(NULL);
THIS.DIE();

~ath(this) {} execute(null);
this.die();

~ATH also now features abstract objects. An
abstract object is one that only exists virtually, and on which execute and die can be called anywhere, because your computer is in complete control of its lifespan. More on this in Chapter 3, but it basically means you don't have to import everything anymore. Gone are the days of waiting around for your friends to die just to start up another round of Solitaire. Here's a simple example, but don't run it; there are enough versions of me running around as it is.

import author Jaimee;
abstract A;
~ath(A) {
tab A.die();
} execute(Jaimee);
this.die();

The expressivity of array semantics has also improved. Union semantics are now supported. More on this in Chapters 4, 5, and 6. Here's a preview:

bifurcate this [this|this];

This video is my theme song and also my spirit animal
Visit this user's website Find all replies by this user
Quote this message in a reply
Offline 08-02-2017, 02:08 PM (This reply was last modified: 08-02-2017 02:25 PM by memedIntoOblivion.)(Edited by memedIntoOblivion.)
Reply: #3
RE: ~ATH 17: A Primer

Chapter 1: Goodbye World

So you've decided to immerse yourself in the "programming language for the imminently deceased." You poor, poor bastard. This brief manual will help prepare you for the landslide of reeking bumslurry soon to be wrought upon all of Alternia by your futile and agonizing attempts to wrap your poor sensitive thinkpan around the unfrogly horror that is this aesthetic and conceptual mess of a language. As someone who's been through about as much of the seething wiggler-lumpsquirt that is ~ATH as anyone would ever willingly cram down their protein chute, I can authoritatively and exhaustively declare that I do not envy your position.

Just the Facts, Ma'am

~ATH 17 is the 617 edition of the ~ATH programming language. Although at the time of writing it is currently only the eighth perigee of the sweep 612, by popular demand ~ATH 17 has been sent into the past via Trollian so that a broader audience may enjoy its benefits.

~ATH (pronounced as "'til-death") is an imperative, concept-oriented, statically typed, compiled, domain-specific programming language with call-by-name semantics. If you don't know what any of these terms mean yet, that's okay. To whet your tunepipe, here are a few short definitions:
  • Imperative: As the programmer, you tell it what to do. This is in contrast to declarative languages, in which cases, as the programmer, you tell them what end result to aim for, and they figure out how to get there on their own.
  • Concept-oriented: In computer programming, a concept is a kind of object defined in terms of what operations are possible on it. Different objects may implement the same concept in different ways.
  • Statically-typed: The types which operations return as results and receive as parameters--or, in this case, the concepts on which they operate--are immutable and explicit properties of the program itself. This is in contrast to dynamically-typed languages, in which such information is decided at runtime.
  • Compiled: Programs in the language cannot be run as-is. They must be passed through a compiler and thereby translated into a purely numeric representation called machine code to be parsed by the central processing bees, or CPBs. By contrast, programs in interpreted languages can be run as-is, because a program called the interpreter performs the translation to machine code in real time. Compiled languages are generally faster than interpreted languages.
  • Domain-specific: Typically used to write programs for some particular purpose, as opposed to general-purpose programming languages, which can be used for anything. In particular, ~ATH is intended for viruses, pranks, curses, and dark pacts. However, it can exhibit a wide variety of other uses with enough work.
  • Call-by-name: Data is passed to functions as unevaluated code. This is in contrast to call-by-reference, whereby data is passed to functions via the variables that contain the data, but these variables are dissociated from the code that represents them; call-by-address, whereby data is passed to functions by its address in memory, but the address is dissociated from the variable bound to it, if any; and call-by-value, whereby bare data is passed to functions, dissociated even from its address in memory. Call-by-name semantics are closely related to lazy evaluation.
None of these things are the most interesting and powerful thing about ~ATH. Not by a long shot. You'll see what I mean soon enough. In the meantime, let's get you set up and ready to hack.

Preparation

To install the ~ATH compiler, you will need:
  • A computer. Minimum requirements 500KB RAM, 1GB free comb-matrix space. (Human readers: Check the foreword.)
  • Crocker OS v1.1 or later. Windows with MinCW should work fine.
  • A yellow-blooded grub. You should be able to get one pretty cheap off the black market these days. If you can't find a whole grub, just the thinkpan-sponge will do.
  • A spare culling cord to attach the yellow-blood.
  • A yellow-blooded grub thinkpan-sponge driver from the compiler's provided compatibility list. Personally I use YACOSYBGTPSDWNYCLA (Yet Another Crocker OS Yellow-Blooded Grub Thinkpan-Sponge Driver Whose Name Yields a Comically Long Acronym) by well known freelance developer Hevurt Nalisk.
As for the whereabouts of the compiler, just Croogle it or something. What do I look like, your fucking lusus?

Our First ~ATH Program

Once you've wired up your programming rig and made sure your yellow-blood is fed, rested, clean, alert, and communicating correctly with your driver, go ahead and open a new file--let's call it "goodbyeworld.~ath"--and enter the following code.

import monitor Monitor;
abstract Message = "Goodbye World!\n";
~ath([Monitor, Message]) {} execute(null);
this.die();

To compile and run the program, simply double-click it. The machine code will be cached to disk and only updated on future executions if the source code file has been modified.

If all has gone well, the message "Goodbye World!" should appear on your desktop.

What's Happening Here?

What is causing this behavior? Let's examine the program line by line. Keep in mind you need not understand everything you read here yet; all will be explained in great detail in future chapters.

import monitor Monitor;

Declares a concept referring to a newly established connection to your monitor. The connection thus established is a connection not in the common biodigital sense, but in a metaphysical sense we will cover later.

abstract Message = "Goodbye World!\n";

An abstract concept is, in short, one without metaphysical properties. They are usually singletons, but can be strings, as we see here--among a few other things.

~ath([Monitor, Message]) {} execute(null);

This is where we start getting into the real meat of a ~ATH program. What you see here is called the ~ATH loop. ~ATH loops are a mandatory part of all programs. Code deviating from the following pattern will not compile:

~ath(/* concept */) {
tab // additional graves
} execute(/* concept or grave */);
this.die();

What exactly all this means is not yet important. The critical piece of information to notice here is what concept has been supplied to the ~ATH loop as its conditional.

~ath([Monitor, Message])

For reasons we'll get into in later chapters, this piece of code has permanently affixed the contents of Message to your monitor. Their destinies are bound together from now on, 'til death do they part.

Hope you like your new desktop background. You won't be getting rid of it any time soon.

Welcome to ~ATH, motherfucker.

This video is my theme song and also my spirit animal
Visit this user's website Find all replies by this user
Quote this message in a reply
Post Reply 


Board jump:


User(s) browsing this memo: 1 Guest(s)