Wattslang++

Wattslang++ is an esoteric programming language which evolved from the Wattslang conlang, submitted to the Cursed Conlang Circus 4. It is a cell-based, non-determistic language in which instructions are written as words and interpreted based on how the binary representation of their ASCII representations behave in Conway’s Game of Life. As a response to pseudonatural languages like Shakespeare Programming Language, each sentence of plaintext code in Wattslang++ acts as a form of Turing test, attempting to elicit from the user a particular response which then acts as code guiding the flow of the program.

The programming language has 4 components: the plaintext words of the program, the letters of the program tape, the program counter, and the memory tape. The tape is initialized to a blank state. The program counter by default counts up by an increment of 1, but can be toggled into an increment of 2.

Language

In Wattslang++, a program may be written in English, for example. Each word in the program is interpreted onto the program tape by converting it into binary based on each character’s ASCII encoding (excluding punctuation), and then the binary is placed in isolation into Conway’s Game of Life with the letters forming a column and each letter’s bits laid out in a row, and allowed to run until the state stabilizes. Words are thus categorized as instructions by how they stabilize.

Being that Wattslang itself evolved from the syllable Aum, the program tape and memory tape have cells filled with ternary values, represented by the three sounds constituting the syllable Aum. On the tapes, “a” corresponds to 0_3, “u” corresponds to 1_3, and “m” corresponds to 2_3. There are thus three “basic” commands on the program tape:

• a is a word whose ASCII representation stabilizes to become an oscillator
  • It writes the “a” to the memory tape
  • It furthermore toggles the capitalization of the first letter of the word coming next in the program.
  • It then advances the memory pointer
• u is a word that stabilizes as a still life, or dies to become an infinitely blank field
  • It writes “u” to the memory tape
  • It also toggles our program pointer increment between 1 and 2
  • It then advances the memory pointer
• m is a word that stabilizes to have gliders, ships, or anything else – or never stabilizes at all (with a cutoff of 1 million GoL steps)
  • It writes “m” to the memory tape
  • If the plaintext word does not contain a “z”, it advances the memory pointer; else, advance the memory pointer the ASCII value of the first letter of the word
  • It then reverses the direction of the increment of the memory pointer.

After each sentence of plaintext code has been executed, the user is prompted to input an answer based on the plaintext reading of the sentence. The user answer is then rendered into Game of Life (with spaces and punctuation included) and interpreted as either a, u, or m and slotted into the program tape at the start of the next sentence. So, for example, if the current plaintext sentence is “Surname of the US President in 2014.”, then the user would know to input “Obama” as the response to the prompt, which would then be interpreted as “u” on the program tape. It is thus imperative that each sentence of code be comprehensible as real-language text to ensure that the user inputs the correct responses to each prompt. Given that the user can alternatively input the incorrect answer (or something that is not interpreted to the same letter), Wattslang++ is a non-deterministic language, and each program has a set of potential behaviours based on user responses.

There are numerous compound commands, based on the order of letters in the program tape. If any letter on the program tape begins one of these sequences, the whole compound command is executed, as opposed to each letter command individually, and the program counter then jumps to the end of the whole compound instruction.

• a followed by code instructions of
  • aa: writes a random a, u, or m to the memory tape then advances the memory pointer
  • um: prompts the user to enter text which is then written to the memory tape, starting at the current address; the inputted text is interpreted as the base 3 representation of the ASCII values of the characters.
  • uu: if current memory address is a vowel, toggle {a,u}; else continue with program.
  • ma: write "m" in the current memory tape cell if the cell at that location is not the same as the cell to its left; else copy the nearest vowel to the left of the memory pointer into the memory cell at the pointer (if there is no nearest vowel, assume “a”).
• u followed by code instructions of
  • aa: creates a label at this point in code with name of 1st word in the current plaintext sentence
  • au: TNOR the base-3 numerical representation of the programmatical letter corresponding to the first plaintext word of code in the current label with the base-3 representation of the value of the current memory address (assume “a” if current address is blank)
  • m: TNAND the base-3 numerical representation of the programmatical letter corresponding to the first plaintext word of code in the current label with the base-3 representation of the value of the current memory address (assume “a” if current address is blank)
• m followed by code instructions of
  • ua: unconditional jump to first code sentence beginning with the first word in user answer
  • uu: jump to label with name of 1st word in user answer to current plaintext sentence if current memory address is "a"; else continue with code
  • mm: delete contents of current cell and advance the memory pointer

It is important to note that, if the letter of a user’s response to a prompt results in an “m” which is then followed by a “uu” at the start of the next sentence, and the first word of the user’s answer is not a valid label, it will cause the program to crash.

The program terminates once the program pointer has executed the prompt response of the final sentence and where the program does not jump due to an muu or mua instruction.

Programming Techniques

While no functional non-trivial examples of a Wattslang++ script have yet been demonstrated, several programming tricks have been developed. These include creating a dictionary where words in both upper and lowercase forms are noted for their a, u, and m values and parts of speech, as well as using muu jumps to counteract the change in memory increment direction.