Logo

MagicNG

From 2012.

Chapter 1: The Future of Yesterday

Software.

Magic.

Two seemingly unrelated words. Yet together they form the essentials of the new programming language which 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:

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 everywhen. 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:

MagicNG vX
?

(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:

? one frog eye

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

t

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 it 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):

Holy oak of honey
,si:pmnin34_=UUe

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:

for line in open(filename):
    print(line)

If written in MagicNG, there is one line (and it is magical):

cauldron of candy

(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 surprise 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:

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);

In Python:

sum([1, 3, -2, 9])

In MagicNG:

head of Macbeth

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).

dragon claw polished with golden mead
  mead in cauldron
tastebuds of 23 pigs
,si:3=)uUUn!2aa

(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 not only does it 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.