Update

3d_rendering.md

@@ -244,7 +244,7 @@ One frame of the animation should look like this:
 press key to animate
 ```
 
-**PRO TIP**: It also help if you learn a bit about [photography](photo.md) because 3D usually tries to simulate [cameras](camera.md) and 3D programmers adopt many terms and concepts from photography. At least learn the very basics such as [focal length](focal_length.md), [pinhole camera](pinhole_camera.md), the "exposure triangle" (shutter speed, [aperture](aperture.md), [ISO](iso.md)) etc. You should know how focal length is related to [FOV](fov.md), what the "f number" means, how to use exposure settings to increase or decrease things like [motion blur](motion_blur.md) and [depth of field](depth_of_field.md), what [HDR](hdr.md) means etc.
+**PRO TIP**: It will also help if you learn a bit about [photography](photo.md) because 3D usually tries to simulate [cameras](camera.md) and 3D programmers adopt many terms and concepts from photography. At least learn the very basics such as [focal length](focal_length.md), [pinhole camera](pinhole_camera.md), the "exposure triangle" (shutter speed, [aperture](aperture.md), [ISO](iso.md)) etc. You should know how focal length is related to [FOV](fov.md), what the "f number" means, how to use exposure settings to increase or decrease things like [motion blur](motion_blur.md) and [depth of field](depth_of_field.md), what [HDR](hdr.md) means etc.
 
 ## Mainstream Realtime 3D
 

algorithm.md

@@ -222,7 +222,7 @@ $1 2 = ?
 .
 ```
 
-and in Scheme [Lisp](lisp.md) as (here notice the difference in [paradigm](paradigm.md) -- loop is replaced with [recursion](recursion.md), as it's done in [functional](functional.md) programming):
+in Scheme [Lisp](lisp.md) as (here notice the difference in [paradigm](paradigm.md) -- loop is replaced with [recursion](recursion.md), as it's done in [functional](functional.md) programming):
 
 ```
 (define (countDivisors x countFrom currentCount) ; recursive function
@@ -240,6 +240,61 @@ and in Scheme [Lisp](lisp.md) as (here notice the difference in [paradigm](parad
 (countDivisors (read) 1 0)
 ```
 
+and also for [fun](fun.md) in [Brainfuck](brainfuck.md) (a bit simplified version, made with our [Macrofucker](macrofucker.md) language):
+
+```
+[-]>[-]++++++++++++++++++++++++++++++++++++++++++++++++>,>[-]>[-]<<<[->>+>+<<<]
+>>>[-<<<+>>>]<[-<->]<>[-]<[->+<]<[->+<]>>[-<<+>>]<[-]++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++>[-]>
+[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<>[-]<<-[->>>
+[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<+>]<<<]>>[-<<<+>>>]<<<>[-]+++++++++++++++
++++++++++++++++++++++++++++++++++>,>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<->]<>
+[-]<[->+<]<[->+<]>>[-<<+>>]<[-]++++++++++>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<>[
+-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<>[-]<<-[->>>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>
+]<[-<+>]<<<]>>[-<<<+>>>]<<<>[-]<[->+<]<[->+<]>>[-<<+>>]<<>[-]>[-]<<<[->>+>+<<<]
+>>>[-<<<+>>>]<[-<+>]<>[-]++++++++++++++++++++++++++++++++++++++++++++++++>,>[-]
+>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<->]<>[-]<[->+<]<[->+<]>>[-<<+>>]<<>[-]>[-]<<
+<[->>+>+<<<]>>>[-<<<+>>>]<[-<+>]<>[-]<[->+<]<<<[->>>+<<<]>>>>[-<<<<+>>>>]<<<<>[
+-]>[-]<<[->+>+<<]>>[-<<+>>]<[>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<>[-]>[-]<<<[->
+>+>+<<<]>>>[-<<<+>>>]<>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<<<[-]>>>[-]>[-]>[-]<<
+<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<+<[->
+->[-]>[-]<<[->+>+<<]>>[-<<+>>]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]]<<]<>[-]+<[[
+-]>-<]>[<+>[-]]<[<<<+>>>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<->]<>[-]>[-]>[-]<
+<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<+<[-
+>->[-]>[-]<<[->+>+<<]>>[-<<+>>]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]]<<]<>[-]+<[
+[-]>-<]>[<+>[-]]<]<>[-]<[->+<]<[->+<]>>[-<<+>>]<<>[-]+<[[-]>-<]>[<+>[-]]<[<<<<+
+>>>>[-]]<<-]<<>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<>[-]
+>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<<<[-]>>>[-]
+>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>
+>>>]<+<[->->[-]>[-]<<[->+>+<<]>>[-<<+>>]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]]<<
+]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<->]<>[-
+]>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+
+>>>>]<+<[->->[-]>[-]<<[->+>+<<]>>[-<<+>>]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]]<
+<]<>[-]+<[[-]>-<]>[<+>[-]]<]<>[-]<[->+<]<[->+<]>>[-<<+>>]<<>[-]<[->+<]<[->+<]>>
+[-<<+>>]<>[-]++++++++++++++++++++++++++++++++++++++++++++++++>[-]>[-]<<<[->>+>+
+<<<]>>>[-<<<+>>>]<[-<+>]<.<<<[-]++++++++++>>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<
+>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<<<[-]>>>[-]>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<
+<<<+>>>>]<>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<+<[->->[-]>[-]<<[->+>+<<]>>
+[-<<+>>]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]]<<]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>
+>>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<->]<>[-]>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-
+<<<<+>>>>]<>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<+<[->->[-]>[-]<<[->+>+<<]>
+>[-<<+>>]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]]<<]<>[-]+<[[-]>-<]>[<+>[-]]<]<>[-
+]<[->+<]<[->+<]>>[-<<+>>]<<>[-]<[->+<]<[->+<]>>[-<<+>>]<>[-]+++++++++++++++++++
++++++++++++++++++++++++++++++>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<+>]<.<>[-]<
+[->+<]<[->+<]>>[-<<+>>]<>[-]++++++++++++++++++++++++++++++++++++++++++++++++>[-
+]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<+>]<.<<<<>[-]++++++++++.[-]++>[-]>[-]<<<[->
+>+>+<<<]>>>[-<<<+>>>]<>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<->]<>[-]+<[[-]>-<]
+>[<+>[-]]<[[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++.[-]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++.[-]++++++++++.[-]]
+```
+
 TODO: assembly, haskell, unix shell, ...
 
 This algorithm is however not very efficient and could be **[optimized](optimization.md)** -- for example not only we wouldn't have to check if a number is divisible by 1 and itself (as every number is), but there is also no need to check divisors higher than the [square root](sqrt.md) of the checked value (mathematically above square root there only remain divisors that are paired with the ones already found below the square root) so we could lower the number of the loop iterations and so make the algorithm finish faster. You may try to improve the algorithm this way as an exercise :-)

assembly.md

@@ -1,6 +1,6 @@
 # Assembly
 
-Assembly (also ASM) is, for any given [hardware](hw.md) computing platform ([ISA](isa.md), basically a [CPU](cpu.md) architecture), the lowest level [programming language](programming_language.md) that expresses typically a linear, unstructured (i.e. without nesting blocks of code) sequence of CPU instructions -- it maps (mostly) 1:1 to [machine code](machine_code.md) (the actual [binary](binary.md) CPU instructions) and basically only differs from the actual machine code by utilizing a more human readable form (it gives human friendly nicknames, or mnemonics, to different combinations of 1s and 0s). Assembly is converted by [assembler](assembler.md) into the the machine code, something akin a computer equivalent of the "[DNA](dna.md)", the lowest level instructions for the computer. Assembly is similar to [bytecode](bytecode.md), but bytecode is meant to be [interpreted](interpreter.md) or used as an intermediate representation in [compilers](compiler.md) while assembly represents actual native code run by hardware. In ancient times when there were no higher level languages (like [C](c.md) or [Fortran](fortran.md)) assembly was used to write computer programs -- nowadays most programmers no longer write in assembly (majority of [zoomer](zoomer.md) "[coders](coding.md)" probably never even touch anything close to it) because it's hard (takes a long time) and not [portable](portability.md), however programs written in assembly are known to be extremely fast as the programmer has absolute control over every single instruction (of course that is not to say you can't fuck up and write a slow program in assembly).
+Assembly (also ASM) is, for any given [hardware](hw.md) computing platform ([ISA](isa.md), basically a [CPU](cpu.md) architecture), the native, lowest level [programming language](programming_language.md) that expresses typically a linear, unstructured (i.e. without nesting blocks of code) sequence of very simple CPU instructions -- it maps (mostly) 1:1 to [machine code](machine_code.md) (the actual [binary](binary.md) CPU instructions) and basically only differs from the actual machine code by utilizing a more human readable form (it gives human friendly nicknames, or mnemonics, to different combinations of 1s and 0s). Assembly is converted by [assembler](assembler.md) into the the machine code, something akin a computer equivalent of the "[DNA](dna.md)", the lowest level instructions for the computer. Assembly is similar to [bytecode](bytecode.md), but bytecode is meant to be [interpreted](interpreter.md) or used as an intermediate representation in [compilers](compiler.md) and may even be quite high level while assembly represents actual native code run by the hardware. In ancient times when there were no higher level languages (like [C](c.md) or [Fortran](fortran.md)) assembly was used to write computer programs -- nowadays most programmers no longer write in assembly (majority of [zoomer](zoomer.md) "[coders](coding.md)" probably never even touch anything close to it) because it's hard (takes a long time) and not [portable](portability.md), however programs written in assembly are known to be extremely fast as the programmer has absolute control over every single instruction (of course that is not to say you can't fuck up and write a slow program in assembly) and is able to manually [optimize](optimization.md) every single detail about the program.
 
 { see this meme lol :D http://lolwut.info/images/4chan-g1.png ~drummyfish }
 
@@ -12,7 +12,7 @@ The most common assembly languages you'll encounter nowadays are **[x86](x86.md)
 
 To be precise, a typical assembly language is actually more than a set of nicknames for machine code instructions, it may offer helpers such as [macros](macro.md) (something akin the C preprocessor), pseudoinstructions (commands that look like instructions but actually translate to e.g. multiple instructions), [comments](comment.md), directives, automatic inference of opcode from operands, named labels for jumps (as writing literal jump addresses would be extremely tedious) etc. I.e. it is still much easier to write in assembly than to write pure machine code even if you knew all opcodes from memory. For the same reason remember that just replacing assembly mnemonics with binary machine code instructions is not yet enough to make an executable program! More things have to be done such as [linking](linking.md) [libraries](library.md) and converting the result to some [executable format](executable_format.md) such as [elf](elf.md) which contains things like header with metainformation about the program etc.
 
-**How will programming in assembly differ from your mainstream high-level programming?** Quite a lot, assembly is extremely low level, so you get no handholding or much programming "safety" (apart from e.g. CPU operation modes), you have to do everything yourself -- you'll be dealing with things such as function [call conventions](call_convention.md), [interrupts](interrupt.md), [syscalls](syscall.md) and their conventions, counting CPU cycles of individual instructions, looking up exact hexadecimal memory addresses, opcodes, defining memory segments, dealing with [endianness](endianness.md), raw [goto](goto.md) jumps, [call frames](call_frame.md) etc. You have no branching (if-then-else), loops or functions, you make these yourself with gotos. You can't write expressions like `(a + 3 * b) / 10`, no, you have to write every step of how to evaluate this expression using registers, i.e. something like: load *a* to register *A*, load *b* to register *B*, multiply *B* by 3, add register *B* to *A*, divide *A* by 10. You don't have any [data types](data_type.md), you have to know yourself that your variables really represent signed values so when you're dividing, you have to use signed divide instruction instead of unsigned divide -- if you mess this up, no one will tell you, your program simply won't work. And so on.
+**How will programming in assembly differ from your mainstream high-level programming?** Quite a lot, assembly is extremely low level, so you get no handholding or much programming "safety" (apart from e.g. CPU operation modes), you have to do everything yourself -- for example assembly languages are **untyped**, i.e. no one is going to offer or check your data types, everything is just 1s and 0s. You will also be dealing with things such as function [call conventions](call_convention.md), call stack and call frames, [interrupts](interrupt.md), overflows, [system calls](syscall.md) and their conventions, counting CPU cycles of individual instructions, looking up exact hexadecimal memory addresses, studying opcodes, defining memory segments, dealing with [endianness](endianness.md), raw [goto](goto.md) jumps, manual [memory management](memory_management.md) etc. You have no branching (if-then-else), loops or functions, you make these yourself with gotos. You can't write expressions like `(a + 3 * b) / 10`, no, you have to write every single step of how to evaluate this expression using registers, i.e. something like: load *a* to register *A*, load *b* to register *B*, multiply *B* by 3, add register *B* to *A*, divide *A* by 10. As said, you don't have any [data types](data_type.md), you have to know yourself that your variables really represent let's say a signed value so when you're dividing, you have to use signed divide instruction instead of unsigned divide -- if you mess this up, no one will tell you, your program simply won't work. And so on.
 
 ## Typical Assembly Language
 
@@ -24,7 +24,7 @@ The working of the language reflects the actual [hardware](hardware.md) architec
 
 Writing instructions works similarly to how you call a [function](function.md) in high level language: you write its name and then its [arguments](argument.md), but in assembly things are more complicated because an instruction may for example only allow certain kinds of arguments -- it may e.g. allow a register and immediate constant (kind of a number literal/constant), but not e.g. two registers. You have to read the documentation for each instruction. While in high level language you may write general [expressions](expression.md) as arguments (like `myFunc(x + 2 * y,myFunc2())`), here you can only pass specific values.
 
-There are also no complex [data types](data_type.md), assembly only works with numbers of different size, e.g. 16 bit integer, 32 bit integer etc. Strings are just sequences of numbers representing [ASCII](ascii.md) values, it is up to you whether you implement null terminated strings or Pascal style strings. [Pointers](pointer.md) are just numbers representing addresses. It is up to you whether you interpret a number as signed or unsigned (some instructions treat numbers as unsigned, some as signed, some don't care because it doesn't matter).
+There are also no advanced [data types](data_type.md), assembly only works with numbers of different sizes, e.g. 16 bit integer, 32 bit integer etc. Strings are just sequences of numbers representing [ASCII](ascii.md) values, it is up to you whether you implement null terminated strings or Pascal style strings. [Pointers](pointer.md) are just numbers representing addresses. It is up to you whether you interpret a number as signed or unsigned (some instructions treat numbers as unsigned, some as signed, some don't care because it doesn't matter).
 
 Instructions are typically written as three-letter abbreviations and follow some unwritten naming conventions so that different assembly languages at least look similar. Common instructions found in most assembly languages are for example:
 

brainfuck.md

@@ -35,18 +35,18 @@ Brainfuck source code files usually have *.bf* or *.b* extension.
 
 ## Implementation
 
-This is a very simple [C](c.md) implementation of brainfuck:
+This is a very simple [C](c.md) implementation of Brainfuck interpreter:
 
 ```
 #include <stdio.h>
 
-#define CELLS 30000
-
 const char program[] = ",[.-]"; // your program here
 
+#define CELLS 30000
+char tape[CELLS];
+
 int main(void)
 {
-  char tape[CELLS];
   unsigned int cell = 0;
   const char *i = program;
   int bDir, bCount;
@@ -89,12 +89,68 @@ int main(void)
     
     i++;
   }
+  
+  return 0;
 }
-
 ```
 
+TODO: brainfuck to C translator
+
 TODO: comun implementation
 
+Advanced Brainfuck implementations may include [optimizations](optimization.md), for example things like `>>><<>` may be reduced to `>>` etc.
+
+And here is a Brainfuck to C transpiler, written in C, which EVEN does the above simple optimization of grouping together additions, subtractions and shifts. It will allow you to compile Brainfuck to native executables. The code is possibly even simpler than the interpreter:
+
+```
+#include <stdio.h>
+
+int main(void)
+{
+  int c, cNext;
+
+  puts("#include <stdio.h>\nunsigned char m[1024];\n"
+       "char *c = m;\nint main(void) {");
+
+#define NEXT { c = cNext; cNext = getchar(); }
+
+  NEXT NEXT
+
+  while (c != EOF)
+  {
+    switch (c)
+    {
+      case '>': case '<': case '+': case '-':
+      {
+        unsigned int n = 1;
+
+        while (cNext == c)
+        {
+          NEXT
+          n++;
+        }
+
+        printf("  %s %c= %u;\n",(c == '<' || c == '>') ? "c" : "*c",
+          (c == '>' || c == '+') ? '+' : '-',n);
+
+        break;
+      }
+
+      case '.': puts("  putchar(*c);"); break;
+      case ',': puts("  *c = getchar();"); break;
+      case '[': puts("  while (*c) {"); break;
+      case ']': puts("  }"); break;
+      default: break;
+    }
+
+    NEXT
+  }
+
+  puts("return 0; }");
+  return 0;
+}
+```
+
 ## Programs
 
 Here are some simple programs in brainfuck.
@@ -113,6 +169,131 @@ Read two 0-9 numbers (as ASCII digits) and add them:
 
 TODO: more
 
+## Making Brainfuck Usable: Defining Macrofucker
+
+{ There probably exist BF derivatives in this spirit, it's very natural, I didn't bother checking too much, here I just want to derive this from scratch myself, for educational purposes. ~drummyfish }
+
+What if we want to actually write a more complex program in Brainfuck? How do we tame the beast and get out of the Turing tarpit? We may build a metalanguage on top of Brainfuck that will offer more convenient constructs and will compile to Brainfuck, and maybe we'll learn something about building and [bootstrapping](bootstrap.md) computing environments along the way :) We may do this e.g. with a simple system of [preprocessing](preprocessing.md) [macros](macro.md), i.e. we will create a language with more advanced commands that will be replaced by plain Brainfuck commands -- on the level of source code -- before it gets executed. This turns out to be a quite effective approach that enables us to create sort of a [Forth](forth.md)-like language in which we may program quite complex things with the stack-based computing [paradigm](paradigm.md).
+
+Hmmm okay, what name do we give the language? Let's call it **Macrofucker**. It will work like this:
+
+- Vanilla Brainfuck commands work normally, they'll be simply copied.
+- Additionally we introduce macros. A macro will be defined as: `:M<commands>;`. `:` and `;` are simply keywords separating the macro definition, `M` is the macro name, which we'll for simplicity sake limit to single uppercase letters only (so we won't be able to make more macros than there are letters), and `<commands>` are just commands that will be copy-pasted wherever the macro is used.
+- A macro will be used by simply writing its name, i.e. if we have macro `M` defined (anywhere in the source code), we can use it by simply writing `M`. Optionally we may call it with numeric parameter as `MX`, where `X` is a decimal number. If no parameter is given, we consider it 0. Macro may be invoked even inside another macro.
+- Inside a macro definition we may use the symbol `$` that will repeat the next character by the macro's parameter number of times.
+
+For example consider the following piece of code:
+
+```
+:X[-]$+; >X10 >X11 >X12 >X13
+```
+
+We first define macro called `X` that serves for storing constants in cells. The macro first zeroes the cell (`[-]`) and then repeats the character `+` the argument number of times. Then we use the macro 4 times, with constants 10, 11, 12 and 13. We also shift right before each macro invocation so it's as if we're pushing the constants on the stack. This code will compile to:
+
+```
+>[-]++++++++++>[-]+++++++++++>[-]++++++++++++>[-]+++++++++++++
+```
+
+If we examine and run the code, we indeed find that we end up with the values 10, 11, 12 and 13 on the tape:
+
+```
+0 10 11 12 13
+           ^
+```
+
+Implementing the preprocessor is about as simple as implementing Brainfuck itself: pretty easy. As soon as we have the preprocessor, we may start implementing a "[library](library.md)" of macros, i.e. we may expand Brainfuck by adding quite powerful commands -- the [beauty](beauty.md) of it is we'll be expanding the language in Macrofucker itself from now on, no more C code is required beyond writing the simple preprocessor. This is a very cool, [minimalist](minimalism.md) approach of building complex things by adding simple but powerful extensions to very simple things, the kind of incremental programming approach that's masterfully applied in languages such as [Forth](forth.md) and [Lisp](lisp.md).
+
+So here it is, the Macrofucker preprocessor in C, along with embedded code of the program it processes -- here we include simple library that even includes things such as division, modulus and printing and reading decimal values:
+
+```
+#include <stdio.h>
+
+const char program[] =
+  // the library (WARNING: cells to the right may be changed):
+  ":Z[-];"                                       // zero: c[0] = 0
+  ":L$<;"                                        // left: c -= N
+  ":R$>;"                                        // right: c += N
+  ":I$+;"                                        // inc: c[0] += N
+  ":D$-;"                                        // dec: c[0] -= N
+  ":XZ$+;"                                       // const: c[0] = N
+  ":N>Z+<[Z>-<]>[<$++>Z]<;"                      // not: c[0] = c[0] == 0 ? N + 1 : 0
+  ":CZ>Z<<$<[-$>>+>+<$<<]$>>>[-<$<<+>>$>]<;"     // copy: c[0] = c[-(N + 1)]
+  ":M>C<Z>[-<$-->]<;"                            // minus: c[0] *= -(N + 1)
+  ":F>Z<[->+<]<$<[->$>+<$<]$>>>[-<<$<+>>$>]<;"   // flip: SWAP(c[0],c[-(N + 1)])
+  ":A>C1[-<+>]<;"                                // add: c[0] += c[-1]
+  ":S>C1[-<->]<;"                                // subtract: c[0] -= c[-1]
+  ":T>C1>C1>Z<<-[->>A<<]>>[-L3+R3]L3;"           // times: c[0] *= c[-1]
+  ":EC1>C1[-<->]<N;"                             // equals: c[-2] == c[-1] ? 1 : 0
+  ":GZ>C2>C2+<[->->CN[L3+R3Z]<<]<;"              // greater: c[-1] > c[0] ? 1 : 0
+  ":B>C1>C1<<Z>>>GN[L3+>>S>GN]<F<;"              // by: c[1] = c[0] % c[-1]; c[0] = c[0] / c[-1]; c++
+  ":P>X100>C1BF>X48A.L3X10>BF>X48A.<F>X48A.L4;"  // print: print byte as decimal
+  ":VX48>,SFX100T>X48>,SFX10TF<A>X48>,SF<AF2L3;" // value: reads decimal number of three digits
+  // the main program itself:
+  "Z>V>C[>C1BN[L4+R4Z]<<-]<<P>X10.X2>E[X112.X114.X105.X109.X101.X10.Z]"
+;
+
+void process(const char *c, int topLevel)
+{
+  char f = *c;        // macro name to search
+  unsigned int n = 0; // macro argument
+
+  if (!topLevel)
+  {
+    // read argument
+    c++;
+
+    while (*c >= '0' && *c <= '9')
+    {
+      n = 10 * n + *c - '0';
+      c++;
+    }
+  }
+
+  c = program;
+
+  while (*c) // search for the macro
+  {
+    if (topLevel || (c[0] == ':' && c[1] == f))
+    {
+      c += topLevel ? 0 : 2; // skip the beginning macro chars
+
+      while (*c && *c != ';')
+      {
+        if (*c == ':')
+          while ((*++c) != ';'); // skip macro definitions
+        else if (*c == '+' || *c == '-' || *c == '<' || *c == '>' ||
+          *c == '[' || *c == ']' || *c == '.' || *c == ',')
+          putchar(*c);           // normal BF commands
+        else if (*c >= 'A' && *c <= 'Z')
+          process(c,0);          // macro
+        else if (*c == '$')
+        {
+          c++;
+          for (unsigned int i = 0; i < n; ++i)
+            putchar(*c);
+        }
+
+        c++;
+      }
+
+      return;
+    }
+
+    c++;
+  }
+}
+
+int main(int argc, char **argv)
+{
+  process(program,1);
+  putchar(0);  // allows separating program on stdin from program input
+  // puts("013"); // program input may go here
+  return 0;
+}
+```
+
+The main program we have here is the example program from the [algorithm](algorithm.md) article: it reads a number, prints the number of its divisors and says if the number is [prime](prime.md). Code of the Brainfuck program will be simply printed out on standard output and it can then be run using our Brainfuck interpreter above. Unlike "hello world" this is already a pretty cool problem we've solved with Brainfuck, and we didn't even need that much code to make it happen. Improving this further could allow us to make a completely usable (though, truth be said, probably slow) language. Isn't this just beautiful? Yes, it is :)
+
 ## Variants
 
 TODO

fight_culture.md

@@ -1,6 +1,6 @@
 # Fight Culture
 
-Fight culture is the [harmful](harmful.md), mostly western mindset of seeing any endeavor as a fight against something. Even such causes as aiming for establishment of [peace](peace.md) are seen as fighting the people who are against peace, which is [funny](fun.md) but also sad. Fight culture keeps, just by the constant repetition of the word *fight* (and similar ones such as *combat*, *win* etc.), a subconscious validation of violence as justified and necessary means for achieving any goal. Fight culture is to a great degree the culture of [capitalist](capitalism.md) society (of course not exclusively), the environment of extreme [competition](competition.md) and hostility. It fuels [war](war.md) mentality, hostility, [fear culture](fear_culture.md) (everyone is your enemy!), constant unrest leading to mental health deterioration, obsession with various kinds of protections against everything etc. Fight is a mechanism of the jungle, something a civilized society tries to distance itself from -- sustaining the mechanisms of the jungle means we are only implementing cosmetic changes. It is ridiculous, our society is now one big fight: against global warming, unemployment, inflation, [unproductivity](productivity_cult.md),  traffic jams, hunger, too little hunger etc. Perhaps in a few years it won't even sound so weird to say you are fighting a road when you try to get from point A to point B or that you are fighting air when riding your bike.
+Fight culture is the [harmful](harmful.md), mostly western mindset of seeing any endeavor as a fight against something. Even such causes as aiming for establishment of [peace](peace.md) are seen as fighting the people who are against peace, which is [funny](fun.md) but also sad. Fight culture keeps, just by the constant repetition of the word *fight* (and similar ones such as *combat*, *win* etc.), a subconscious validation of violence as justified and necessary means for achieving any goal. Fight culture is to a great degree the culture of [capitalist](capitalism.md) society (of course not exclusively), the environment of extreme [competition](competition.md) and hostility. It fuels [war](war.md) mentality, hostility, [fear culture](fear_culture.md) (everyone is your enemy!), constant unrest leading to mental health deterioration, obsession with various kinds of protections against everything etc. Fight is a mechanism of the jungle, something a civilized society tries to distance itself from -- sustaining the mechanisms of the jungle means we are only implementing cosmetic changes. It is laughable but also tragic, our society is now one big fight: for "human [rights](rights_culture.md)", education, for respect and dignity, against illnesses, criminality, global warming, unemployment, inflation, [unproductivity](productivity_cult.md), traffic jams, hunger and poverty etc. [Language](human_language.md) reflects our inner mindset: we say we "fight" our shortcomings or "defend" ourselves in a discussion, as if starting a discussion was not an invitation to collaboratively search for truth but rather a personal attack. Instead of collaboration and unity we perceive only war and hostility -- if someone is "on our side" then only temporarily, for strategic or tactical reasons of self benefit in this huge conflict. Perhaps soon it won't even sound so odd to say you are fighting the road when traveling from point A to point B or that you are fighting water when you're swimming and then fighting the Sun when you lie on the beach.
 
 [We](lrs.md), of course, see fight culture as highly undesirable for a [good society](less_retarded_society.md) as that needs to be based on peace, [love](love.md) and [collaboration](collaboration.md), not [competition](competition.md). For this reasons we never say we "fight" anything (or even "win", we rather achieve goals), we rather aim for goals, look for solutions, educate and sometimes reject, avoid, refuse and oppose bad concepts (e.g. fight culture itself).
 

jokes.md

@@ -8,7 +8,7 @@ Also remember the worst thing you can do to a joke is put a [disclaimer](disclai
 
 { Many of the jokes are original, some are shamelessly pulled from other sites and reworded. I don't believe [copyright](copyright.md) can apply if the expression of a joke is different, ideas can't be copyrighted. Also the exact origins of jokes are difficult to track so it's probably a kind of folklore. ~drummyfish }
 
-{ I would like to thank one anonymous friend who contributed to me many ideas for jokes here :D I usually modified them slightly. ~drummyfish }
+{ I would like to thank my friend Ramon who contributed to me many ideas for jokes here :D I usually modified them slightly. ~drummyfish }
 
 - [C++](cpp.md)
 - Why is the maximum speed called terminal velocity? Because [GUI](gui.md)s are slow.
@@ -29,16 +29,18 @@ Also remember the worst thing you can do to a joke is put a [disclaimer](disclai
 - "Never test for a bug that you don't know how to fix." --manager; "If we cannot fix it, it isn't broken." --also manager
 - a joke for minimalists:
 - When is [Micro$oft](microsoft.md) finally gonna make a product that doesn't suck???! Probably when they start manufacturing vacuum cleaners.
+- Why does a [Ruby](ruby.md) hater dislike [gemini](gemini.md)? Because it has gem. { Thanks to my dear friend :D ~drummyfish }
 - Can [free software](free_software.md) lead to insanity? I don't know, but it can make you [GNU](gnu.md)ts.
 - Man sits on a toilet, taking a [shit](shit.md), he takes a piece of toilet paper, wipes sweat off of his face, then wipes his ass with it and goes away. The next day he does the same, he sits, takes a shit, wipes his face, wipes his ass, goes away. The third day he goes to the toilet, takes a shit, wipes his ass, wipes his face... oh shit :D { I came up with this when I was taking a shit. ~drummyfish }
 - Political activists walk into a bar. [Pseudoleftist](pseudoleft) tells his friends: "hey guys, how about we have oppressive rulers and call them a [government](government.md)?" Capitalist says: "well no, let's have oppressive rulers and call them [corporations](corporation.md)". [Liberal](liberal.md) replies: "Why not both?". Monarchist goes: "no, it's all wrong, let's have oppressive rulers and call them Kings." To this pseudo communist says: "that's just shit, let's have oppressive rulers and call them the [proletariat](proletariat.md)". Then [anarcho pacifist](anpac.md) turns to them and says: "Hmmm, how about we don't have any oppressive rulers?". They lynch him.
 - There are a lot of jokes at https://jcdverha.home.xs4all.nl/scijokes/. Also http://textfiles.com/humor/JOKES/, http://textfiles.com/humor/TAGLINES/quotes-1.txt and so on. Also on [wikiwikiweb](wikiwikiweb.md) under *CategoryJoke*, *ProgrammerLightBulbJokes*, also https://www.gnu.org/fun/ etc.
-- Hello, is this anonymous [pedophile](pedophilia.md) help hotline? Yes. My 8yo daughter begs for sex, can we do penetration right away or should we start with anal?
+- Hello, is this anonymous [pedophile](pedophilia.md) help hotline? Yes. My 8yo wants it real bad, will I give her better pleasure with oral or anal?
 - What do you call a [woman](woman.md) that made a computer explode just by typing on it? Normal.
 - Does the invisible hand exist in the [free market](free_market.md)? Maybe, but if so then all it's doing is masturbating (or giving us a middle finger).
 - 90% of statistics are fake.
 - When will they remove the *[touch](touch.md)* and *[kill](kill.md)* commands from [Unix](unix.md)? Probably when they rename *[man pages](man_page.md)* to *person pages*.
 - If [law](law.md) was viewed as a programming code, it would be historically the worst case of [bloated](bloat.md) [spaghetti code](spaghetti_code.md) littered with [magic constants](magic_constant.md), undefined symbols and dead code, which is additionally deployed silently and without any [testing](testing.md). Yet it's the most important algorithm of our society.
+- What does a [chess](chess.md) player say when he meets another chess player? h[Elo](elo.md). { Again thanks to a friend <3 ~drummyfish }
 - C++ is to C as brain cancer is to brain.
 - [Entropy](entropy.md) is no longer what it used to be. Nostalgia too.
 - At the beginning there was [machine code](machine_code.md). Then they added [assembly](assembly.md) on top of it to make it more comfortable. To make programs portable they created an [operating system](os.md) and a layer of [syscalls](syscall.md). Except it didn't work because other people made other operating systems with different syscalls. So to try to make it portable again they created a high-level language [compiler](compiler.md) on top of it. To make it yet more comfortable they created yet a higher level language and made a [transpiler](transpiler.md) to the lower level language. To make building more platform independent and comfortable they created [makefiles](makefile.md) on top of it. However, more jobs were needed so they created [CMake](cmake.md) on top of makefiles, just in case. It seems like CMake nowadays seems too low level so a new layer will be needed above all the meta-meta-meta build systems. I wonder how high of a tower we can make, maybe they're just trying to get a Guinness world record for the greatest bullshit sandwich in history.

macrofucker.md

@@ -0,0 +1,3 @@
+# Macrofucker
+
+Please see [Brainfuck](brainfuck.md).

main.md

@@ -123,7 +123,7 @@ Are you a noob but see our ideas as appealing and would like to join us? Say no
 Here there are quick directions to some of the important topics; for more see the links provided at the top that include the list of all articles as well as a single page HTML which is good for "fulltext search" via crtl+F :)
 
 - **basics**: [bloat](bloat.md) -- [capitalist software](capitalist_software.md) -- [less retarded society](less_retarded_society.md) -- [LRS](lrs.md) -- [pseudoleft](pseudoleft.md)
-- **LRS inventions/propositions**: [A/B fail](fail_ab.md) -- [Anarch](anarch.md) -- [boat](boat.md) webring -- [comun](comun.md) -- [freedom distance](freedom_distance.md) -- less retarded [chess](chess.md) -- [less retarded hardware](less_retarded_hardware.md) -- [less retarded society](less_retarded_society.md) -- [less retarded software](lrs.md) -- [less retarded watch](less_retarded_watch.md) -- [less retarded wiki](lrs_wiki.md) -- [public domain computer](public_domain_computer.md) -- [raycastlib](raycastlib.md) -- [rock carved binary data](rock_carved_binary_data.md) -- [SAF](saf.md) -- [small3dlib](small3dlib.md) -- [smallchesslib](smallchesslib.md) -- [tinyphysicsengine](tinyphysicsengine.md) -- [world broadcast](world_broadcast.md) -- [unretardation](unretard.md)
+- **LRS inventions/propositions**: [A/B fail](fail_ab.md) -- [Anarch](anarch.md) -- [boat](boat.md) webring -- [comun](comun.md) -- [freedom distance](freedom_distance.md) -- less retarded [chess](chess.md) -- [less retarded hardware](less_retarded_hardware.md) -- [less retarded society](less_retarded_society.md) -- [less retarded software](lrs.md) -- [less retarded watch](less_retarded_watch.md) -- [less retarded wiki](lrs_wiki.md) -- [macrofucker](macrofucker.md) -- [public domain computer](public_domain_computer.md) -- [raycastlib](raycastlib.md) -- [rock carved binary data](rock_carved_binary_data.md) -- [SAF](saf.md) -- [small3dlib](small3dlib.md) -- [smallchesslib](smallchesslib.md) -- [tinyphysicsengine](tinyphysicsengine.md) -- [world broadcast](world_broadcast.md) -- [unretardation](unretard.md)
 - **programming/computers**: [3D rendering](3d_rendering.md) -- [binary](binary.md) -- [computer](computer.md) -- [AI](ai.md) -- [algorithm](algorithm.md) -- [C](c.md) -- [C tutorial](c_tutorial.md) -- [computer](computer.md) -- [computer graphics](graphics.md) -- [CPU](cpu.md) -- [data structure](data_structure.md) -- [demoscene](demoscene.md) -- [GNU](gnu.md) -- [hacker culture](hacking.md) -- [hardware](hardware.md) -- [Internet](internet.md) -- [KISS](kiss.md) -- [Linux](linux.md) -- [OOP](oop.md) -- [open consoles](open_console.md) -- [operating system](os.md) -- [optimization](optimization.md) -- [portability](portability.md) -- [procedural generation](procgen.md) -- [programming](programming.md) -- [programming language](programming_language.md) -- [suckless](suckless.md) -- [Unix philosophy](unix_philosophy.md) -- [web](www.md)
 - **math/theory**: [aliasing](aliasing.md) -- [chaos](chaos.md) -- [combinatorics](combinatorics.md) -- [fractal](fractal.md) -- [formal languages](formal_language.md) -- [information](information.md) -- [linear algebra](linear_algebra.md) -- [logic](logic.md) -- [math](math.md) -- [number](number.md) -- [pi](pi.md) -- [prime number](prime.md) -- [probability](probability.md) -- [Turing machine](turing_machine.md) -- [zero](zero.md)
 - **society**: [anarchism](anarchism.md) -- [anarcho pacifism](anpac.md) -- [capitalism](capitalism.md) -- [censorship](censorship.md) -- [collapse](collapse.md) -- [communism](communism.md) -- [democracy](democracy.md) -- [everyone does it](everyone_does_it.md) -- [fascism](fascism.md) -- [feminism](feminism.md) -- [fight culture](fight_culture.md) -- [history](history.md) -- [homosexuality](gay.md) -- [left vs right vs pseudoleft](left_right.md) -- [Jesus](jesus.md) -- [less retarded society](less_retarded_society.md) -- [LGBTQWTF](lgbt.md) -- [science](science.md) vs [soyence](soyence.md) -- [productivity cult](productivity_cult.md) -- [selflessness](selflessness.md) -- [socialism](socialism.md) -- [Venus project](venus_project.md) -- [work](work.md)

update_culture.md

@@ -20,4 +20,6 @@ Software updates are usually justified by "muh [security](security.md)" and "muh
 - **It is painful for the user** while at the same time being unnecessary, i.e. it's plainly artificial discomfort forced on users. The user has to keep caring about his software like some kind of [tamagotchi](tamagotchi.md), becoming a slave to it.
 - **It creates a mindset of not aiming to [finish](finished.md) anything** and [normalizes](normalization.md) this -- developers accept they release unfinished software, users accept they use unfinished software, society depends on technology that's not been finished, is buggy, unstable, randomly changing from one day to another etcetc. Update culture has a similar effect to the cancerous economic effect of [inflation](inflation.md) that prevents you from saving up money: it destroys anything that becomes static, not allowing to establish any stability.
 - **It is actually a huge security risk** (yes, we don't really buy intro security but this still holds). The developer, whoever it is, has the power to remotely push and execute any code at any time to the devices of many users. In fact this can be seen as the definition of [backdoor](backdoor.md). This is not just an issue of [proprietary](proprietary.md) software, there have been many [FOSS](foss.md) projects pushing [malware](malware.md) this way (look up e.g. the projects that targeted malware at Russians during the Russia-Ukraine war).
-- ...
+- ...
+
+Inb4 IPv7.

wiki_stats.md

@@ -2,10 +2,10 @@
 
 This is an autogenerated article holding stats about this wiki.
 
-- number of articles: 590
+- number of articles: 591
-- number of commits: 864
+- number of commits: 865
-- total size of all texts in bytes: 4234693
+- total size of all texts in bytes: 4249888
-- total number of lines of article texts: 32156
+- total number of lines of article texts: 32421
 - number of script lines: 262
 - occurences of the word "person": 7
 - occurences of the word "nigger": 91
@@ -35,60 +35,72 @@ longest articles:
 
 top 50 5+ letter words:
 
-- which (2395)
+- which (2399)
-- there (1838)
+- there (1841)
-- people (1633)
+- people (1634)
-- example (1415)
+- example (1419)
-- other (1307)
+- other (1309)
-- number (1216)
+- number (1224)
 - software (1144)
-- about (1139)
+- about (1142)
-- program (948)
+- program (962)
-- because (889)
+- because (890)
 - their (882)
 - would (880)
-- called (822)
+- called (823)
 - being (806)
-- language (798)
+- language (805)
-- something (796)
+- things (801)
-- things (795)
+- something (797)
-- numbers (792)
+- numbers (793)
-- simple (750)
+- simple (758)
 - computer (749)
 - without (713)
-- programming (704)
+- programming (705)
-- function (700)
+- function (701)
 - these (682)
 - different (666)
 - however (661)
-- system (630)
+- system (632)
-- world (619)
+- world (620)
 - doesn (610)
-- should (605)
+- should (604)
+- while (589)
 - point (586)
-- while (582)
 - games (578)
-- society (576)
+- society (577)
-- drummyfish (550)
+- simply (554)
-- simply (549)
+- drummyfish (553)
-- though (546)
+- though (547)
-- using (544)
+- using (545)
 - still (540)
 - possible (530)
+- memory (521)
 - similar (520)
-- memory (520)
 - https (510)
 - course (504)
-- value (498)
+- value (500)
 - technology (496)
 - always (485)
 - basically (480)
 - really (473)
-- first (462)
+- first (464)
 
 latest changes:
 
 ```
+Date:   Thu Aug 22 02:23:24 2024 +0200
+  algorithm.md
+  ashley_jones.md
+  backgammon.md
+  furry.md
+  logic.md
+  political_correctness.md
+  random_page.md
+  shogi.md
+  usa.md
+  wiki_pages.md
+  wiki_stats.md
 Date:   Wed Aug 21 17:34:42 2024 +0200
   algorithm.md
   ashley_jones.md
@@ -110,21 +122,6 @@ Date:   Mon Aug 19 21:04:41 2024 +0200
   exercises.md
   forth.md
   free_speech.md
-  john_carmack.md
-  less_retarded_society.md
-  lisp.md
-  lrs.md
-  lrs_dictionary.md
-  main.md
-  number.md
-  political_correctness.md
-  programming_language.md
-  random_page.md
-  recursion.md
-  reddit.md
-  vector.md
-  wiki_pages.md
-  wiki_stats.md
 ```
 
 most wanted pages:
@@ -162,28 +159,27 @@ most popular and lonely pages:
 - [proprietary](proprietary.md) (123) 
 - [computer](computer.md) (98) 
 - [kiss](kiss.md) (97) 
+- [minimalism](minimalism.md) (96) 
 - [modern](modern.md) (95) 
-- [minimalism](minimalism.md) (95) 
 - [linux](linux.md) (92) 
 - [gnu](gnu.md) (91) 
 - [programming](programming.md) (86) 
+- [fun](fun.md) (86) 
 - [censorship](censorship.md) (86) 
-- [fun](fun.md) (85) 
 - [free_culture](free_culture.md) (82) 
 - [fight_culture](fight_culture.md) (81) 
+- [math](math.md) (80) 
 - [less_retarded_society](less_retarded_society.md) (80) 
 - [hacking](hacking.md) (80) 
 - [bullshit](bullshit.md) (80) 
-- [math](math.md) (79) 
 - [art](art.md) (77) 
 - [shit](shit.md) (76) 
 - [public_domain](public_domain.md) (76) 
 - [programming_language](programming_language.md) (75) 
 - [foss](foss.md) (75) 
 - [corporation](corporation.md) (73) 
-- [chess](chess.md) (71) 
+- [chess](chess.md) (72) 
 - ...
-- [anal_bead](anal_bead.md) (5) 
 - [adam_smith](adam_smith.md) (5) 
 - [aaron_swartz](aaron_swartz.md) (5) 
 - [zuckerberg](zuckerberg.md) (4) 
@@ -213,4 +209,5 @@ most popular and lonely pages:
 - [cyber](cyber.md) (4) 
 - [crow_funding](crow_funding.md) (4) 
 - [random_page](random_page.md) (2) 
+- [macrofucker](macrofucker.md) (2)