Introduction to Esoteric Programming Languages

How to go about Esoteric Programming Languages?

Esoteric Programming Languages (EPLs) are a huge subject
There's (at least) as much to be learned in EPLs as there's in other programming languages
Many points of view: cultural, technical, theoretical, historical, anthropological, just to name the most important ones
Moral: don't expect to get a proper treatment of anything in such a short time

Mostly a lecture, to familiarise everybody with the various subjects that might warrant further study
Discussion is of course allowed and encouraged, but only when it seems interesting for most of the audience
- everybody has their own favourites in the area, and somehow oddly opinions differ about what is cool
Let's try and find the fun here!
More information could be acquired as self study or a studying group

by point: making programming hard, elegance (minimalism), exploring computational paradigms, funny syntax, thematic languages, proofs of concept
by computational paradigm: imperative (state-changing), stack-based, rewriting (string/tree/graph), cellular automata, reflective
by expressive power: FSM-level, Turing machine equivalent, unimplementable
by cultural influence: popular, influential, novel, just a new syntax for Brainfuck, number of implementations, amount of code written, kind of code written, usage in games / competitions / whatever

How to proceed with all this?

I have prepared very short introductions to different languages
I prefer historical order, in order to show what the points of various languages were at that time
Any ideas?
Want to try them out?

The privilege of being first
Satirical references to many existing programming languages (used then): PLEASE, COME FROM, hard-to-use bitwise operators
A lot of derivatives: object-oriented, threaded, trinary INTERCAL.
Actually quite a traditional imperative programming language, resembles BASIC and COBOL.
a couple of implementations
doesn't seem to inspire programmers to write programs
```
PLEASE GIVE UP
```

(successful) attempt to make an easily-compilable language
very Forth-like, once used to write many fine programs but not popular anymore
demonstrates well how terse programs can be in certain paradigms
gave important inspiration for the big two languages of -93
```
ß[^$1_=~][,]#
```

very well-known, an early attempt to make minimalist language (topped many many times)
an imperative language with 8 instructions
has inspired an endless flood of improved brainfucks, minimalist imperative languages of l.t. 8 instructions, and subsequent work (GA breeding, BF competitions)
resembles a TM with very many states, relatively easy to understand
tens of implementations (if not hundreds)
popular with program authors
a lot of interesting theoretical subsequent work, such as optimisation for numerical constants, arguments about implementation boundary cases, etc.
```
[->++<]
```

(failed) attempt at making an uncompilable language
main novelty: source code is treated as a two-dimensional grid, where characters are primitive operations on an internal stack
Resembles Forth (and Unix dc!) because of the stack-based nature
Neat, it's fun to see the instruction pointers run around the source
a couple of implementations
popular with program authors
main theoretical result: bf-93 only PDA equivalent because of boundedness
```
0"!dlroW ,olleH">:#,_@
```

programs that only rewrite themselves (by swapping instructions)
early attempt at a really weird programming language
```
Step 4. Swap step 1 with step 6.
```

a deliberate attempt to make as evil (hard-to-use) programming language as possible
features all kinds of deliberate obfuscation: IP rewrites code as it reads it, all registers keep changing, no proper operations at all
nobody knows (to day) how complex programs can be written
however, significant findings have been made that have allowed writing loops, for instance
Malbolge programs are too long to demonstrate
one implementation, de facto standard
surprisingly many programs

first time somebody with an academic background joins the movement
basically, a condensed syntax for a minimalistic version of Scheme
designed to be hard to compile (but what does that mean, actually?)
spurred a lot of excitement because it was so easily more minimalistic than Brainfuck
joins the functional programming tradition: first programs were fibonacci sequences and quines, soon followed by an Unlambda implementation in Unlambda
does not have predefined data types, other than the program source
```
` ` s ` ` sii ` ki
```

string rewriting as a paradigm
starts the trend of making (not so) early computation-related papers into programming languages
only provides constant string rewriting, but easily Turing equivalent (can produce context-dependent languages)
does not have predefined data types, other than any given substring from the total program state
```
bc::=abcd
```

string rewriting as a paradigm
starts the trend of making (not so) early computation-related papers into programming languages
only provides constant string rewriting, but easily Turing equivalent (can produce context-dependent languages)
does not have predefined data types, other than any given substring from the total program state
```
bc::=abcd
```