Update

ancap.md

@@ -16,7 +16,9 @@ As if [capitalism](capitalism.md) wasn't extremely bad already, "anarcho" capita
 
 Firstly this means anything is allowed, any unethical, unfair business practice, including slavery, physical violence, blackmailing, rape, worst psychological torture, nuclear weapons, anything that makes you the winner in the jungle system. Except that this jungle is not like the old, self-regulating jungle in which you could only reach limited power, this jungle offers, through modern technology, potentially limitless power with instant worldwide communication and surveillance technology, with mass production, genetic engineering, AI and weapons capable of destroying the planet.
 
-Secondly the idea of getting rid of a state in capitalism doesn't even make sense because **if we get rid of the state, the strongest corporation will become the state**, only with the difference that state is at least *supposed* to work for the people while a corporation is only by its very definition supposed to care solely about its own endless profit on the detriment of people. Therefore if we scratch the state, McDonalds or Coca Cola or Micro$oft -- whoever is the strongest -- hires a literal army and physically destroys all its competition, then starts ruling the world and making its own laws -- laws that only serve the further growth of that corporation such as that everyone is forced to work 16 hour shifts every day until he falls dead. Don't like it? They kill your whole family, no problem. 100% of civilization will experience the worst kind of suffering, maybe except for the CEO of McDonald's, the world corporation, until the planet's environment is destroyed and everyone hopefully dies, as death is what we'll wish for.
+Secondly the idea of getting rid of a state in capitalism doesn't even make sense because **if we get rid of the state, the strongest corporation will become the state**, only with the difference that state is at least *supposed* to work for the people while a corporation is only by its very definition supposed to care solely about its own endless profit on the detriment of people. Therefore if we scratch the state, McDonalds or Coca Cola or [Micro$oft](microsoft.md) -- whoever is the strongest -- hires a literal [army](military.md) and physically destroys all its competition, then starts ruling the world and making its own laws -- laws that only serve the further growth of that corporation such as that everyone is forced to work 16 hour shifts every day until he falls dead. Don't like it? They kill your whole family, no problem. 100% of civilization will experience the worst kind of suffering, maybe except for the CEO of McDonald's, the world corporation, until the planet's environment is destroyed and everyone hopefully dies, as death is what we'll wish for.
+
+In addition to this the whole idea is also **[logically](logic.md) faulty** at the very basic level by assuming two contradictory premises at once: that people CANNOT behave morally and therefore need capitalism (money to ensure fairness, economic pressure etc.) to make them behave well, and that people CAN behave morally in the sense of purely voluntarily resisting "bad" things like establishing states. If an anarcho"capitalist" tries to educate people about harmfulness of state, believing he can turn people to change their behavior, he also has to accept it's possible to convince people in the same way that they can just behave well in general and won't need capitalism. There is no way out of this -- there are people, like [us](lrs.md), who believe that people can learn selfless moral behavior, and then there are people who don't believe it -- that's still fine as far as logic goes -- however "anarcho"capitalists try to believe both at once. That's just pure stupidity.
 
 A typical "anarcho"capitalist is a redneck who probably thinks the only thing preventing him from beating a corporation at its own game is state holding him back with high taxes -- he thinks that if he's allowed to keep all his crops he'll become a beast starting his own business that will go on beating Facebook, i.e. he thinks that if he can keep all five of all five carrots he grows on his field, he will somehow become so powerful he can bring down an army of ten thousand men with the most advanced technology who by the way can now also keep all money it makes, because he heard this in some fairy tale about Henry Ford or something. Of course that's highly laughable and pathetic, but indeed typically [American](usa.md).
 

attribution.md

@@ -3,7 +3,7 @@
 In the world of intellectual works (such as programs, texts, images etc.) attribution means visibly and properly acknowledging the work of collaborators, i.e. usually mentioning the names or pseudonyms of others that somehow took part in creation of the work. Sometimes we distinguish between merely giving *credit*, i.e. just recording collaborators somewhere, even in a less visible place such as some documentation file, and *proper attribution* which may have further conditions, e.g. mentioning the authors in a visible place (e.g. game's main menu) along with a link to their website and so on. Attribution is something that's often a condition of a [license](license.md), i.e. for example the [Creative Commons Attribution](cc_by.md) (CC BY) license grants everyone rights to the work as long as the original author is properly attributed. However we at [LRS](lrs.md) see such license requirements as [harmful](harmful.md); **forcing attribution with a [license](license.md) is a very bad idea!** Never do it. Please consider the following:
 
 - Forcing attribution may cause practical problems and make your work unusable. While it's no issue to give proper attribution to one guy who made music for your game, consider also a different scenario: e.g. in development of [LMMS](lmms.), a [FOSS](foss.md) music making program, the authors had to collect hundreds of short sound samples for their virtual instruments -- here they couldn't use CC BY-SA samples because doing so would require anyone who made music with their program to also carry on proper attribution of all the author of every single sample that was used in the music, which is practically almost impossible.
-- Forcing attribution can make you be force singed under things you don't want to be signed under. Consider you make a comics for children and license it CC BY-SA, i.e. require attribution. By free culture principles someone can take the characters from your story and make porn or terrorist supporting videos with them and even if those guys knew you wouldn't want to be signed under this (because you e.g. made it clear on your blog that you hate porn and terrorism) and even if they would be willing to not name you, your license will force them to write your name PROPERLY, i.e. visibly, under the thing they make.
+- Forcing attribution can make you be force signed under things you don't want to be signed under. Consider you make a comics for children and license it CC BY-SA, i.e. require attribution. By free culture principles someone can take the characters from your story and make porn or terrorist supporting videos with them and even if those guys knew you wouldn't want to be signed under this (because you e.g. made it clear on your blog that you hate porn and terrorism) and even if they would be willing to not name you, your license will force them to write your name PROPERLY, i.e. visibly, under the thing they make.
 - You're still playing the [copyright](copyright.md) game -- even if you relax copyright, you still acknowledge of the idea you keep some basic rights and have to [enforce](fight_culture.md) a "correct use" of your work. Even if the difference between CC0 and CC BY was practically of small importance, your mindset will likely be very different with each of them. There is a pattern of people who use CC0 being completely cool while the "CC BY-SA" people oftentimes changing their mind, trying to make trouble with "moral rights" and so on. Just don't do this.
 - It is just legal [bloat](bloat.md), it created [friction](friction.md), distract artists. It is unnecessary. Even if it's a small burden, it's still a burden for everyone -- the license has to be longer, it has to define what proper attribution means, what happens if it can't be technically achieved etc. You have to keep one more thing in your working memory, you have to observe if people respect this condition etc.
 - It discourages many from using your work. For some of the mentioned reasons many people actually avoid reusing works that require attribution { Including me and many other people I know.  ~drummyfish }. There exist dangers like attribution getting unintentionally lost in some copy paste by which you start violating the license, people are aware of this danger so they firstly look for works with no conditions at all, just to be safer. By releasing your work without requiring attribution you usually get "extra points" from the free culture community for saving other headaches and trouble.

bbs.md

@@ -8,7 +8,7 @@ Back then people connected to BBSes via dial-up [modems](modem.md) and connectin
 
 A BBS was usually focused on a certain topic such as technology, fantasy [roleplay](rolaplay.md), dating, [warez](warez.md) etc., they would typically greet the users with a custom themed [ANSI art](ansi_art.md) welcome page upon login -- it was pretty cool. BBSes were used to share [plain text](plain_text.md) files of all sorts, be it [shareware](shareware.md) versions of games, [anarchist](anarchism.md) writings, computer manuals, poetry or recipes. It really was a HUGE thing, you can dig up a lot of fun and obscure material by searching for BBS stuff -- http://textfiles.com is one place that gathers tons and tons of plain text files that were shared on these networks; searching and downloading files was just one favorite activity and obsession of BSS users (there is a very funny text "confession" of a chronic BBS downloader called `dljunkie.txt`, look that up, it's funny as hell).
 
-{ There's some documentary on BBS that's upposed to give you an insight into this shit, called literally *BBS: The documentary*. It's about 5 hours long tho. ~drummyfish }
+{ There's some documentary on BBS that's supposed to give you an insight into this shit, called literally *BBS: The documentary*. It's about 5 hours long tho. ~drummyfish }
 
 Considerable part of BBS community **frowned upon anonymity** (see e.g. http://textfiles.com/law/ethics.txt), a rule of some BBSes was that you had to use your real life info like name and address to communicate with others, some even advised against using handles. You met real, non-hiding humans back then, not some anonymous furry they/thems faggot who is scared to even tell you what continent he lives on. Of course, no one probably even considered any encrypted connection back then. This show that today's [privacy](privacy.md) hysteria is a [bullshit](bullshit.md), it's sad that today you'll see the exact opposite -- sites that PROHIBIT use of real life credentials. The world is fucked up now.
 

bilinear.md

@@ -2,6 +2,8 @@
 
 Bilinear interpolation (also bilinear filtering) is a simple way of creating a smooth transition ([interpolation](interpolation.md)) between [discrete](discrete.md) samples (values) in 2D, it is a [generalization](generalization.md) of [linear interpolation](lerp.md) to 2 dimensions. It is used in many places, popularly e.g. in 3D [computer graphics](graphics.md) for **[texture](texture.md) filtering**; bilinear interpolation allows to upscale textures to higher resolutions (i.e. compute new pixels between existing pixels) while keeping their look smooth and "non-blocky" (even though blurry). On the scale of quality vs simplicity it is kind of a middle way between a simpler [nearest neighbour](nearest_neighbour.md) interpolation (which creates the "blocky" look) and more complex [bicubic interpolation](bicubic.md) (which uses yet smoother curves but also requires more samples). Bilinear interpolation can further be generalized to [trilinear interpolation](trilinear.md) (in computer graphics trilinear interpolation is used to also additionally interpolate between different levels of a texture's [mipamap](mipamp.md)) and perhaps even bilinear [extrapolation](extrapolation.md). Many frameworks/libraries/engines have bilinear filtering built-in (e.g. `GL_LINEAR` in [OpenGL](ogl.md)). Of course this method may be used to smooth not just textures but anything, for example terrain [heightmaps](heightmap.md) or just any discrete mathematical function that we simply want to have defined everywhere, it's not just graphics thing, but here we will focus on its application in [graphics](graphics.md).
 
+Why is it named *bilinear*? Probably because it's doing linear interpolation twice: once in *X* direction, then in *Y* direction.
+
 ```
 ####OOOOVVVVaaaaxxxxssssffffllllcccc////!!!!;;;;,,,,....----    
 ####OOOOVVVVaaaaxxxxxssssffffllllcccc////!!!!;;;;,,,,.....----  

bootstrap.md

@@ -15,13 +15,19 @@ Bootstrapping has to start with some initial prerequisite machine dependent bina
 
 [Forth](forth.md) is a language that has traditionally been used for making bootstrapping environments -- its paradigm and philosophy is ideal for bootstrapping as it's based on the concept of building a computing environment practically from nothing just by defining new and new words using previously defined simpler words, fitting the definition of bootstrapping perfectly. [Dusk OS](duskos.md) is a project demonstrating this. Similarly simple language such as [Lisp](lisp.md) and [comun](comun.md) can work too (GNU Mes uses a combination of [Scheme](scheme.md) and C).
 
-**How to do this then?** To make a computing environment that can bootstrap itself you can do it like this:
+**How to do this then?** To make a computing environment that can bootstrap itself this approach is often used:
 
 1. **Make a [simple](kiss.md) [programming language](programming_language.md) L**. You can choose e.g. the mentioned [Forth](forth.md) but you can even make your own, just remember to keep it extremely simple -- simplicity of the base language is the key feature here. If you also need a more complex language, write it in L. The language L will serve as tool for writing software for your platform, i.e. it will provide some comfort in programming (so that you don't have to write in assembly) but mainly it will be an **[abstraction](abstraction.md) layer** for the programs, it will allow them to run on any hardware/platform. The language therefore has to be **[portable](portability.md)**; it should probably abstracts things like [endianness](byte_sex.md), native integer size, control structures etc., so as to work nicely on all [CPUs](cpu.md), but it also mustn't have too much abstraction (such as [OOP](oop.md)) otherwise it will quickly get complicated. The language can compile e.g. to some kind of very simple [bytecode](bytecode.md) that will be easy to translate to any [assembly](assembly.md). Make the bytecode very simple (and document it well) as its complexity will later on determine the complexity of the bootstrap binary seed. At first you'll have to temporarily implement L in some already existing language, e.g. [C](c.md). NOTE: in theory you could just make bytecode, without making L, and just write your software in that bytecode, but the bytecode has to focus on being simple to translate, i.e. it will probably have few opcodes for example, which will be in conflict with making it at least somewhat comfortable to program on your platform. However one can try to make some compromise and it will save the complexity of translating language to bytecode, so it can be considered ([uxn](uxn.md) seems to be doing this).
 2. **Write L in itself, i.e. [self host](self_hosting.md) it**. This means you'll use L to write a [compiler](compiler.md) of L that outputs L's bytecode. Once you do this, you have a completely independent language and can start using it instead of the original compiler of L written in another language. Now compile L with itself -- you'll get the bytecode of L compiler. At this point you can bootstrap L on any platform as long as you can execute the L bytecode on it -- this is why it was crucial to make L and its bytecode very simple. In theory it's enough to just interpret the bytecode but it's better to translate it to the platform's native machine code so that you get maximum efficiency (the nature of bytecode should make it so that it isn't really more diffiult to translate it than to interpret it). If for example you want to bootstrap on an [x86](x86.md) CPU, you'll have to write a program (L compiler [backend](backend.md)) that translates the bytecode to x86 assembly; if we suppose that at the time of bootstrapping you will only have this x86 computer, you will have to write the translator in x86 assembly manually. If your bytecode really is simple and well made, it shouldn't be hard though (you will mostly be replacing your bytecode opcodes with given platform's machine code opcodes). Once you have the x86 backend, you can completely bootstrap L's compiler on any x86 computer.
 3. **Further help make L bootstrapable**. This means making it even easier to execute the L bytecode on any given platform -- you may for example write backends (the bytecode translators) for common platforms like x86, ARM, RISC-V, C, Lisp and so on. You can also provide tests that will help check newly written backends for correctness. At this point you have L bootstrappable without any [work](work.md) on the platforms for which you provide backends and on others it will just take a tiny bit of work to write its own translator.
 4. **Write everything else in L**. This means writing the platform itself and software such as various tools and libraries. You can potentially even use L to write a higher level language (e.g. C) for yet more comfort in programming. Since everything here is written in L and L can be bootstrapped, everything here can be bootstrapped as well.
 
+However, a possibly even better way may be the [Forth](forth.md)-style **incremental programming** way, which works like this (see also [Macrofucker](macrofucker.md) and [portability](portability.md) for explanation of some of the concepts):
+
+1. **Start with a trivially simple language.** It must be one that's easy to implement from scratch on any computer without any extra tools -- something maybe just a little bit more sophisticated than [Brainfuck](brainfuck.md). This language may even be a machine specific [assembly](assembly.md), let's say [x86](x86.md), that's using just a small subset of the simplest instructions, as long as it's easy to replace these instructions with other instructions on another hardware architecture. There should basically only be as many commands to ensure [Turing Completeness](turing_complete.md) and good performance (i.e. while an increment instruction may be enough for Turing completeness, we should probably also include instruction performing general addition, because adding two numbers in a loop using just the increment instruction would be painfully slow). The goal here is of course to build the foundations for the rest of our platform -- one that's simple enough to be easily replaced.
+2. **Build a more complex language on top of it.** I.e. now use this simple language ALONE to build a more complex, practically usable language. Again, take inspiration in Forth -- you may for example introduce something like procedures, [macros](macro.md) or words to your simple language, which will allow you to keep adding new useful things such as arrays or more complex control structures. To add the system of macros for example just write a [preprocessor](preprocessor.md) in the base language that will take the new, macro-enabled language source code and convert it to the plain base language; with macros on your disposal now you can start expanding the language more and more just by writing new macros. I.e. expanding the base language should be done in small steps, incrementally -- that is don't build C out of Brainfuck right away; instead first build just a tiny bit more complex language on top of the initial language, then a bit more complex one on top of that etc. -- in Forth this happens by defining new words and expanding the language's dictionary.
+3. **Now build everything else with the complex language.** This is already straightforward (though time consuming). First you may even build more language extensions and development tools like a debugger of [text editor](text_editor.md) for example. The beauty of this approach is really that to allow yourself to program on the system you are building the system itself on-the-go, i.e. you are creating a development environment and also a user environment for yourself, AND everything you make is bootstrappable from the original simple language. This is a very elegant, natural way -- you are setting up a complex system, building a road which is subsequently easy to walk again from the start, i.e. bootstrap. This is probably how it should ideally be done.
+
 ## Booting: Computer Starting Up
 
 Booting as in "staring computer up" is also a kind of setting up a system from the ground up -- we take it for granted but remember it takes some [work](work.md) to get a computer from being powered off and having all RAM empty to having an operating system loaded, hardware checked and initialized, devices mounted etc.

brainfuck.md

@@ -94,8 +94,6 @@ int main(void)
 }
 ```
 
-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.
@@ -167,7 +165,9 @@ Read two 0-9 numbers (as ASCII digits) and add them:
 ,>,[<+>-]<------------------------------------------------.
 ```
 
-TODO: more
+## Variants
+
+TODO
 
 ## Making Brainfuck Usable: Defining Macrofucker
 
@@ -180,7 +180,7 @@ Hmmm okay, what name do we give the language? Let's call it **Macrofucker**. It
 - 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.
+- Inside a macro definition we may use the symbol `$` that will make the next character be repeated the macro's argument number of times -- i.e. if the macro was called with let's argument 3, then `$>` will output `>>>`. This symbol can also be used in the same sense in front of macro invocation.
 
 For example consider the following piece of code:
 
@@ -237,9 +237,8 @@ void process(const char *c, int topLevel)
   char f = *c;        // macro name to search
   unsigned int n = 0; // macro argument
 
-  if (!topLevel)
+  if (!topLevel)      // read the argument
   {
-    // read argument
     c++;
 
     while (*c >= '0' && *c <= '9')
@@ -249,13 +248,14 @@ void process(const char *c, int topLevel)
     }
   }
 
+#define IS_MACRO(x) ((x) >= 'A' && (x) <= 'Z')
   c = program;
 
-  while (*c) // search for the macro
+  while (*c)                     // search for the macro definition
   {
     if (topLevel || (c[0] == ':' && c[1] == f))
     {
-      c += topLevel ? 0 : 2; // skip the beginning macro chars
+      c += topLevel ? 0 : 2;     // skip the beginning macro chars
 
       while (*c && *c != ';')
       {
@@ -264,13 +264,13 @@ void process(const char *c, int topLevel)
         else if (*c == '+' || *c == '-' || *c == '<' || *c == '>' ||
           *c == '[' || *c == ']' || *c == '.' || *c == ',')
           putchar(*c);           // normal BF commands
-        else if (*c >= 'A' && *c <= 'Z')
+        else if (IS_MACRO(*c))
           process(c,0);          // macro
         else if (*c == '$')
         {
           c++;
           for (unsigned int i = 0; i < n; ++i)
-            putchar(*c);
+            IS_MACRO(*c) ? process(c,0) : putchar(*c);
         }
 
         c++;
@@ -286,19 +286,97 @@ void process(const char *c, int topLevel)
 int main(int argc, char **argv)
 {
   process(program,1);
-  putchar(0);  // allows separating program on stdin from program input
+  putchar(0);    // allows separating program on stdin from program input
-  // puts("013"); // program input may go here
+  //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
+So just for completeness, here is a Macrofucker program that prints out the first 10 [Fibonacci numbers](fibonacci_number.md):
 
-TODO
+```
+:Z[-];                                        zero the cell
+:L$<;                                         go left by n
+:R$>;                                         go right by n
+:XZ$+;                                        store constant n
+:N>Z+<[Z>-<]>[<$++>Z]<;                       not
+:CZ>Z<<$<[-$>>+>+<$<<]$>>>[-<$<<+>>$>]<;      copy
+:F>Z<[->+<]<$<[->$>+<$<]$>>>[-<<$<+>>$>]<;    flip
+:A>C1[-<+>]<;                                 add
+:S>C1[-<->]<;                                 subtract
+:GZ>C2>C2+<[->->CN[L3+R3Z]<<]<;               greater
+:B>C1>C1<<Z>>>GN[L3+>>S>GN]<F<;               divide
+:P>X100>C1BF>X48A.L3X10>BF>X48A.<F>X48A.L4;   print
+
+main program
+
+>X10   loop counter
+>X0    first number
+>X1    second number
+<<
+
+[-             loop
+  R3
+  C1 A         copy and add
+  P > X10 .    print number and newline
+  < F < F <<   go back and shift numbers
+]
+```
+
+which translates to:
+
+```
+>[-]++++++++++>[-]>[-]+<<[->>>[-]>[-]<<<[->>+>+<<<]>>>[-<<<
++>>>]<>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<+>]<>[-]++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++>[-]>[-]<<<[->>+>+<<<]>>
+>[-<<<+>>>]<>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<>[-]>[-]<<<
+[->>+>+<<<]>>>[-<<<+>>>]<<<[-]>>>[-]>[-]>[-]<<<<[->>>+>+<<<
+<]>>>>[-<<<<+>>>>]<>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>
+]<+<[->->[-]>[-]<<[->+>+<<]>>[-<<+>>]<>[-]+<[[-]>-<]>[<+>[-
+]]<[<<<+>>>[-]]<<]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]>[-]<
+<<[->>+>+<<<]>>>[-<<<+>>>]<[-<->]<>[-]>[-]>[-]<<<<[->>>+>+<
+<<<]>>>>[-<<<<+>>>>]<>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>
+>>]<+<[->->[-]>[-]<<[->+>+<<]>>[-<<+>>]<>[-]+<[[-]>-<]>[<+>
+[-]]<[<<<+>>>[-]]<<]<>[-]+<[[-]>-<]>[<+>[-]]<]<>[-]<[->+<]<
+[->+<]>>[-<<+>>]<<>[-]<[->+<]<[->+<]>>[-<<+>>]<>[-]++++++++
+++++++++++++++++++++++++++++++++++++++++>[-]>[-]<<<[->>+>+<
+<<]>>>[-<<<+>>>]<[-<+>]<.<<<[-]++++++++++>>[-]>[-]<<<[->>+>
++<<<]>>>[-<<<+>>>]<>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<<<[-
+]>>>[-]>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<>[-]>[-]<<
+<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<+<[->->[-]>[-]<<[->+>+<<]>>
+[-<<+>>]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]]<<]<>[-]+<[[-]
+>-<]>[<+>[-]]<[<<<+>>>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-
+<->]<>[-]>[-]>[-]<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<>[-]>[-]
+<<<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<+<[->->[-]>[-]<<[->+>+<<]
+>>[-<<+>>]<>[-]+<[[-]>-<]>[<+>[-]]<[<<<+>>>[-]]<<]<>[-]+<[[
+-]>-<]>[<+>[-]]<]<>[-]<[->+<]<[->+<]>>[-<<+>>]<<>[-]<[->+<]
+<[->+<]>>[-<<+>>]<>[-]+++++++++++++++++++++++++++++++++++++
++++++++++++>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<+>]<.<>[-
+]<[->+<]<[->+<]>>[-<<+>>]<>[-]+++++++++++++++++++++++++++++
++++++++++++++++++++>[-]>[-]<<<[->>+>+<<<]>>>[-<<<+>>>]<[-<+
+>]<.<<<<>[-]++++++++++.<>[-]<[->+<]<[->+<]>>[-<<+>>]<<>[-]<
+[->+<]<[->+<]>>[-<<+>>]<<<]
+```
+
+which outputs:
+
+```
+001
+001
+002
+003
+005
+008
+013
+021
+034
+055
+```
 
 ## See Also
 
 - [False](false.md) (a very similar esolang)
-- [comun](comun.md)
+- [comun](comun.md)

exercises.md

@@ -217,7 +217,8 @@ Bear in mind the main purpose of this quiz is for you to test your understanding
 110. A [troll](trolling.md) joins homosexual gayming stream and starts spamming Hitler quotes by which he increases the amount of lulz by X percent. However the gay starts crying so the stream censor quickly bans the poor troll, dropping the lulz to the original level. By how many percent have the lulz decreased now?
 111. What happens in [Forth](forth.md) when you try to define a word with the same name as another already existing word? Will the old word be deleted? Or is this forbidden to do? Also say why.
 112. What's the difference between [lazy](lazy.md) and strict evaluation? Show simple example.
-113. Did you enjoy this quiz?
+113. Write code in [Brainfuck](brainfuck.md) that copies the value in current cell to the cell on to the right, while KEEPING the value in current cell. Of course you may use another temporary cell to do this.
+114. Did you enjoy this quiz?
 
 ### Answers
 
@@ -334,7 +335,8 @@ sin(x) / cos(x) - log2(2) = tg(x) - 1*, so we get *tg(x) >= 1*. So that will hol
 110. If the original level of lulz is *a* and lulz increase is *n*, then *X = 100 * n / a*. The decrease is then *100 * n / (a + n) = 100 * (a * X / 100) / (a + a * X / 100) = X / (1 + X / 100) = 100 * X / (100 + X)*.
 111. It can be done (and it's useful), the new word will shadow the old one -- i.e. invoking the word will execute the latest word of that name -- but the old word will still exist in the dictionary, so that if the new word is deleted the old one becomes accessible again. This is because the dictionary is searched from the newest entries to the oldest (it's usually a linked list starting with the latest defined word).
 112. They're both strategies for evaluating [expressions](expression.md): lazy (also *by need*) evaluates an argument ONLY once it's actually needed, while strict evaluation evaluates all arguments, even if some might not be needed. Example: let's have a function `or3(a,b,c)` which performs logical OR of three values; under strict evaluation all *a*, *b* and *c* will be evaluated and then logical OR will be performed; under lazy evaluation the function may first evaluate one argument, let's say *a*, and if it ends up being TRUE, there is no need to further evaluate *b* and *c* (the result is already known to be TRUE), so they won't be evaluated.
-113. yes
+113. For example `[->+>+<<]>>[-<<+>>]<<`: first we copy the current cell into TWO cells to the right -- one of them is used as a temporary cell; after this we use another loop to copy the value from the temporary cell back to the original location that we zeroes during the first copying.
+114. yes
 
 ## Other
 

free_hardware.md

@@ -25,7 +25,7 @@ The following is a list of some "freedom friendly" hardware, i.e. hardware that
 - **[Ben NanoNote](ben_nanonote.md)**: tiny [GNU](gnu.md)/[Linux](linux.md) laptop whose design is free, however it utilizes e.g. a proprietary CPU.
 - **[DragonBox Pyra](pyra.md)**: Upcoming small handheld computer running [GNU](gnu.md)/[Linux](linux.md) that *almost* meets the RYF criteria, schematics will be available, GPU drivers are sadly proprietary. Successor to OpenPandora.
 - **[Librem 5](librem5.md)**: WARNING, this device has been criticized a lot. It's an "open"/privacy-friendly smartphone with free-licensed design running [GNU](gnu.md)/[Linux](linux.md), however it uses proprietary firmware (loaded from secondary CPU to sneakily comply with RYF) and the functionality is, according to reviews, horrible.
-- **[MNT Reform](mnt_reform.md)**: "Open hardware" (free-licensed design but using proprietary components) laptop with [NXP](nxp.md) [ARM](arm.md) CPU and [Vivante](vivante.md) GPU that can run with free drivers, has no camera or microphone. Pretty expensive.
+- **[MNT Reform](mnt_reform.md)**: "Open hardware" (free-licensed design but using proprietary components) laptop with [NXP](nxp.md) [ARM](arm.md) CPU and [Vivante](vivante.md) GPU that can run with free drivers, has no camera or microphone. Pretty expensive. It is possible to change the [SoC](soc.md).
 - **[Talos ES](talos_es.md)**: Very simple usable [CPU](cpu.md) that can be made at home.
 - **Old [Thinkpad](thinkpad.md) laptops**: Old thinkpads such as [X200](x200.md), [T400](t400.md) and [T500](t500.md) are construction-wise superior to maybe any other laptop ever made, however despite being proprietary they are compatible with [libreboot](libreboot.md) and can be purchased with [Intel ME](intel_me.md) CPU backdoor disabled, offering complete control over the device, plus they can be bought relatively cheap. Very popular, some even certified ["Respects Your Freedom"](ryf.md) by the [FSF](fsf.md).
 - **[OLinuXino](olinuxino.md)**: TODO

gay.md

@@ -22,6 +22,7 @@ Is homosexuality disgusting? Yes of course it's fucking disgusting.
 
 ## See Also
 
+- [gay bomb](gay_bomb.md)
 - [cocksucker](cocksucker.md)
 - [AIDS](aids.md)
 - [tranny](tranny.md)

gui.md

@@ -10,17 +10,20 @@ Expert computer users normally frown upon GUI because it is the "noobish", ineff
 
 ## When And How To Do GUI
 
-GUI is not forbidden, it has its place, but today it's way too overused -- it should be used only if completely necessary (e.g. in a painting program) or as a completely optional thing built upon a more [suckless](suckless.md) text interface or [API](api.md). So remember: first create a program and/or a [library](library.md) working without GUI and only then consider creating an optional GUI [frontend](frontend.md). GUI must never be tied to whatever functionality can be implemented without it.
+GUI is not forbidden, it has its place, but today it's way too overused -- it should be used sparingly, only if completely necessary (e.g. in a painting program) or as a completely optional thing built upon a more [suckless](suckless.md) text interface or [API](api.md). So remember: first create a program and/or a [library](library.md) working without GUI and only then consider creating an optional GUI [frontend](frontend.md). GUI must never cripple a program that can work without it. Say no to [frameworks](framework.md)! Absolutely **NEVER** let GUI dictate what languages, tools, file formats or [paradigms](paradigm.md) you should use -- if there is to be a GUI, it must be your absolute slave, not the master.
 
-Still, when making a GUI, you can make it [suckless](suckless.md) and lighthweight. Do your buttons need to have reflections, soft shadows and rounded anti-aliased borders? No. Do your windows need to be transparent with light-refraction simulation? No. Do you need to introduce many MB of dependencies and pain such as [QT](qt.md)? No.
+Still, when making a GUI, you can make it [suckless](suckless.md) and lighthweight. Do your buttons need to have reflections, soft shadows and rounded anti-aliased borders? No. Do your windows need to be transparent with light refraction simulation? No. Do you need to introduce many MB of dependencies and pain such as [QT](qt.md)? No.
 
-The ergonomics and aesthetic design of GUIs has its own field and can't be covered here, but just keep in mind some basic things:
+Also keep in mind this: **GUI doesn't have to have windows**. No, this doesn't mean you should have tiling windows instead of floating ones, this means you shouldn't have windows AT ALL. Graphical windows are a [bullshit](bullshit.md) pimp feature no one really needs. Your program can be just a full screen [DOS](dos.md)-style GUI, don't just blindly implement windows because they're everywhere. THINK, do not imitate because the established way is [cancer](cancer.md) -- your GUI doesn't have to run of 60 FPS, you probably don't need a [framebuffer](framebuffer.md), full RGB colors, clicking sounds, font rendering library (maybe you don't need text at all) etc. Use the fucking white matter you have in your skull, if there is any.
 
-- Don't have too many elements (buttons etc.) at the screen at once, it's confusing as hell and drives noobs away.
+The ergonomics and aesthetic design of GUIs has its own field and can't be covered here, but just bear in mind some basics:
-- Things must be intuitive, i.e. behave in a way that they normally do (e.g. main menu should be at the top of the window, not the bottom etc.).
-- Just use your brain. If a button is important and often used, it should probably be bigger than a button that's used almost never, etc.
 
-The million dollar question is: **which GUI framework to use?** Ideally none. GUI is just pixels, buttons are just rectangles; make your GUI simple enough so that you don't need any shitty abstraction such as widget hierarchies etc. If you absolutely need some framework, look for a suckless one; e.g. [nuklear](nuklear.md) is worth checking out. The suckless community sometimes uses pure [X11](x11.md), however that's not ideal, X11 itself is kind of bloated and it's also getting obsoleted by  [Wayland](wayland.md). The ideal solution is to make your GUI **backend agnostic**, i.e. create your own very thin abstraction layer above the backend (e.g. X11) so that any other backend can be plugged in if needed just by rewriting a few simple functions of your abstraction layer (see how e.g. [Anarch](anarch.md) does rendering).
+- Don't have too many elements (buttons etc.) at the screen at once, it's confusing as hell and drives noobs away. On the other hand too many submenus can be confusing as hell -- find a way to minimize the number of buttons and if there's still too many, group them let's say under 3 general tabs and that's it.
+- Things must be "intuitive", i.e. behave in a way that they normally do and what the user will probably expect: e.g. main menu should be at the top of the window, not bottom right, rarely used buttons should be small and not take too much space, "destroy everything" button shouldn't be right next to "save" button, "go left" button should be placed on left, "go right" on right etc.
+- Just use your brain.
+- ...
+
+The million dollar question is: **which GUI framework to use?** Ideally none. GUI is just [pixels](pixel.md), buttons are just rectangles; make your GUI simple enough so that you don't need any shitty abstraction such as widget hierarchies etc. If you absolutely need some framework, look for a suckless one; e.g. [nuklear](nuklear.md) is worth checking out. The suckless community sometimes uses pure [X11](x11.md), however that's not ideal, X11 itself is kind of bloated and it's also getting obsoleted by [Wayland](wayland.md) which is also shitty. The ideal solution is to make your GUI **[backend agnostic](portability.md)**, i.e. create your own very thin abstraction layer above the GUI system (e.g. X11) so that any other system can be plugged in if needed just by rewriting a few simple functions of your abstraction layer (see how e.g. [Anarch](anarch.md) does rendering).
 
 ## State Of Mainstream GUI
 

jokes.md

@@ -32,7 +32,7 @@ Also remember the worst thing you can do to a joke is put a [disclaimer](disclai
 - 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.
+- Political activists walk into a bar. [Pseudoleftist](pseudoleft.md) 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 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.
@@ -53,7 +53,7 @@ Also remember the worst thing you can do to a joke is put a [disclaimer](disclai
 - One of the great milestones yet left to be achieved by science is to find intelligent life in our Solar System.
 - An evil capitalist, good capitalist and [female](woman.md) genius walk in the park. A bee stings one of them. Who did it sting? The evil capitalists, the other two don't exist.
 - Cool statistics: 9 out of 10 people enjoy a gang [rape](rape.md).
-- Basement hackers never die, they just smell that way. Musicians never die, they just decompose (and musicians working part time are [semiconductors](semicoductor.md)).
+- Basement hackers never die, they just smell that way. Musicians never die, they just decompose (and musicians working part time are [semiconductors](semiconductor.md)).
 - `int randomInt(void) { int x; return x; }`
 - Boss: "We're going to need to store additional information about gender of all 1600 people in our database." Me: "OK that's only 200 extra bytes.". Diversity department: "You're fired."
 - the [downto](downto.md) operator
@@ -74,9 +74,8 @@ Also remember the worst thing you can do to a joke is put a [disclaimer](disclai
 - How do you accelerate a [Windows](windows.md) PC? By dropping it out of the window. (Hence the name?)
 - Shakespeare for programmers: `0x2b || !0x2b`. { This one is a bit lame but at least it's not so common :D ~drummyfish }
 - An [Apple](apple.md) a day keeps [sanity](lrs.md) away.
-- The goal of [computer science](compsci.md) is to create things that will last at
+- The goal of [computer science](compsci.md) is to create things that will last at least until we're finished building them.
 - Vision is what capitalist claims to have had after making a correct guess.
-least until we're finished building them.
 - How many lesbians do you need to screw a lightbulb? Eleven: one to screw it and ten to talk about how great it was doing it without a man.
 - Look at that obese singer typing something on her laptop. I think it's a Dell.
 - A fine is tax for doing bad, a tax is fine for doing good.

logic.md

@@ -1,11 +1,15 @@
 # Logic
 
-Logic (from Greek *logos* -- *reason*) is the study of how to make rational reasoning.
+Logic (from Greek *logos* -- thought/reason/word) is the study of rational reasoning. Logic as such is a term very general -- there is common sense logic, philosophical logic, formal and [mathematical](math.md) logic, deductive and inductive logic, logic in [circuits](logic_circuit.md), [programming](programming.md), [fuzzy](fuzzy.md) logic and many other kinds of logic. Logic is closely intertwined with [mathematics](math.md) because mathematics is built on top of logic and adopts many of its tools and concepts, for example axiomatic systems, and in turn mathematicians help further develop deeper knowledge about logic with tools they obtained. As always, here we will focus mainly on logic from programmer's point of view.
 
-TODO: moar stuff here, relationship of logic and math, which comes first etc.
+TODO: moar stuff here, different orders of logic etc.
+
+Formal logic is also usable as one of many **programming [paradigms](paradigm.md)** -- a typical example of logic programming language is [Prolog](prolog.md).
 
 **Power of logic is limited** (for more please read this excellent resource: http://humanknowledge.net/Thoughts.html) -- though logic is the strongest, most stable platform our knowledge can ever stand on, it is still not infinitely powerful and has its limits, despite what any reddit [atheist](atheism.md) tells you or even what he believes. This sadly [dooms](doom.md) us to certain eternal inability to uncover all there is, we just have to accept from a certain point we are blind and not even logic will help us. [Kurt Godel](godel.md) (along with others, e.g. Tarski) mathematically proved with his [incompleteness theorems](incompleteness.md) that we simply won't be able to prove everything, not even the validity of formal tools we use to prove things. See also [knowability](knowability.md). Even in just intuitive terms: on the lowest level we start using logic to talk about itself, i.e. if we e.g. try to prove that "logic works" using logical arguments, we cannot ever succeed, because if we succeed, the proven fact that "logic works" relies on the fact that logic indeed works; if it perhaps doesn't work and we used it to prove its own validity, we might have simply gotten a wrong result (it's just as if we trust someone saying "I am not a liar", he may as well be lying about not being a liar). By this logic even the previous sentence may or may not actually be true, we simply don't know, sometimes the best we can do is simply hold on to stronger or weaker beliefs. Imagine we have a function *isTrue(x)* that automatically checks if statement *x* is true (returns *true* or *false*), now image we have statement *y* that says *isTrue(y) = false*; our *isTrue* function will fail to correctly evaluate statement *y* (it can't return neither *true* nor *false*, both will lead to contradiction) -- this is a proof that there can never be a computable function that decides whether something is true or not. Logic furthermore cannot talk about many things; it can tell us how the world works but e.g. not WHY it works like it does. Checkmate [atheists](atheist.md).
 
+Are laws of logic inherent to every kind of existence, constant and unchanging under all possible conditions or are they specific to our [Universe](universe.md) and something we simply learn empirically? I.e. it seems logical that for example if *A* implies *B* and *A* holds, *B* will hold too -- but does it always have to be so or is it just so around our specific spacetime coordinates and we simply LEARN this rule, accepting it as a general interdimensional law? It seems logical that putting two individual [rocks](rock.md) together forms a single pair of rocks, but maybe in another universe putting two rocks together forms three rocks -- would beings in this universe have different laws of logic and different mathematics? This is probably a great philosophical question we can't satisfyingly answer here, but quite likely it may be the case that such questions [cannot be answered](knowability.md) at all.
+
 ## See Also
 
 - [math](math.md)

magic.md

@@ -1,3 +1,7 @@
 # Magic
 
-Magic stands for unknown mechanisms. Once mechanisms of magic are revealed and understood, it becomes [science](science.md).
+Magic stands for unknown mechanisms. Once mechanisms of magic are revealed and understood, it becomes [science](science.md).
+
+## See Also
+
+- [Harry Potter](harry_potter.md)

often_confused.md

@@ -78,6 +78,7 @@ There are many terms that are very similar and can many times be used interchang
 - **[forwarding](forwarding.md)** vs **[routing](routing.md)** vs **[switching](switching.md)**
 - **[framework](framework.md)** vs **[library](library.md)**
 - **[free software](free_software.md)** vs **[open source](open_source.md)** vs **[public domain](public_domain.md)** vs **[source available](source_available.md)** vs **[freeware](freeware.md)**
+- **[gay](gay.md)** vs **[LGBT](lgbt.md)**
 - **[geek](geek.md)** vs **[nerd](nerd.md)**
 - **[GNU](gnu.md)/Linux** vs **[Linux](linux.md)**
 - **[goniometry](goniometry.md)** vs **[trigonometry](trigonometry.md)**

paradigm.md

@@ -1,21 +1,21 @@
 # Paradigm
 
-Paradigm (from Greek *paradeigma*, "pattern", "example") of a [programming language](programming_language.md) means the very basic concepts that are used as a basis for performing computation in that language. Among popular paradigms are e.g. the [imperative](imperative.md), [object oriented](oop.md) and [functional](functional.md), but there are many more; we may see every paradigm as a set of basic ideas and mathematical models (e.g. [models of computation](model_of_computation.md)) that form the foundation of how the language works; these are typically additionally also accompanied by kind of "philosophy"/mindset/recommendations that will likely be used by the programmer who uses the language. Just to be clear, paradigm does NOT encompass other than purely technical aspects of performing computation (i.e. it does NOT include e.g. political, artistic or other ideas such as "eco-friendly language", "joke language" etc.). Just as e.g. music genres, paradigms are greatly fuzzy, have different definitions, flavors and are often combined; sometimes it's unclear how to classify paradigms (if one strictly falls under another etc.) or even if something is or isn't a paradigm.
+By [programming language](programming_language.md)'s paradigm (from Greek *paradeigma*, "pattern", "example") we mean the very basic concepts used as a basis for performing computation in that language. Among the most popular paradigms we'll find for example the [imperative](imperative.md), [object oriented](oop.md) and [functional](functional.md), but there exist many others; we may view every paradigm as a set of basic ideas, principles and [mathematical](math.md) models (e.g. [models of computation](model_of_computation.md), [data types](data_type.md), forms of [expressions](expression.md) etc.) that form the foundation of how the whole language works; these foundations are subsequently also accompanied by a kind of "programming philosophy" (we'll oftentimes hear sentences such as "[everything is](everything_is.md) X" where *X* may be *number*, *object*, *array*, *list* etc.), a naturally emerging "mindset", a set of recommendations the programmer should follow when using the language. But let it be set straight that paradigm will NOT include other than purely technical, engineering aspects of computation, i.e. artistic or political ideas (such as "eco-friendlieness", "anti-fascism", ...) are indeed not part of programming paradigm. Nevertheless, although of technical nature, aspects of paradigms are subjective, for example the question of drawing borders between them -- just like [music](music.md) genres or human [races](race.md), paradigms are [fuzzy](fuzzy.md) concepts, they have different definitions in different books, come in different flavors and are often combined; sometimes it's unclear how to classify paradigms (if one strictly falls under another etc.) or even if something is or isn't a paradigm at all.
 
 For example the [functional](functional.md) paradigm is built on top of [lambda calculus](lambda_calculus.md) (one of many possible mathematical systems that can be used to perform general calculations) which performs calculations by combining pure mathematical [functions](function.md) -- this then shapes the language so that a programmer will mostly be writing mathematical functions in it, AND this also usually comes with the natural "philosophy" of subsequently viewing everything as a function, even such things as loops or [numbers](number.md) themselves. In contrast [object oriented](oop.md) (OOP) paradigm tries to solve problems by constructing a network of intercommunicating "objects" and so in OOP we tend to see most things as objects.
 
-**Most common** practically used paradigm is the [imperative](imperative.md), one based on the simple concept of issuing "commands" to a [computer](computer.md) -- though it is nowadays almost always combined with some other [bullshit](bullshit.md) paradigm, most notably [object orientation](oop.md). Prevalence of imperative paradigm is probably caused by several factors, most importantly its simplicity (it's possibly the closest to human thinking, easiest to learn, predict etc.), efficiency thanks to being closest to how computers actually work (compilers have very small overhead in translation, they perform less "[magic](magic.md)"), historically established status (which is related to simplicity; imperative was the first natural approach to programming) etc.
+**Most common** practically used paradigm is the **[imperative](imperative.md)**, one based on the plain and simple concept of issuing "commands" to the [computer](computer.md) -- even though nowadays it almost always gets combined with some other [bullshit](bullshit.md) paradigm, most infamously [object orientation](oop.md). Prevalence of imperative paradigm is probably due to more than one factor, most important of which is most likely its simplicity (it's possibly the closest to human thinking, easiest to learn, predict etc.), efficiency thanks to being closest to how computers actually work (compilers have very small overhead in translation, they perform less "[magic](magic.md)"), [historically](history.md) established status (which is related to simplicity; imperative was the first natural approach to programming) etc. Even more abstract paradigms are ultimately built on top of imperative system, so imperative is just present everywhere.
 
 **List of notable paradigms** follows (keep in mind the subjectivity and fuzziness that affect classification):
 
 - **[imperative](imperative.md)**: Programmer issues commands, the computer blindly executes them ("impero" = "to command"). The focus is on the process of computation. This is the most common paradigm.
   - **[procedural](procedural.md)**: Programmer writes procedures -- smaller subprograms that together solve the whole problem at hand. This is an extremely common paradigm; procedures are also often called *[functions](function.md)*, but they mustn't be confused with PURE mathematical functions used in functional paradigm. Examples: [Pascal](pascal.md), [C](c.md), [Fortran](fortran.md), ...
-  - **[stack](stack.md)-based**: Computation happens on stack (or multiple stacks), a [data structure](data_structure.md) very convenient for this purpose. These languages often naturally use prefix or postfix notation, it is easy to implement parameter passing and returning values, many computations are elegant. This is a popular paradigm for [minimalist](minimalism.md) languages. Examples: [Forth](forth.md), [comun](comun.md).
+  - **[stack](stack.md)-based**: Computation happens on stack (or multiple stacks), a [data structure](data_structure.md) very convenient for this purpose. These languages often naturally use prefix or postfix notation, it is easy to implement parameter passing and returning values, many computations are elegant. This is a popular paradigm for [minimalist](minimalism.md) languages. Examples: [Forth](forth.md), [comun](comun.md), ...
   - **[event](event.md)-driven**: Programmer defines reactions to certain external events rather than a single run of a program. This is very often used in [GUI](gui.md) programming (with events such as "button clicked", "window resized" etd.). Example: [Javascript](javascript.md).
   - **[array](array.md)-based**: Operations mostly work on [arrays](array.md) as opposed to working on single values (scalars).
   - ...
 - **[declarative](declarative.md)**: Programmer defines ("declares") what the result should look like, the program finds something that fits the definition. The focus is on the result, not the process to obtain it.
-  - **[functional](functional.md)**: Programmer describes solution to a problem as composition of pure mathematical functions (which are not to be confused with more loosely defined "functions" present in many languages). Here everything, even branching and loops, are implemented as strictly mathematical functions that have no [side effects](side_effect.md). Formally this paradigm is based on [lambda calculus](lambda_calculus.md). Example: [Haskell](haskell.md).
+  - **[functional](functional.md)**: Programmer describes solution to a problem as composition of pure mathematical functions (which are not to be confused with more loosely defined "functions" present in many languages). Here everything, even branching and loops, are implemented as strictly mathematical functions that have no [side effects](side_effect.md). Formally this paradigm is based on [lambda calculus](lambda_calculus.md). Examples: [Haskell](haskell.md), [Lisp](lisp.md), ...
   - **[logic](logic.md)**: Programmer describes solution using formal [logic](logic.md). Example: [Prolog](prolog.md).
   - ...
 - **[object oriented](oop.md)** (OOP): Programmer defines objects (greatly independent, small encapsulated abstract entities) that communicate with each other to solve given problem. Most generally the paradigm is only about "decomposing problems to objects" and so may be implemented as both imperative and declarative, though nowadays OOP is heavily combined with imperative programming and so is often seen as imperative. Examples: [Smalltalk](smalltalk.md), [Java](java.md), [C++](cpp.md), ...

pedophilia.md

@@ -24,6 +24,8 @@ It is hilarious that people nowadays laugh at the old timey propaganda -- absolu
 
 Part of the strategy of fueling the hysteria is **strictly separating people into two groups: pedophiles and non-pedophiles** -- "evil" and "good", "us" and "them" -- to which strict age of consent and labels such as "disorder" are great helpers. While with topics such as [autism](autism.md), sexes, genders and approved sexual orientations the pseudoleft pushes the idea of a "spectrum" and "fluidity", i.e. people not simply being one or another but having individual mixes of certain attributes (which is likely correct but many times taken to misleading extremes), with pedophilia they refuse to acknowledge the same, i.e. that some people may be attracted to mature people and other people are attracted to younger people and other ones to very young people or simply all people, and that some people are attracted to younger people a lot and others just mildly, and that some people become interested in sex at 18 years of age while other ones at 15, 11 or even younger. Nature is like this, no one can in his right mind believe that biology will obey human laws and separate humans into two distinct, clearly separated groups. [Law](law.md) obsessed society has once again managed to replace sense of [morality](morality.md) with harmful oversimplifications that allow to label everyone either guilty or not guilty -- 95 year old dating 18 year old? That's fine, in fact we may call them [heroes](hero.md) for "[fighting](fight_culture.md)" stereotypes about sexuality! 18 year old dating 17 year old? Disgusting! Mental disease, highly dangerous predator! Best to castrate the monster, lock him up, lynch him, burn him like a witch, quick death would be too good for him.
 
+{ This fanaticism is destroying society -- from a real life acquaintance I've heard their family was split after a young granddaughter, after having learned about "sexual assault" and "rape" at school, accused her grandfather of said crime when he basically just gently touched her and stroke her hair. Of course, the child doesn't even know what it's talking about. So now grandparents can't touch their grandchildren. ~drummyfish }
+
 **Can a child consent?** Rather ask if you have good enough reason to prevent it from what it wants to do and what is natural for its healthy development. Can a child consent for going out of house? What if someone abducts it there? What if a car runs it over? Better lock it at home until it's 18 and it's no longer on you if it dies, right? Doesn't matter it will grow up to be a pale unsocialized monster with depression who never saw sunlight, only if it's physically safe and you are legally safe. People nowadays have more trouble with sex than ever before, they don't know what gender they are, they have trouble dating, stay virgins, don't have kids, commit suicides. This wasn't the case in times when this supposed "law protection" didn't exist, how can that be? It's because this "protection" is actually a curse, it makes big deal out of sex, purposefully establishes a [stigma](stigmatization.md) and prevents natural development at everyone's pace. It labels people monsters for being attracted to the wrong age group, it labels them marked for life for having been touched by someone from a different age group, it label art a work of Satan if it shows a natural human body. It prohibits the depiction of young face because someone might find it pretty. This you think is a good society? Think again then.
 
 The idea of needing consent itself is also not the best one -- yes, non-consensual sex is considered [rape](rape.md), but that's only by [shortcut thinking](shortcut_thinking.md). Everyone nowadays seems to accept without questioning that sexual behavior without consent must be prevented at all cost, but does it have to be so? It is given (at least by [our](lrs.md) standards) that physical harm to anyone is always bad -- there is no question about that -- but not all non-consensual sexual behavior ("rape") causes physical harm, most harm of what's today called "rape" is probably psychological, which stems from cultural stigmatization. If a guy squeezes a girl's breast without consent, he doesn't physically hurt her in any way, the girl is completely fine, it's just that society will tell her she was "raped" by this and should now start suffering from PTSD, she's labeled a "victim", assigned a psychiatrist, will be pumped with drugs and told she has an increased chance of committing suicide now. In a [good society](less_retarded_society.md) this would simply not be the case, mild non-consensual sexual behavior such as touching, spying, masturbation etc. might be at worst as much harmful as for example non-consensual small talk or farting in someone's presence without his approval. Again, physically harming someone is WRONG, but do we have to equate such an extreme form of rape with slapping a girl's ass? By doing so we are probably hurting the "victims" more than the "offenders". But again, this helps separate people into two groups: "raped" and "not raped", "victims" and "predators" and so on.

tranny_software.md

@@ -1,6 +1,8 @@
 # Tranny Software
 
-Tranny software is a harmful [software](software.md) developed within and infected by the culture of the toxic [LGBTFJJJGIIQWWQW](lgbt.md) [SJW](sjw.md) [pseudoleftists](pseudoleft.md), greatly characterized e.g. by [codes of conduct](coc.md), bad engineering and excluding straight white males from the development in the name of "inclusivity". Such software is retarded. It is practically always a high level of [bloat](bloat.md) with features such as [censorship](censorship.md), bugs and [spyware](spyware.md).
+*Maybe you are looking for: [transsexual](tranny.md).*
+
+Tranny software is a [harmful](harmful.md) [software](software.md) developed within and infected by the culture of the toxic [LGBTFJJJGIIQWWQW](lgbt.md) [SJW](sjw.md) [pseudoleftists](pseudoleft.md), greatly characterized e.g. by [codes of conduct](coc.md), bad engineering and excluding straight white males from the development in the name of "inclusivity". Such software is retarded. It is practically always a high level of [bloat](bloat.md) with features such as [censorship](censorship.md), bugs and [spyware](spyware.md).
 
 To be clear, *tranny software* does NOT stand for *software written by transsexuals*, it stands for a specific kind of software infected by [fascism](fascism.md) (in its features, development practices, culture, goals etc.) which revolves around things such as sexual identity. Of course with good technology it doesn't matter by whom it is made. For god's sake do NOT bully individuals for being transsexual! Refuse bad software.
 

wiki_stats.md

@@ -3,9 +3,9 @@
 This is an autogenerated article holding stats about this wiki.
 
 - number of articles: 591
-- number of commits: 865
+- number of commits: 866
-- total size of all texts in bytes: 4249888
+- total size of all texts in bytes: 4249989
-- total number of lines of article texts: 32421
+- total number of lines of article texts: 32424
 - number of script lines: 262
 - occurences of the word "person": 7
 - occurences of the word "nigger": 91
@@ -89,6 +89,19 @@ top 50 5+ letter words:
 latest changes:
 
 ```
+Date:   Thu Aug 22 22:58:37 2024 +0200
+  3d_rendering.md
+  algorithm.md
+  assembly.md
+  brainfuck.md
+  fight_culture.md
+  jokes.md
+  macrofucker.md
+  main.md
+  random_page.md
+  update_culture.md
+  wiki_pages.md
+  wiki_stats.md
 Date:   Thu Aug 22 02:23:24 2024 +0200
   algorithm.md
   ashley_jones.md
@@ -109,19 +122,6 @@ Date:   Wed Aug 21 17:34:42 2024 +0200
   lisp.md
   minimalism.md
   number.md
-  political_correctness.md
-  programming_language.md
-  random_page.md
-  wiki_pages.md
-  wiki_stats.md
-  woman.md
-Date:   Mon Aug 19 21:04:41 2024 +0200
-  bilinear.md
-  dramatica.md
-  dynamic_programming.md
-  exercises.md
-  forth.md
-  free_speech.md
 ```
 
 most wanted pages:
@@ -180,6 +180,7 @@ most popular and lonely pages:
 - [corporation](corporation.md) (73) 
 - [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) 
@@ -209,5 +210,4 @@ 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)