Added non-serious pages.

site/projects/index.org

@@ -13,6 +13,7 @@ These are my projects, new and old.
 #++exec
 #+BEGIN_SRC python3
   top_projs = (
+      'magicng',
       'gravnoise',
       'hbcht',
       'mege',

site/projects/magicng/index.org

@@ -0,0 +1,290 @@
+#+title: MagicNG
+#&summary
+The Next Generation Programming Language
+#&
+#+license: bysa
+#&toc
+
+* Chapter 1: The Future of Yesterday
+
+/Software./
+
+/Magic./
+
+Two seemingly unrelated words. Yet together they form the essentials of the new
+programming language that has already changed how computers and humans interact
+with each other: *MagicNG* (short for Magic: The Next Generation).
+
+*MagicNG* is not your common programming language; it is not biased towards one
+ or two paradigms, in fact it uses none of the existing ways of programming:
+
++ Functional programming is, naturally, much too functional for any magic-based
+  programming language, as magic is not /functional/, but
+  /magical/. Magic-based software do not require functionality as in something
+  being able to do something else, because it depends on magic which /does/
+  stuff instead of making sure that /stuff/ can be done; this makes using the
+  computer much faster.
++ Object-oriented programming does not fit very well with the ideas behind
+  *MagicNG* either. While the magic-oriented approach /is/ able to properly
+  emulate object-oriented ways of doing things, such emulations will often
+  require {CMU&abbr='Central Magical Unit'}-expensive conversions from spell
+  scrolls to object-based representations.
++ Procedural programming conflicts with the nature of magic; since in the case
+  of magic, advanced heuristics are used run a program, the simple approach of
+  procedurally executing commands pales in comparison to the magical
+  approach. The same is true for assembly programming and machine programming.
++ Logic programming is mute. Magic is always above logic. Logic is based on
+  magic. Everyone knows that.
++ Declarative programming is actually the only one of the existing widespread
+  paradigms which is even slightly like *magical programming*. Declarative
+  programming languages do, however, still base their entire existence on
+  deduction and knowledge, both of which are infinitely long below the
+  standards of magical programming languages. Deduction and knowledge are for
+  programming languages that do not /see/ how everything works, whose authors
+  do not understand the connectionabilities of everything.
+
+In short, *MagicNG* employs the *magical programming* paradigm because it is
+superior to non-magical approaches.
+
+
+** But how do I program in it?
+
+The reader should now be comfortable thinking about programming in terms of
+magic and be able to see what a big mistake it was to learn all those outdated,
+logic-based programming languages. The reader might also be a little
+overwhelmed and perhaps confused; but fear not, we will soon take a look at an
+example of MagicNG programming.
+
+Before we get to that, we will go over a few (yes, there are many more) of the
+applications of magical programming, to pique the reader's curiosity.
+
+1. First, there is the temporal improvement. Since magic is independent of the
+   flow of time, a program can be run not just everywhere, but
+   every{/when/}. This is the sole reason MagicNG is already so popular ---
+   someone spread its use many years ago, through several temporal-offset
+   MagicNG runs.
+2. Speed. The Central Magical Unit runs programs magically many times faster
+   than any CPU in existence. This is possible due both to the previously
+   explained effects of magic in programming /and/ what we will come to refer
+   as "magic downleveling" in later chapters (since magic cannot be optimized,
+   other approaches such as the downleveling approach have been developed).
+3. Code maintenance also becomes much easier, as you will see in the examples
+   and excercises.
+
+Now, to our first example. We wish to print to a computer console (on a magical
+computer) the magical string "Hello, world!". This is often accomplished in
+anything from 1 to 100 conventional lines in conventional programming
+languages; in MagicNG, it is not /that/ simple. It's another kind of simple,
+namely the /magic simple/ way, from now on referred to as the /magple/ way.
+
+To write the magple MagicNG code for this example, we first fire up our MagicNG
+interactive interpreter:
+
+#+BEGIN_SRC text
+MagicNG vX
+?
+#+END_SRC
+
+(MagicNG is not being developed because it relies on magic for updates, hence
+the 'X' version.)
+
+(The correct way to program in MagicNG is to write on pergament scrolls, but
+for the beginner it is often easier to write the magical expressions on one's
+computer and then print afterwards.)
+
+The =?= at the prompt means we can type something. Let us try typing the
+following:
+
+#+BEGIN_SRC text
+? one frog eye
+#+END_SRC
+
+What this tells the MagicNG interpreter is that if /it is not the case/ that no
+frog eyes exist in the programmer's vicinity, it will print "Hello,
+world!". The frog-eye detection is only a formality, included in MagicNG to
+make the proofs of magical truth be magically true, and so the sentence can be
+excluded if the programmer wishes so. That is, you could write
+
+#+BEGIN_SRC text
+t
+#+END_SRC
+
+which is short for "one frog eye", and it would have the same effects.
+
+MagicNG programs can be compiled (printed) to scrolls, which can then be used
+independently of a running magical computer.
+
+(Trivia: This was in fact one of the major reasons why the text-based nature of
+MagicNG was chosen over the two other proposed ways of programming: speech and
+jumping. While speech had the advantage that it worked well for people who had
+difficulties writing, history had shown that the human memory was not a good
+place to store information not meant to be changed. And while jumping was good
+for people who were only good at jumping, it was too radical an approach for
+many of the language designers.)
+
+Now, it may not be obvious to the casual non-magician why and how both "one
+frog eye" and "t" eventually prints "Hello, world!". In fact, these two
+expressions are not at all the only ways to print "Hello, world!" --- one can
+also write "traveller with seven legs", "spider queen", or something
+similar. The thing to remember is that it is /the intention/ that counts. If
+you /feel/ that the expression "bonsai of Norway" prints the sum of all
+prime numbers below 4012, then /that is what it does/.
+
+In essence, MagicNG is an *intention-based programming language*. This might at
+first sound like all other programming languages: You have an intention on
+which you base your programming. The difference here is that the intention /is/
+the programming and not just part of it. Once you have figured out what you
+want and written in down in your inner language, magic takes care of the boring
+stuff.
+
+This has the side-effect that all magic is somewhat personal; a scroll written
+by an individual A might yield different results if used by an individual B
+with different intentions than A.
+
+This means that MagicNG has *built-in encryption*.
+
+At this point some might note that this is not good for interoperability. At
+the core of MagicNG, this is true. However, one extraordinary extension has
+been made to MagicNG that makes interoperability both possible and easy:
+MagicIS (short for Magic Intention Serializer).
+
+MagicIS encodes your intention in a magical format, after which the intention
+is compiled along with your program. With MagicIS, a compiled program that
+prints "My name is Niels" might look like this (imagine it compiled on a
+scroll):
+
+#+BEGIN_SRC text
+Holy oak of honey
+,si:pmnin34_=UUe
+#+END_SRC
+
+where the =,si:= part denotes the start of the serialized intention.
+
+The MagicIS extension can be enabled on most MagicNG compilers with a
+command-line option. Note that it will need to be connected to your brain with
+a special magical interface to work.
+
+
+* Chapter 2: Real World Examples
+
+"This is all very nice," you might think, "but what is it any good for?"
+
+MagicNG can be used for everything a typical, non-magical language can be used
+for, the major differences being that MagicNG is per definition faster, better
+and easier to program in. This has been magically proven.
+
+** cat
+
+Consider the UNIX =cat= program. If written in C (even if you look at the Plan
+9 version), there are many lines of source code. If written in Python 3, there
+are 2 lines:
+
+#+BEGIN_SRC python3
+for line in open(filename):
+    print(line)
+#+END_SRC
+
+If written in MagicNG, there is _one_ line (/and/ it is magical):
+
+#+BEGIN_SRC text
+cauldron of candy
+#+END_SRC
+
+(without MagicIS enabled.)
+
+
+** Finding a value when a key is known
+
+In a non-magical programming language, you could use a hash map. Or you could
+sort the elements by their keys and use binary search. Or you could look
+through every element one by one.
+
+In MagicNG, no such algorithms are used; /magic/ finds the value. In fact, this
+reveals a large, fascinating and unavoidable part of MagicNG: it does not
+support algorithms.
+
+"No algorithms? But how, then, can I program?" you think. The answer is simple,
+and it has been explained before, but to stress it one last time: /magic/.
+
+This leads us to another important part of MagicNG: its use of the *black box
+model*. The /black box model/ has been revered all over the known universe for
+its unchangeability (it is absolute), unworsenability (since you cannot change
+it, you cannot make it worse), high suprise factor ("who knew my program could
+do /that/?!"), and lack of meaningful error messages (no errors, no worries).
+
+
+** Calculating the sum of a list of numbers
+
+In C:
+
+#+BEGIN_SRC c
+int sum(int xs[], int xs_len) {
+  int fin_sum = 0;
+  int i;
+  for (i = 0; i < xs_len; i++) {
+    fin_sum += xs[i];
+  }
+  return fin_sum;
+}
+
+[...]
+
+sum({1, 3, -2, 9}, 4);
+#+END_SRC
+
+In Python:
+
+#+BEGIN_SRC python3
+sum([1, 3, -2, 9])
+#+END_SRC
+
+In MagicNG:
+
+#+BEGIN_SRC text
+head of Macbeth
+#+END_SRC
+
+
+** A flight simulator
+
+Up until now, we have only looked at MagicNG programs spanning single
+lines. One can create a very powerful MagicNG program in one line, but
+sometimes it can be necessary to use two, or even three lines.
+
+As a flight operator, you may wish to have a very durable and efficient 3D
+flight simulator; in MagicNG such a system can be written concisely in just
+three lines of magical code (four lines with MagicIS enabled).
+
+#+BEGIN_SRC text
+dragon claw polished with golden mead
+  mead in cauldron
+tastebuds of 23 pigs
+,si:3=)uUUn!2aa
+#+END_SRC
+
+(Notice the indentation and the explicit number.)
+
+
+/[Chapters 3 through 88 have been excluded in this preview. Only members of
+the Magically Magical Magic Community (MMMC) have access to these chapters.]/
+
+
+* Chapter 89: How to Learn More
+
+To recap: MagicNG is an easy language to learn, since it not only does not
+require the user to learn about algorithms, data structures and related wastes
+of time, but actually discourages that; MagicNG encourages its users to /not
+think/ which /reduces errors/.
+
+To expand your knowledge of MagicNG, both in theory and practice, do not look
+at the examples of other MagicNG programmers, unless you are *absolutely sure*
+that their intentions are the same as yours. You can of course deduce the
+intention from a MagicIS line, but then, if you wish to base a new program on
+the old program, you will have to convert that intention to your own along with
+the actual program, which can be tedious and very difficult (MagicNG is
+actually a very complex language).
+
+What you should do is lean back in a comfy chair and look into nothingness and
+not strain your mind. That way, everything you need to know will come to you
+eventually. That's how this book was written.
+

site/writings/number-bases.org

@@ -0,0 +1,22 @@
+#+title: Number bases
+#&summary
+This is fairly serious.
+#&
+#+license: cc0
+
+| Base                  | Description                                        |
+|-----------------------+----------------------------------------------------|
+| u-nary                | the always true base                               |
+| bi-nary               | the somewhat true base                             |
+| tri-nary              | hipster binary ("binary is so mainstream")         |
+| revolutio-nary        | trinary instead of binary                          |
+| counterrevolutio-nary | binary                                             |
+| imagi-nary            | unary imagined to be useful                        |
+| visio-nary            | binary or trinary, depending on the person         |
+| statio-nary           | trinary or binary, depending on the person         |
+| ordi-nary             | base 10 ("this works, so why use something else?") |
+| extraordi-nary        | base 11                                            |
+| veteri-nary           | base 14 ("Tetra? Is that an animal?")              |
+| no-nary               | unary                                              |
+| u-r-i-nary            | binary (mind melt)                                 |
+| evolutio-nary         | base 60                                            |