Commits

catseye  committed fc2eda9 Draft

Add Markdown versions of specs for Sartre, *W, and TURKEY BOMB.

  • Participants
  • Parent commits c2effc2

Comments (0)

Files changed (3)

File sartre/doc/sartre.markdown

+The Sartre Programming Language
+===============================
+
+John Colagioia, 199?
+
+Introduction
+------------
+
+The Sartre programming language is named for the late existential
+philosopher, Jean-Paul Sartre. Sartre is an extremely unstructured
+language. Statements in Sartre have essentially no philosophical
+purpose; they just are. Thus, Sartre programs are often left to define
+their own functions.
+
+Unlike traditional programming languages (or maybe very much like them),
+nothing in Sartre is guaranteed, except maybe for the fact that nothing
+is guaranteed. The Sartre compiler, therefore, must be case insensitive
+(technically, it requires all capital letters, but since nothing matters
+anyway, why should this?).
+
+Names in Sartre may only contain letters (and only capital letters, at
+that, but nobody really cares that much), and maybe some trailing
+digits, but nothing else.
+
+No standard mathematical functionality is supplied in Sartre. Instead,
+nihilists are created, which may damage the properties inherent to the
+data, and nihilators are executed to reclaim storage dynamically.
+
+Sartre programmers, perhaps somewhat predictably, tend to be boring and
+depressed, and are no fun at parties. No comments will be made on the
+level of contrast between the Sartre programmer and any other
+programmer.
+
+In the words of a Sartre programmer who worked intensely for months,
+eating whatever junkfood wandered near his cubicle, "I have been gaining
+twenty-five pounds a week for two months, and I am now experiencing
+light tides. It is stupid to be so fat. My pain, ultimate solitude, and
+collection of Dilbert cartoons are still as authentic as they were when
+I was thin, but seem to impress girls far less. From now on, I will live
+on cigarettes and black coffee," which is the general diet of the Sartre
+programmer, for obvious reasons.
+
+Comments are available in Sartre, though not at all suggested, since
+nobody really wants to listen to you, anyway, by typing the comment at
+the beginning of the line, and terminating it (on the same line) with a
+squiggle (brace) pair ("{}"). Valid Sartre text may be placed after the
+comment if desired. If comments are absolutely necessary, they should
+adequately describe the futility of the program and the plight of
+programmer and computer in a world ruled by an unfeeling God and His
+compilers, as well as providing explanation of the surrounding program
+statements.
+
+They should not be misspelled, as some compilers may check.
+
+Admittedly, while it is not hard to string Sartre statements together to
+create a Sartre-compilable text file, it can be quite hard to program in
+the Sartre paradigm. To wit, one may keep creating programs, one after
+another, like soldiers marching into the sea, but each one may seem
+empty, hollow, like stone. One may want to create a program that
+expresses the meaninglessness of existence, and instead they average two
+numbers.
+
+Sartre Data Types
+-----------------
+
+The Sartre language has two basic data types, the EN-SOI and the
+POUR-SOI. The en-soi is a completely filled heap of a specified rank,
+whereas the pour-soi is a dynamic structure which never has the same
+value. An integer may also be used in Sartre, but it may only take the
+value of zero (the Dada extensions to Sartre allow integers to also take
+on the value of "duck sauce", but that's neither here nor there--unless
+you happen to like duck sauce, of course).
+
+en-soi
+
+The en-soi, as mentioned before, is a full heap of a specified rank. As
+Sartre does not allow pre-initialized data, the actual data in the heap
+is non-specified (but the heap is "pre-heapified"). Data (en-sois of
+rank 0) may be "deconstruct"ed from the en-soi, or "rotate"d through. At
+all times, the en-soi remains a full heap, however. En-sois of rank zero
+are 32 bits with no inherent meaning. En-sois of higher rank may be
+defined as each element being of another (same) data type (an en-soi of
+integers, all with a value of zero (or duck sauce), for example).
+
+pour-soi
+
+The pour-soi is only, and precisely, what it is not. It may be
+"unassigned from" a certain value, thereby exactly increasing the number
+of things it isn't. It is specified to be a two-bit value, so it
+probably isn't.
+
+integer
+
+Unlike the integers in most programming languages, Sartre integers all
+have a value of zero (again, unless the Dada extensions are being used).
+Like the rest of the dreary universe (duck sauce included), this is
+something that must be lived with.
+
+orthograph
+
+The orthograph is a special type of pictogram used in the specification
+of lexicographic elements. The set of orthographs varies from Sartre
+implementation to Sartre implementation, but is guaranteed to contain
+all the so-called "letters" from at least one modern language,
+transliterated to the closest element of the ASCII set and ordered as
+the bit-reversed EBCDIC value, assuming those bit-patterns were
+integers, which they probably aren't. Unavailable orthographs in a given
+implementation are represented by "frowny faces". As defined, the
+orthograph is possibly the simplest and most convenient data type to
+work with.
+
+const
+
+Not an actual data type, but somewhat useful, is the introduction of the
+symbolic constant into the Sartre language. Since Sartre does not allow
+for unconventional, potentially confusing symbols to be strewn about a
+program (for example, "17" meant to represent a certain quantity of
+items), this allows the programmer to define a set of symbolic constants
+he plans to use. To avoid confusion, symbolic constants are defined in
+unary, using the "wow" (!) as the unit (i.e., !, !!, !!!, !!!!, ...).
+
+Symbolic constants must be surrounded in "rabbit ears" (") in use during
+the action section of the program.
+
+Predefined Sartre Instances
+---------------------------
+
+The following data instances are provided to the Sartre programming
+environment to facilitate programming certain concepts which would be
+(and probably should be) nearly impossible otherwise.
+
+                MAXINT  This is the maximum integer value allowed by the
+                        particular Sartre implementation:  zero.
+                MININT  This is the minimum integer value allowed by the
+                        particular Sartre implementation.  If using the Dada
+                        extensions, MININT is duck sauce; if not, it is zero.
+                ORTH0   This is the "initial orthograph" of the Sartre
+                        implementation.
+                ORTHL8  This is the "final orthograph" of the implementation.
+                        The name is properly pronounced "Orthograph:  Lazy
+                        Eight".
+
+Sartre Program Segments
+-----------------------
+
+The Sartre program is broken into simple, logical portions. In essence,
+all things must be declared before usage, and the declaration section
+comes before the action section (if any). Since the Sartre language has
+a recursive structure, the Sartre nihilist has the same structure as the
+main nihilator which is about to be described:
+
+                    Nihilator <name> ;
+                    {Nihilist;}
+                    Const   <name> = <value>;
+                    Consts  <name> = <value>..<value>;
+                    Matter  {<name> {, <name>} : <type> ;}
+                    Act
+                            {<statement> ;}
+                    No more ;
+                    .
+
+The only difference between a nihilist and the nihilator is that a
+nihilist does not use the trailing one-spot.
+
+Example Matter definitions (data declaration) might be:
+
+                    Const   3 = !!;
+                    Matter  dooM:   integer;
+                            Rniqqlj:en-soi, rank "3", of pour-soi;
+
+which creates an integer (with a value of 0, since we are not invoking
+Dada extensions), and a heapified en-soi with seven pour-soi storage
+locations.
+
+Sartre Statement Types
+----------------------
+
+`IF ;`
+
+The Sartre conditional takes no arguments and then alters program flow
+accordingly. Put simply, on the condition where the most recently
+executed nihilator was successful, program execution is transferred to
+just beyond the next conditional, restarting the search from the
+beginning, if necessary.
+
+`LVAL := expr ;`
+
+The Sartre assignment statement takes the bourgois-perceived value of
+the damned expression and places it in LVAL. If LVAL is a pour-soi, this
+unassigns a value from the pour-soi.
+
+`No Exit ;`
+
+A reminder to the program that none of us can escape what we have
+wrought, or even escape what others have wrought. In programming terms,
+this may either cause the machine to hang or cause the program not to
+terminate, depending on the implementation.
+
+`Life Is Meaningless ;`
+
+A special command which, due to the resignation of the programmer, is
+permitted to perform a wide variety of tasks, among them, alter the
+direction of program flow, execute a random function, terminate the
+program, or positionally invert the bits in the data region. Since the
+programmer doesn't care anyway, this doesn't really matter. In the
+(tee-hee) ordinary version of Sartre, this operation is defined at
+compile-time, and is constant at that statement for each incidence of
+execution. The Dada extensions, however, redefine meaninglessness (since
+everything under Dada is meaningless to begin with) to be determined at
+run- time. Further, it may also logically negate each bit in the
+dataspace under Dada.
+
+`{ data } <nihilist> ;`
+
+This invokes the named nihilist and allows it to accomplish its goal.
+
+The Sartre scoping rules are somewhat complex in that it may only
+utilize data which has been accessed previously or any data which it
+makes up itself. Data which has not yet been accessed is unknown to the
+Sartre nihilist, however.
+
+`again ;`
+
+Repeats the last statement, for the computationally-impaired.
+
+`Act {<statement> ; } No more ;`
+
+Allows certain statement-sets to be considered a single, atomic
+statment. A conditional cannot jump to within such an atomic structure.
+
+Predefined Sartre Nihilists
+---------------------------
+
+`<orthograph> which`
+
+Gets replaced with a zero-rank en-soi with the bit pattern of the
+orthograph. The orthograph may be replaced by a symbolic constant, and
+returns the bit-pattern that would be associated if the symbolic
+constant were an integer, which it isn't, otherwise it would be zero.
+
+`<zres> that`
+
+Gets replaced with the orthograph that matches the bit- pattern in the
+zero-rank en-soi.
+
+`<zres> <zres> <logop>`
+
+\<logop\> is one of "and", "or", or "xor", and returns the bitwise
+logical operation between the two zero-rank en-sois.
+
+`NOT <pour-soi>`
+
+This makes the pour-soi what it isn't, even if it is.
+
+`annihilate ;`
+
+Clears the values (sets to arbitrary values) of any data in the program.
+Proceeds to destroy any dynamically allocated storage. If no dynamic
+storage exists, causes a "Bad Faith" error in the program.
+
+`<zres> Dump ;`
+
+Prints the zero-rank en-soi to the screen as up to four orthographs. The
+en-soi may be replaced with an orthograph, in which case the orthograph
+itself is printed.
+
+`<orthograph> Get ;`
+
+Allows an orthograph to be input from the keyboard and stored in the
+specified orthograph. The orthograph may be replaced by any-rank en-soi
+of orthographs, in which case the statement will read in enough
+orthographs to fill the en-soi, then "heapify" the en-soi.
+
+`<en-soi> <data> Zip`
+
+First, removes an element from the en-soi, then adds the new element and
+"heapifies," returning the removed element.
+
+`<en-soi> Dir`
+
+Flips direction of the en-soi's "heapification." If the Dir nihilist is
+never executed, the heapification of the en-soi is, by default,
+descending.
+
+`<value> <data> Flip ;`
+
+Flips the bit represented by \<value\> in \<data\>.
+
+`<data> <data> Concat`
+
+Returns the concatenated bitpatterns of the two \<data\> elements.
+
+Sample Sartre Programs
+----------------------
+
+            Nihilator SartreExample1;
+            Act
+            No more ; .
+
+This program can be appreciated for its ability to not sort the input
+list of values in ascending order. It's elegance and simplicity in not
+accomplishing this goal are admirable. To fully appreciate that sorting
+is the activity being denied the user, as opposed to, say, searching or
+some sort of filtering, one should stare at the (lack of) program output
+forever and not turn on the lights when it gets dark.
+
+            Nihilator SartreExample2;
+            Act
+              IF ;
+              again ;
+            No more ; .
+
+This program fully considers the implications of its existance. It
+begins by questioning itself and, if successful, control flow moves to
+find the next conditional, of which there is none, so flow wraps to
+itself. If unsuccessful, it defaults to the "again" statement, which
+makes the same consideration (of which the condition is now true),
+wrapping the control flow to the previously executed "IF".

File star-w/doc/star-w.markdown

+The \*W Programming Language
+============================
+
+John Colagioia, 199?
+
+Introduction
+------------
+
+The \*W language should be based on the W language which, of course,
+does not exist. Instead it is based on an assortment of odds and ends
+which could be useful in languages, but never seem to have been
+implemented (and definitely shouldn't have been implemented in the same
+language), combined with some patching added to, firstly, make \*W truly
+bizarre and, secondly, to make it as functionally complete a language as
+C and C++ (from which some concepts such as casting have been borrowed,
+as well as the name convention), for example. The data types should
+provide enough of a range that any structure may be built up, and
+includes arbitrary bitstrings, machine independant pointers (useful for
+a pass-by-reference), name bindings of data (useful for a pass-by-name),
+allows for homogenous array-like compositions, and has a semi-structured
+composite data type. All arithmetic expressions are constructed in
+prefix to preserve continuity with subroutine calls, and include a
+fairly complete set of arithmetic and bitwise operators and inbuilt
+functions to execute any calculation.
+
+The language is also quite robust in flow control, allowing for
+conditionals, iteration (bounded and unbounded), function calls,
+interrupt-driven, and even random execution. To enforce structured
+programming, however, neither a "go to" or a "come from" statement has
+been implemented in \*W.
+
+To minimize readability, of course, \*W is fully case insensitive, so
+that Count, COUNT, count, and COunT are all indistinct except under
+fairly confusing circumstances (which may or may not exist, depending on
+the implementation). Data instances must begin with an alphabetic
+character (`a`-`z` or `A`-`Z`), an underscore (`_`), or a hyphen (`-`).
+The remainder of the name may then be made up of any alphanumeric
+characters and the underscore, hyphen, and, of course, the right bracket
+(`]`). Comments are also possible in \*W (though not necessarily
+suggested as the language is fairly confusing without misspelled and
+incorrect descriptions of the program to botch things), and may be
+included in text by placing a double pipe (`||`) at the beginning of a
+comment, terminated by the doubled end-of-statement marker (`!!`). Such
+comments may be placed anywhere in the program, and should be completely
+ignored by the compiler (just as they are by most programmers). This
+does not mean that comments are equivalent to whitespace. On the
+contrary, the compiler considers comments to simply not exist,
+essentially concatenating the strings to either side of the comment.
+
+\*W, like most modern languages, is entirely freeform, meaning that
+statements are not constrained to the dimensions of, say, a punch card,
+teletype, computer monitor, or three-dimensional, virtual reality
+programmers' editor. Program format, therefore, is entirely dependant on
+input device, host computer's character set, and lack of programmer
+style, though the compiler is permitted (actually somewhat encouraged)
+to mock poor format style.
+
+\*W Data Types
+--------------
+
+The \*W data types are designed with maximum versatility in mind. With
+them, any other known (and several unknown) types may be built. In
+addition, several predefined instances of these types are provided to
+enhance the language.
+
+    `bits`   A bitstring of arbitrary length.
+    `cplx`   A complex number in the mathematical form (A + Bj) where A and B are integers and j is the square root of (-1). Each component of a cplx is specified to have a minimum precision of {-32768 ... 32767}, but may be more, depending on the implementation.
+    `sack`   A (semi)structured data type consisting of a collection of elements which can be packed, unpacked, and checked with other data.
+    `dref`   A reference to an instance of some data type.
+    `name`   A name of another datum.
+    `chrs`   A character string of arbitrary length.
+    `hole`   A data type with no value. May pose as any type.
+
+Predefined \*W Instances
+------------------------
+
+The following data instances are provided to the \*W programming
+environment to facilitate programming certain concepts which would be
+nearly impossible otherwise.
+
+    `WORLD` (`bits`)       The \*W representation of the outside world. Assigning an expression to WORLD (see below) causes the character represented by the expression to be appended to the computer display. Likewise, using WORLD in an expression represents the value of the next character in the input buffer (if any).
+    `NOWHERE` (`hole`)..   NOWHERE is a place to discard things as well as a place to get nothing. Can also be used for comparison purposes.
+    `NL` (`chrs`)          NL is a newline character.
+    `POCKET` (`sack`)      Data instances local to each subroutine. Both may be used to store any data, but RESULT will be available for the calling routine to read.
+    `RESULT` (`bits`)
+
+\*W Program Parts
+-----------------
+
+Each \*W program is made of several parts. The functions part, which
+defines any user functions, the stuff part, which defines any instances
+of data for the program, and the text part, which contains the program
+instructions, themselves.
+
+### Functions
+
+Subprograms which can be used from the Text, in the form.
+
+    @ name = Stuff Text
+
+### Stuff
+
+Declarations of data to be used by the Text portion of the program, with
+an optional constant initializer. The initial number allows multiple
+indexed instances to exist.
+
+    num/name IS type [const] !
+    num/name , num/name ... ARE ALL type [const] !
+    AUTOPACKED SACK name [, ... name] HAS type [, ... type] !
+
+### Text
+
+A list of statements, appearing as:
+
+    TEXT: {statements} :ENDTEXT
+
+W Statement Types
+-----------------
+
+    statement % expr !
+
+Runs statement with a probability of expr. If expr is less than 100, the
+statement is executed that percentage of time. If it is greater, the
+statement is executed (expr/100) more times, each time decrementing the
+value of expr by 100, and, if expr ever falls below 100, is subject to
+the first rule. A negative value for expression works just like a
+positive value, except only under conditions where program execution
+runs backward; otherwise, it is treated as a zero.
+
+    statment UNLESS expr !
+
+The statment is executed whenever encountered except in any cases when
+expr evaluates to non-zero.
+
+    statement WHEN expr !
+
+The statement is not executed when encountered, but is instead executed
+after any statement where expr currently evaluates to non-zero.
+
+    lval < expr !
+    expr > lval !
+
+Takes the value of expr and copies it into lval.
+
+    function (parameters) !
+
+Calls a function with the appropriate parameters. The parameter list
+must correspond one-to-one with the Stuff list for that function.
+
+The scoping rules in \*W are much more simplified than they would have
+been in W, had it existed: A function may only access data instances
+declared within itself, including those implicitly defined.
+
+    -|- (expr) !
+
+If expr is 0, jumps to the end of the current block (see below),
+otherwise, terminates the current expr blocks. If expr is greater than
+the current block nesting, it does nothing. If expr is negative, the
+program terminates.
+
+    & statement & statement & ... statement &&
+
+A blocking mechanism for multiple statments.
+
+\*W Mathematical Operations
+---------------------------
+
+    `^ X`      And the bits of X (yielding a single bit).
+    `. X`      Or the bits of X.
+    `? X`      Xor the bits of X.
+    `* X`      Butterfly the bits of X, i.e., 11001100 becomes 10100101.
+    `- A B`    If A and B are simple (bits, cplx, chrs, hole), identical types, subtracts B from A.
+    `/ A B`    If A and B are numeric (cplx), divides A by B.
+    `# A B`    If A and B are numeric (cplx), takes A to the B power.
+    `$ A B`    Mingles B with A.
+    `~ A B`    Selects the B bits from A.
+    `SIZE X`   Returns the size of X, in full bytes (rounded up if X is a bitstring).
+
+\*W Sack Operations
+-------------------
+
+          PACK sack data:         Add data to sack.
+          UNPACK sack data:       Remove a data-like element from sack.
+          UNPACK sack:            Remove an element from sack.
+          CHECK sack data:        Examine sack for data.
+          WEIGH sack:             Returns the weight of the sack (in bits).
+
+Other \*W Operations
+--------------------
+
+          NAME name AFTER data:   Assigns the name of data to name.
+          WHOIS (data):           Returns name suggested by data.
+          REF (data):             Returns a reference to data.
+          DATA (dref):            Returns the data referred to by ref.
+          FCHRS (chrs):           Returns the first character of the string.
+          LCHRS (chrs):           Returns the last character of the string.
+          FBIT (bits):            Returns the first (lowest) bit of the bits.
+          LBIT (bits):            Returns the last (highest) bit of the bits.
+
+Sample \*W Programs
+-------------------
+
+          1.      Functions:
+                  || No functions for this program !!
+                  Stuff:
+                          1/Hello is chrs!
+                          1/Sz, 1/Total are all cplx!
+                  Text:
+                  || Initialize the data !!
+                          Hello < "Hello, World!"!
+                          Size Hello > Sz!
+                          Total < 0!
+                  || Take the string length and multiply by 100 !!
+                          - Size - 0 Total > Total %10000!
+                  || Print and delete a character that many times !!
+                          &       WORLD < FCHRS (Hello)!
+                          &       Hello < - Hello FCHRS (Hello)!
+                          &&      %Total!
+                  || Add a newline !!
+                          WORLD < nl!
+                  :Endtext
+              Result:  Prints "Hello, World!" to the screen, followed by a
+                          newline.
+          2.      Functions:
+                          @ mult =
+                                  Stuff:
+                                          1/A, 1/B are all cplx!
+                                  Text:
+                                          cplx (RESULT) < 0!
+                                          cplx (RESULT) < - cplx (RESULT) - 0 B
+                                                  %10000!
+                                          bits (B) < RESULT!
+                                          cplx (RESULT) < 0!
+                                          cplx (RESULT) < - cplx (RESULT) - 0 A
+                                                  %B!
+                                  :Endtext
+                          @ fact =
+                                  Stuff:
+                                          1/n is cplx!
+                                  Text:
+                                          RESULT < bits (1)!
+                                          RESULT < bits (mult (n, - n 1))
+                                                  unless - 1 ?n!
+                                  :Endtext
+                  Stuff:
+                          1/Input, 1/Output are all chrs!
+                          1/SR is chrs "0"!
+                          1/Num, 1/Out, 1/Place, 1/Index, 1/Mod are all cplx 0!
+                  Text:
+                          WORLD > Input!
+                          Place < 1!
+                          Index < cplx (mult (SIZE Input, 100))!
+                          &       Num < - Num - 0 cplx (mult (Place,
+                                          - LCHRS (Input) ZR))!
+                          &       Input < - Input LCHRS (Input)!
+                          &       cplx (mult (10, Place)) > Place!
+                          &&     %Index!
+                          cplx (fact (Num)) > Out!
+                          &       - Out cplx (mult (/ Out 10, 10)) > Mod!
+                          &       + 100 / Out 10 > Out!
+                          &       + Output chrs (+ Mod Zr) > Output!
+                          &&      %%Out!
+                          Size Output > Index!
+                          Index < cplx (mult (100, Index))!
+                          &       WORLD < LCHRS (Hello)!
+                          &       Hello < - Hello LCHRS (Hello)!
+                          &&      %Index!
+                          WORLD < nl!
+                  :Endtext
+              Result:  Accepts a positive integer (n) as input, then outputs
+                          the factorial of n (n!).

File turkey-bomb/doc/turkey-bomb.markdown

+TURKEY BOMB
+===========
+
+Anonymous
+
+Introduction
+------------
+
+TURKEY BOMB, the first known programming-language-cum-drinking-game,
+evolved independently on four seperate continents and was widely used as
+an implementation base for computer operating systems for several
+centuries.
+
+Later, when computers were proven beyond a shadow of a doubt to be the
+malevolent work of unseen evil forces, and digital technology was banned
+on punishment of bodily disintigration, TURKEY BOMB thrived on, only
+slightly modified, as a popular drinking game.
+
+Now that the treaty negotiations between the UN and the world of unseen
+evil forces have been signed, however, computers are back (and in full
+force, now billions upon billions of times more efficient than they once
+were,) and TURKEY BOMB's popularity as a computer programming language
+may just be making a comeback!
+
+Archaeologists have recently uncovered the largest known collection of
+TURKEY BOMB articles. Dating from A.D. 2014 and apparently an almanac of
+black magic of some sort, with the cryptic title "Communications of the
+ACM," the remains of an almost-four-hundred-year-old periodical is
+practically all historians have to go on.
+
+Even then, this obscure grimoire talks of this language as if it were an
+already-established phenomenon - indeed, perhaps dating back to the tail
+end of the second millenium of A.D. For this reason, some scholars
+attribute the widespread popularity of this language to one CLIN\_TON, a
+great leader of the time. It is said that CLIN\_TON was such an
+excellent and heroic TURKEY BOMB jockey that "he never inhaled",
+although that is largely deemed myth, perhaps connected to the
+allegorical story of his close followers who "blew him good".
+
+Our knowledge of the time in which TURKEY BOMB originated is slim,
+indeed. As such, the remainder of this document is by no means a
+complete reconstruction of the language, for that is surely impossible.
+However, it *is* an attempt to organize, apparently for the first time
+ever, the elements of TURKEY BOMB in a human-referencable fashion.
+
+Description
+-----------
+
+To fully and exactly understand TURKEY BOMB one must first grok the
+ancient art of computer programming while under the influence of
+recreational consumables. If you are already under the influence (and
+why else would you be reading a document about a language named TURKEY
+BOMB,) congratulations, you've already taken your first steps on the
+road of becoming an expert TURKEY BOMB programmer/jockey.
+
+But do not be lulled into thinking that simply ingesting an amusing
+chemical will ensure your vainglorious TURKEY BOMB hobby or career! No
+indeed, for it is the most wise and experienced programmer who needs no
+more buzz than to program in TURKEY BOMB itself. Many teatotalling
+hackers excel at the Annual International TURKEY BOMB Open in Maui for
+this very reason. (See you there this fall!)
+
+Data Types
+----------
+
+Name
+
+Description
+
+Size
+
+`   ZILCH`
+
+"A little slice of Nirvana."
+
+Zero.
+
+`   BI_IT`
+
+A composite quantum state of information.
+
+Two thirds of a bit plus half a trit.
+
+`   AMICED`
+
+A conceptual quantum state of information.
+
+Negative six sevenths of a decimal digit.
+
+`   TRIVIA CONCERNING type`
+
+Three references: one to an object of the named type, two to TRIVIA
+objects.
+
+Exactly fifteen bytes, no exceptions.
+
+`   ADVISORY PERTAINING TO type`
+
+A quarter of a reference to a object of the given type.
+
+A quarter of the platform-defined pointer size.
+
+`   GRUBSTEAK`
+
+A fraction whose numerator is a perfect square and whose denominator is
+a prime number.
+
+No bigger than necessary.
+
+`   IMPROPER GRUBSTEAK`
+
+A GRUBSTEAK whose denominator is less than the square root of the
+numerator.
+
+Same as GRUBSTEAK.
+
+`   INDECENT GRUBSTEAK`
+
+A fraction whose numerator is a perfect square of a perfect square and
+whose denominator is a prime number whose ordinal position in the
+counting list of prime numbers is also prime.
+
+In the drinking game, whenever an INDECENT GRUBSTEAK is involved in an
+expression, everyone starts chanting "BANG BANG BANG!!!" until the
+player holding the TURKEY BOMB either finishes their drink and starts
+another, or falls down (in which case someone who hasn't been playing
+should take him or her home).
+
+Same as GRUBSTEAK.
+
+`   NOMENCLATURE`
+
+A set of variable names, defined by an EBNF expression that must contain
+at least one { } (repeated 0 or more times) term.
+
+As big as possible.
+
+`   PUDDING`
+
+An unknowable value.
+
+Infinite.
+
+`   HUMIDOR BUILT UP   FROM type, type & type`
+
+A structure containing three other types, specified at compile-time, all
+of which must be different, one of which must be another HUMIDOR.
+
+Infinite.
+
+`   HYBRID OBTAINED BY   COMBINING type & type   [WITH GUSTO]`
+
+A unified structure containing data from two different types, specified
+at compile time.
+
+The average size of the two types... which may present problems when
+accuracy of representation is desired, which is why the WITH GUSTO
+clause is made available to pad the size of a HYBRID to the larger of
+the sizes of it's two consitituent data types.
+
+`   TURKEY BOMB`
+
+A mysterious and shadowy type, suspected to be a reference to itself.
+There can only be one (no more, no less) variable of type TURKEY BOMB,
+and it is predeclared under the variable name TURKEY BOMB. A variable of
+type TURKEY BOMB (that is to say, the variable named TURKEY BOMB) can
+only take on one value, that value being TURKEY BOMB.
+
+Exactly 1 TURKEY BOMB.
+
+Paradigm
+--------
+
+When TURKEY BOMB is played as a drinking game, the TURKEY BOMB is
+represented by a real object - usually something convenient, like a
+shoe, when an impromptu game is played for fun, but the real hardcore
+TURKEY BOMB junkies insist on using either a real live turkey, or a real
+live time bomb, or ideally, both (tied *securely* together).
+
+The TURKEY BOMB is then passed from player to player while the referee
+(operating system) designates challengers (tasks). The chosen challenger
+takes a deep breath (inhales) and shouts an expression at the player
+holding the TURKEY BOMB. If the player can produce the correct result
+before the referee can, they only have to take a sip of their drink
+before passing off the TURKEY BOMB. Otherwise, it's the whole thing,
+down the hatch.
+
+If the player holding the TURKEY BOMB makes an error, they must down
+their drink and get another before trying again. If the referee makes an
+error, *everyone*, especially the referee, must down their drink, and
+get another.
+
+Variables are also declared by any player spontaneously standing up and
+shouting out a name that hasn't been mentioned yet, and a type to go
+with it, at any time.
+
+For these reasons, TURKEY BOMB should not be considered as much an
+imperative language as a "peer-pressure" one.
+
+Syntax
+------
+
+There are no comments in TURKEY BOMB; it's entire content is considered
+a comment on those who program/play it.
+
+Operators
+---------
+
+Syntax
+
+Description
+
+`   BI_IT BI_IT BI_IT ! BI_IT BI_IT BI_IT`
+
+2-bit NAND, rotate known trit left.
+
+`   BI_IT BI_IT ? BI_IT BI_IT ? BI_IT BI_IT`
+
+3-argument trit operation; unfortunately the Ancient Texts seem unclear
+on what it actually does. (The closest English translation appears to be
+"take these trits three and meditate soundly upon them.")
+
+`   $ BI_IT BI_IT BI_IT BI_IT BI_IT BI_IT $`
+
+Attempt to make a GRUBSTEAK.
+
+`   TRIVIA Y EXPR Y TRIVIA`
+
+Attempt to make a TRIVIA.
+
+`   TRIVIA BI_IT //`
+
+Attempt to connect a TRIVIA to itself and return it. The BI\_IT argument
+is required, but serves no detectably useful purpose (hardcore followers
+of the drinking game tradition insist that it's for good luck.)
+
+`   & EXPR`
+
+Do not evaluate EXPR. Not particularly useful when programming in TURKEY
+BOMB, but wow, can one of these ever screw you up in the middle of a
+game.
+
+`   \ ADVISORY ADVISORY ADVISORY ADVISORY`
+
+Returns the type thus pointed to. Also, the player holding the TURKEY
+BOMB must pass it off.
+
+`   HYBRID.type`
+
+Casts a HYBRID to either type it was defined with.
+
+`   HUMIDOR.type`
+
+Retrieves an element from a HUMIDOR.
+
+`   @ HUMIDOR`
+
+Retrieves a PUDDING which represents the entire HUMIDOR.
+
+`   PUDDING!!!!!`
+
+Attempts to deduce the existance of a HUMIDOR in the given PUDDING. The
+player to the left of the player holding the TURKEY BOMB has to keep
+drinking continuously while the computer/referee does their deducing.
+
+`   ALL BUT EXPR`
+
+Returns a PUDDING indicating everything but EXPR.
+
+`   WHEREFORE ART EXPR`
+
+Returns a PUDDING indicating the entire metaphysical nature of EXPR.
+
+`   WHEREFORE AIN'T EXPR`
+
+Short for WHEREFORE ART ALL BUT EXPR.
+
+`   WHEREFOREN'T EXPR`
+
+Short for ALL BUT WHEREFORE ART EXPR.
+
+`   GARNISH PUDDING`
+
+Convolutes the PUDDING with recent context drawn from the program. The
+player holding the TURKEY BOMB must pass it off.
+
+`   IMAGINE PUDDING, PUDDING!`
+
+Returns a NOMENCLATURE indicating all the variables unchanged between
+two PUDDINGs.
+
+`   EXPR :-> NOMENCLATURE`
+
+Mass-assign the set of variables.
+
+`   < NOMENCLATURE`
+
+Mass-retrieve the set of variables.
+
+`   NOMENCLATURE % GRUBSTEAK GRUBSTEAK`
+
+Perform iterative cypher transformation of set of names.
+
+Notes
+-----
+
+The drinking game can also be played in an asylum, replacing 'drink'
+with 'medication'. Do *not* play this game with LSD.