metanohi/site/magicng/index.md

---
abstract: The Next Generation Programming Language
---

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

+ Functional programming is, naturally, much too functional for any magic-based
  programming language, as magic is not *functional*, but
  *magical*. Magic-based software does 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 a
  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-expensive ('Central Magical Unit') 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:

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