Update

bilinear.md

@@ -115,4 +115,8 @@ The program outputs:
 
 **Cool [hack](hacking.md) to improve bilinear interpolation** (from https://iquilezles.org/articles/texture): bilinear interpolation doesn't looks as good as bicubic but bicubic is a lot more complex on hardware and bandwidth as it requires fetching more texels -- there is one trick which [shader](shader.md) programmers use to improve the look of bilinear filtering while not requiring fetching more texels. They use the `smoothstep` function on the interpolation parameter which eliminates instant "jumps" at edges between texels, it replaces straight lines with a smoother curve and so makes the [derivative](derivative.md) of the result continuous -- basically it looks a lot better. Still not as good as bicubic but close enough.
 
-TODO: code for the above
+TODO: code for the above
+
+For [suckless](suckless.md) programs that do their own [software rendering](software_rendering.md) an issue of bilinear interpolation, as compared with nearest neighbor, might be that it **creates new colors** by averaging colors in the filtered image, i.e. image filtered this way may have new colors introduced and this may become a problem e.g. if we are using [palettes](palette.md) (indexed mode) with limited number of colors and possible operations with them. This may also complicated e.g. using precomputed scaling tables (used in old games like [wolf 3D](wolf3d.md)) that simply store mapping of the original image to pixels in an upscaled image. A possible attempt at a "fix" -- or rather more of a poor man's bilinear interpolation -- may be in [dithering](dithering.md) the colors rather than averaging; perhaps once we sample in between pixels we assign probabilities to the 4 nearest pixels, based on their distance to the sample position, and then take one of the four pixels at random with those probabilities using some [pseudorandom](pseudorandom.md) generator.
+
+TODO: test the above

dramatica.md

@@ -8,9 +8,9 @@ The encyclopedia's motto is  simply "in lulz we trust". Currently it has over 15
 
 Dramatica is notorious for switching domains extremely quickly, as of writing this it is at **[http://encyclopediadramatica.gay](http://encyclopediadramatica.gay)**. If it seems to be down for several days, search the Internet for the new link, you'll usually find it on their Deviant Art page or somewhere.
 
-Examples of what you will find on ED include a highscore table of mass shooters, summary of important event of each year, tips on how to vandalize [Wikipedia](wikipedia.md), detailed article on every [lolcow](lolcow.md), a lengthy article about [niggers](nigger.md), [women](woman.md), video games, countries, music bands, [Hitler](hitler.md), Pokemon, daily featured pictures, documentation of [4chan](4chan.md) raids and other wonderful acts of [trolling](trolling.md) and much more.
+Examples of what you will find on ED include a highscore table of mass shooters, summary of important event of each year, tips on how to vandalize [Wikipedia](wikipedia.md), detailed article on every [lolcow](lolcow.md), a lengthy article about [niggers](nigger.md), [women](woman.md), video games, countries, music bands, [Hitler](hitler.md), Pokemon, daily featured pictures, documentation of [4chan](4chan.md) raids and other wonderful acts of [trolling](trolling.md) and much more. Every article about a fictional work starts with all the important spoilers in bold uppercase.
 
-The encyclopedia used to be written under [CC0](cc0.md), which is of course amazing, but they seem to just be switching licenses however they like -- maybe to support a bit of a drama anyway -- however even with CC0 much of the content simply by nature comprises of copy pastes, screencaps, anonymous works and fair uses (sometimes perhaps also illegal unfair uses), so in general you can't really treat it as a "tidy" [public domain](public_domain.md), more like a chaotic "we shit on any [copyright](copyright.md)" philosophy, which given the situation (impossibility of achieving true PD) is probably the least evil. As of writing this it also doesn't sport any [shit](shit.md) like [ads](marketing.md) (though there were ads in the past, but they managed to get rid of them) or Turing test bullshit and it also only works on plain HTTP (no HTTPS nonsense, even though there are logins and passwords lol), which is simply amazing and shows a high standard of this magnum opus, but of course everything may change at any time so better not speak too early. ED also has pretty nice forums.
+The encyclopedia used to be published under [CC0](cc0.md), which is of course amazing, but they seem to just be switching licenses however they like -- maybe to support a bit of a drama anyway -- however even with CC0 much of the content simply by nature comprises of copy pastes, screencaps, anonymous works and fair uses (sometimes perhaps also illegal unfair uses), so in general you can't really treat it as a "tidy" [public domain](public_domain.md), more like a chaotic "we shit on any [copyright](copyright.md)" philosophy, which given the situation (impossibility of achieving true PD) is probably the least evil. As of writing this it also doesn't sport any [shit](shit.md) like [ads](marketing.md) (though there were ads in the past, but they managed to get rid of them) or Turing test bullshit and it also only works on plain HTTP (no HTTPS nonsense, even though there are logins and passwords lol), which is simply amazing and shows a high standard of this magnum opus, but of course everything may change at any time so better not speak too early. ED also has pretty nice forums.
 
 Dramatica has firmly stood towering as the giant among the people's encyclopedias since its establishment on December 9 2004, it can only be compared to such places like [4chan](4chan.md). It was established by a [WOMAN](woman.md) who got piseed at Wikipedia, who was called called Girlvinyl (Sherrod DeGrippo), which would make her one of the few based women wasn't it for her betrayal of the project in 2011 when she caused a **major drama** by trying to milk the project and replaced ED by some shitty normie friendly website (called "Oh Internet") that soon went bankrupt, by which she confirmed she indeed was just a woman unable to control her lust for golds (and even failing at digging it after going all in lol). Fans however kept ED backed up and going under different domains. ED is mainly a work of [oldfags](oldfag.md), a place of classic, old style, porn-rich [meme](meme.md) culture, nowadays in contrast with the lame zoomer shit like soyjaks and whatnot. The articles are visually rich, joyful, with many flashing colors, flying [CSS](css.md) pictures and many catchy quotes and phrases with a lot of exclamation marks!!11!1! The editors call themselves EDiots. The work achieved a legendary status despite facing the hardest forms of censorship, for example being excluded from [Goolag](google.md) search results; Wikipedia also tried to ban and censor the whole article about Dramatica but eventually had to give in because ED actually became very notable and referenced in mainstream media. This couldn't go without inspiring similar projects, so ED has since its inception been competing with other similar encyclopedias, however it might be better to say it's simply been copied and mimicked without anyone so far reaching the high quality. Some competing wikis are for example the Lurkmore wikis (English, Russian and Ukrainian ones), Nigrapedia or the Soyjak wiki -- nevertheless these hardly ever managed to get on the same level. The "competition" usually does have some valuable material but overall generally fails by several points, like for example being quite small, having low effort articles consisting of unfunny spam, forced self serving vulgarity without any artistic vision (Family Guy style), having too many rules, putting on ads (revealing its motives for just grabbing some internet cash), putting on [cuckflare](cloudflare.md) and basically just not valuing the work enough, not keeping the standard that ED seems to be valuing and tryharding too much to dethrone Dramatica. Dramatica simply knows what it wants to do and does it to the fullest, it puts no barriers, no "this is too far" lines, an artist wouldn't put just 50% effort in his painting and he wouldn't stick a sponsor logo on it. ED is about memes and shitposting but that is [art](art.md) like any other -- awareness of this is key for a quality wiki. Dramatica makes fun even of itself, it won't censor its own failures, it writes about the competing wikis (when these, on the other hand, may pretend Dramatica doesn't exist), it simply truly only follows the [lulz](lulz.md), at least that's how it seems.
 

dynamic_programming.md

@@ -1,14 +1,14 @@
 # Dynamic Programming
 
-Dynamic programming is a [programming](programming.md) technique that can be used to make many [algorithms](algorithm.md) more efficient (usually meaning faster). It can be seen as an [optimization](optimization.md) technique that works on the principle of repeatedly breaking given problem down into smaller subproblems and then solving one by one from the simplest and remembering already calculated results that can be reused later.
+Dynamic programming is a [programming](programming.md) technique that allows us to increase efficiency of certain types of [algorithms](algorithm.md) (efficiency usually meaning faster execution). It can be seen as an [optimization](optimization.md) technique that works on the principle of repeatedly breaking given problem down into smaller subproblems and then solving one by one from the simplest and remembering already calculated results that can be reused later.
 
-It is frequently contrasted to the *[divide and conquer](divide_and_conquer.md)* (DAC) technique which at the first sight looks similar but is in fact quite different. DAC also subdivides the main problem into subproblems, but then solves them [recursively](recursion.md), i.e. it is a top-down method. DAC also doesn't remember already solved subproblem and may end up solving the same problem multiple times, wasting computational time. Dynamic programming on the other hand starts solving the subproblems from the simplest ones -- i.e. it is a **bottom-up** method -- and remembers solutions to already solved subproblems in some kind of a [table](lut.md) which makes it possible to quickly reuse the results if such subproblem is encountered again. The order of solving the subproblems should be made such as to maximize the efficiency of the algorithm.
+It is frequently contrasted with the *[divide and conquer](divide_and_conquer.md)* (DAC) method which at the first sight looks similar but is in fact quite different. DAC also subdivides the main problem into subproblems, but then solves them [recursively](recursion.md) and separately, i.e. it is a top-down method. DAC also doesn't remember already solved subproblem and may end up solving the same problem multiple times, wasting computation. Dynamic programming on the other hand starts solving the subproblems from the simplest ones -- i.e. it is a **bottom-up** method -- and remembers solutions to already solved subproblems in some kind of a [table](lut.md) which enables quick reusing of the results should the same subproblem be encountered again. The order of solving the subproblems should be chosen so as to maximize the efficiency of this approach.
 
-It's not the case that dynamic programming is always better than DAC, it depends on the situation. Dynamic programming is effective **when the subproblems overlap** and so the same subproblems WILL be encountered multiple times. But if this is not the case, DAC can easily be used and memory for the look up tables will be saved.
+It is NOT the case that dynamic programming would always beat DAC, all depends on the situation. Dynamic programming is effective **when the subproblems overlap** and thus the same subproblems WILL be encountered multiple times -- this is the fact that dynamic programming exploits. Should this not be the case -- i.e. if we are solving a problem that doesn't exhibit this property -- DAC should be used instead.
 
 ## Example
 
-Let's firstly take a look at the case when divide and conquer is preferable. This is for instance the case with many [sorting](sorting.md) algorithms such as [quicksort](quicksort.md). Quicksort recursively divides parts of the array into halves and sorts each of those parts: sorting each of these parts is a different subproblem as these parts (at least mostly) differ in size, elements and their order. The subproblems therefore don't overlap and applying dynamic programming makes little sense.
+For starters let's view a case when divide and conquer would be preferable: this is true for instance about many [sorting](sorting.md) algorithms including [quicksort](quicksort.md) and others. Quicksort [recursively](recursion.md) splits parts of the array into halves and sorts each one separately: sorting each part is a different subproblem given the parts (at least generally) differ in size, elements and their order. The subproblems therefore don't overlap and applying dynamic programming makes little sense.
 
 But if we tackle a problem such as computing *N*th [Fibonacci number](fibonacci_number.md), the situation changes. Considering the definition of *N*th Fibonacci number as a *"sum of N-1th and N-2th Fibonacci numbers"*, we might naively try to apply the divide and conquer method:
 
@@ -21,7 +21,7 @@ int fib(int n)
 }
 ```
 
-But we can see this is painfully slow as calling `fib(n - 2)` computes all values already computed by calling `fib(n - 1)` all over again, and this inefficiency additionally appears inside these functions recursively. Applying dynamic programming we get a better code:
+However we make the observation that this is painfully slow due to the fact that calling `fib(n - 2)` computes all values already computed by calling `fib(n - 1)` all over again, and this inefficiency additionally appears inside these functions recursively. Applying dynamic programming we get a better code:
 
 ```
 int fib(int n)
@@ -42,4 +42,4 @@ int fib(int n)
 }
 ```
 
-We can see the code is longer, but it is faster. In this case we only need to remember the previously computed Fibonacci number (in practice we may need much more memory for remembering the partial results).
+Now the code is longer, but it is faster. In this specific case we only need to remember the previously computed Fibonacci number (in practice we may need much more memory for remembering the partial results).

exercises.md

@@ -216,7 +216,8 @@ Bear in mind the main purpose of this quiz is for you to test your understanding
 109. There is a cube-shaped planet that has 8 houses (numbered 1 to 8), each house on one of the 8 cube vertices. Each house is inhabited by one alien (they're named *A* to *H*). Sometimes they get bored and want to switch houses with others, so they organize a big moving day in which some aliens switch houses (it's possible that everyone moves elsewhere or that just some move and some stay where they are). However they like their neighbors (aliens living in houses directly connected by the same edge), so any time this house switching occurs, at the end of the day everyone must have the same neighbors as before. How many possible ways there are to assign aliens to the houses so that they always have the same neighbors?
 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. Did you enjoy this quiz?
+112. What's the difference between [lazy](lazy.md) and strict evaluation? Show simple example.
+113. Did you enjoy this quiz?
 
 ### Answers
 
@@ -332,7 +333,8 @@ sin(x) / cos(x) - log2(2) = tg(x) - 1*, so we get *tg(x) >= 1*. So that will hol
 109. This is counting graph [automorphisms](automorphism.md). Let's say we assign alien *X* to house 1; we can count how many possible allowed configurations there are for this case and then multiply it all by 8 (for case when *X* would be assigned to house 2, then 3, 4 etc.). Let's say neighbors of *X* are *U*, *V* and *W*. There are 3 edges going from house 1, i.e. 3 possible ways for the first neighbor, *U*, to be placed -- again, consider we put *U* in one place; we'll count the possibilities and eventually multiply them by 3. Now we have 2 edges (2 neighbor houses) remaining and 2 neighbors (*V* and *W*) to put there; again, consider one case and then multiply that by 2. Now we have *X* and all his neighbors in place, how many possible configurations are left here? There is one house that's the neighbor of both *U* and *V* and there is only one possibility of who can live there: the shared neighbor of *U* and *V* -- there is just one option so this house's inhabitant is determined. Same for *V*/*W* and *U*/*W*. That's already 7 houses assigned and the one last remaining has to be in the one house left, so in fact by placing *X* and its neighbors we've uniquely determined the rest of the houses, there's just one way. So in the end we have 8 * 3 * 2 * 1 = 48 possible ways.
 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. yes
+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
 
 ## Other
 

forth.md

@@ -12,7 +12,7 @@ Forth is unique in its philosophy, we might almost go as far as calling Forth a
 
 Being somewhat of a misfit in terms of classification, the language is probably more often presented as [interpreted](interpreter.md), but that's a tiny bit misleading (interpreting Forth is almost like native execution), however it may perfectly well be [compiled](compiler.md) to pure machine code too; it's actually very easy and natural to turn Forth source code into assembly, however (again, due to Forth's unique nature) it is not so easy to state with confidence whether the language is really interpreted or compiled because interpreting Forth happens on such a low level that it's almost native code execution -- any newly defined word is immediately compiled into a list of addresses of other words (i.e. in C terms function pointers) and the most basic words are typically written directly in [machine code](machine_code.md), so the interpreter doesn't perform any search for word names or anything like that (like a typical scripting language would), it just jumps between memory addresses, pushes numbers on stack and sometimes runs a native piece of code. For this Forth may be seen as a kind of "wrapper for assembly" as well, one that helps it be [portable](portability.md) (to port a program one will just have to replace the machine code of the basic words).
 
-Forth systems traditionally include not just a compiler/interpreter but also an **interactive environment** in which one is defining and compiling new words on the go. Again -- this is not just some kind of extra killer feature, an interactive environment naturally comes as a byproduct of Forth's design, it costs nothing to have such environment. This environment can serve for example as a debugger or even an operating system.
+Forth systems traditionally include not just a compiler/interpreter but also an **interactive environment** in which one is defining and compiling new words on the go (by this it's similar to [Lisps](lisp.md) that are usually interactive too). Again -- this is not just some kind of extra killer feature, an interactive environment naturally comes as a byproduct of Forth's design, it costs nothing to have such environment. This environment can serve for example as a debugger or even an operating system.
 
 There are several Forth standards, most notably ANS Forth from 1994 (the document is [proprietary](proprietary.md), sharing is allowed, 640 kB as txt). Besides others it also allows Forth to include optional [floating point](float.md) support, however Forth programmers highly prefer [fixed point](fixed_point.md) (as stated in the book *Starting Forth*). Then there is a newer Forth 2012 standard, but it's probably better to stick with the older one.
 
@@ -50,7 +50,7 @@ Note that even the `:` and `;` characters that serve to define new words are wor
 
 Dictionary constitutes one of the most important concept in Forth, it usually stores the words as a [linked list](list.md), starting with the oldest word -- this allows for example temporary shadowing of previously defined words with the same name.
 
-Forth programmers utilize what's called a **stack notation** to document the "signature" of a function, i.e. what it does with the stack (this is important since the language doesn't have the traditional system of named, counted and checked function parameters) -- they write this notation in a comment above a defined word to communicate to others what the word will do. Stack notation has the format `( before -- after )`, for example the effect of the above defined `average` words would be written as `( a b -- avg )` in this notation.
+Forth programmers utilize what's called a **stack notation** to document the "prototype" of a function, i.e. what it does with the stack (this is important since the language doesn't have the traditional system of named, counted and checked function parameters) -- they write this notation in a comment above a defined word to communicate to others what the word will do. Stack notation has the format `( before -- after )`, for example the effect of the above defined `average` words would be written as `( a b -- avg )` in this notation.
 
 Some predefined words usually present in Forth systems include:
 
@@ -257,7 +257,9 @@ We can run this simply with `gforth my.fs`, the programs should write `120`.
 
 WIP
 
-The genius of Forth resides under the hood -- to see it one has to study the internal working and see how it all ultimately ties together. So let's start here with some very basic overview of the internals.
+The first, immediate glance of elegance of Forth lies in the stack paradigm -- we don't need any brackets in expressions, no operator precedence, there is no distinction between operators and procedures and we don't need a complex expression parser. It's not hard to see the beauty of it, but Forth is not the only stack-based language.
+
+The true, deeper genius of Forth is in the "everything is word" abstraction and how it allows a very elegant implementation, but this is more difficult to see, this resides under the hood -- to appreciate Forth one has to study the internal working and see how it all ultimately ties together. So let's start here with some very basic overview of the internals.
 
 There are several regions of memory, most importantly the parameter stack (the main kind of stack), the return stack and dictionary memory. Dictionary obviously stores the words. **Format of the word in memory** may differ between implementations, but typically a word record has the following fields:
 

free_speech.md

@@ -1,6 +1,6 @@
 # Free Speech
 
-Freedom of speech means there are is no responsibility and absolutely no punishments or obstacles (such as [censorship](censorship.md)), imposed by anyone (government, [corporations](corporation.md), [culture](cutlure.md), society, technology, ...), against merely talking about anything, making any public statement and sharing or publication any kind of [information](information.md) at all. Adopting free speech is not about increasing the degree of speech tolerance as many erroneously think, it's rather a complete change of values and a switch of mentality, letting go of old, primitive kind of thinking and making the leap to a new intellectual level, to absolutely eliminating the very concept of limiting or punishing any kind of expression, therefore **free speech has to be by definition absolute and have no limit**, otherwise it's not free speech but controlled, limited speech -- trying to add exceptions to free speech is like trying to limit to whom a [free software](free_software.md) license is granted; doing so immediately makes such software non-free; free speech "with limits" is like free lunch for a low price or vegetarian food with only a little meat in it -- it's not the real thing, it just wants to be called *X* without actually being *X*. **Free speech also comes with zero responsibility** exactly by definition, as responsibility implies some forms of punishment; free speech means exactly one can say anything without fearing any burden of responsibility -- if anyone says "free speech comes with responsibility", he has absolutely no clue what he's talking about, he is not against censorship, he just advocates self censorship (i.e. censorship done internally rather than externally). If you unable to say something or afraid of saying it because of any kind of punishment -- for example sharing someone's private information or a pirated movie, saying that you hate your boss, that you'd like to fuck your cousin, that there is a bomb on a plane, that you'd like to kill someone -- you have no free speech. True freedom of speech is an essential attribute of a mature society, sadly it hasn't been implemented yet and with the [SJW](sjw.md) [cancer](cancer.md) the latest trend in society is towards eliminating free speech rather than supporting it (see e.g. [political correctness](political_correctness.md)). Speech is being widely censored by extremist groups (e.g. [LGBT](lgbt.md) and [corporations](corporation.md), see also [cancel culture](cancel_culture.md)) and states -- depending on country there exist laws against so called "[hate speech](hate_speech.md)", questioning official versions of history (see e.g. [Holocaust](holocaust.md) denial laws present in many EU states), criticizing powerful people (for example it is illegal to criticize or insult that huge inbred dick Thai king), sharing of useful information such as books ([copyright](copyright.md) censorship) etc. Free speech nowadays is being eliminated by the strategy of creating an exception to free speech, usually called "hate speech", and then classifying any undesired speech under such label and silencing it.
+Freedom of speech means there is no responsibility and absolutely no punishments or obstacles (such as [censorship](censorship.md)), imposed by anyone (government, [corporations](corporation.md), [culture](cutlure.md), society, technology, ...), against merely talking about anything, making any public statement and sharing or publication any kind of [information](information.md) at all. Adopting free speech is not about increasing the degree of speech tolerance as many erroneously think, it's rather a complete change of values and a switch of mentality, letting go of old, primitive kind of thinking and making the leap to a new intellectual level, to absolutely eliminating the very concept of limiting or punishing any kind of expression, therefore **free speech has to be by definition absolute and have no limit**, otherwise it's not free speech but controlled, limited speech -- trying to add exceptions to free speech is like trying to limit to whom a [free software](free_software.md) license is granted; doing so immediately makes such software non-free; free speech "with limits" is like free lunch for a low price or vegetarian food with only a little meat in it -- it's not the real thing, it just wants to be called *X* without actually being *X*. **Free speech also comes with zero responsibility** exactly by definition, as responsibility implies some forms of punishment; free speech means exactly one can say anything without fearing any burden of responsibility -- if anyone says "free speech comes with responsibility", he has absolutely no clue what he's talking about, he is not against censorship, he just advocates self censorship (i.e. censorship done internally rather than externally). If you unable to say something or afraid of saying it because of any kind of punishment -- for example sharing someone's private information or a pirated movie, saying that you hate your boss, that you'd like to fuck your cousin, that there is a bomb on a plane, that you'd like to kill someone -- you have no free speech. True freedom of speech is an essential attribute of a mature society, sadly it hasn't been implemented yet and with the [SJW](sjw.md) [cancer](cancer.md) the latest trend in society is towards eliminating free speech rather than supporting it (see e.g. [political correctness](political_correctness.md)). Speech is being widely censored by extremist groups (e.g. [LGBT](lgbt.md) and [corporations](corporation.md), see also [cancel culture](cancel_culture.md)) and states -- depending on country there exist laws against so called "[hate speech](hate_speech.md)", questioning official versions of history (see e.g. [Holocaust](holocaust.md) denial laws present in many EU states), criticizing powerful people (for example it is illegal to criticize or insult that huge inbred dick Thai king), sharing of useful information such as books ([copyright](copyright.md) censorship) etc. Free speech nowadays is being eliminated by the strategy of creating an exception to free speech, usually called "hate speech", and then classifying any undesired speech under such label and silencing it.
 
 The basic principle of free speech says that **if you don't support freedom of speech which you dislike, you don't support free speech**. I.e. speech that you hate does not equal hate speech.
 

john_carmack.md

@@ -13,7 +13,7 @@ John Carmack (born 1970 in Kansas, [US](usa.md)) is a brilliant legendary progra
 
 *[ASCII art](ascii_art.md) of John Carmack*
 
-He is kind of the ridiculously stereotypical [nerd](nerd.md) with glasses who just by the way he talks gives out the impression of someone with high functioning [autism](autism.md). You can just sense his [IQ](iq.md) is over 9000. However it appears he's the kind of very narrowly focused robot, a calculator capable of superhuman programming and math calculations who knows little to nothing about unrelated areas -- for example he doesn't seem to be able to speak any other language than English or know much about empathy (judging from his conformance to entrepreneurship). { If I'm incorrect, let me know please. I searched if he speaks any languages but haven't found any clues about that being true. ~drummyfish } Some nice [shit](shit.md) about him can be read in the (sadly [proprietary](proprietary.md)) book *Masters of Doom*.
+He is kind of the ridiculously [stereotypical](stereotype.md) [nerd](nerd.md) with glasses who just by the way he talks gives out the impression of someone with high functioning [autism](autism.md). You can just sense his [IQ](iq.md) is over 9000. However it appears he's the kind of very narrowly focused robot, a calculator capable of superhuman programming and math calculations who knows little to nothing about unrelated areas -- for example he doesn't seem to be able to speak any other language than English or know much about empathy (judging from his conformance to entrepreneurship). { If I'm incorrect, let me know please. I searched if he speaks any languages but haven't found any clues about that being true. ~drummyfish } Some nice [shit](shit.md) about him can be read in the (sadly [proprietary](proprietary.md)) book *Masters of Doom*.
 
 Carmack is a proponent of "[FOSS](foss.md)" and has released his old game engines as such which gave rise to an enormous amount of modifications, forked engines and even new games (e.g. [Freedoom](freedoom.md) and [Xonotic](xonotic.md)). He's probably leaning more towards the dark side of the source: the [open-source](open_source.md). In 2021 Carmack tweeted that he would have rather licensed his old Id engines under a permissive BSD [license](license.md) than the [GPL](gpl.md), which is good.
 

less_retarded_society.md

@@ -1,6 +1,6 @@
 # Less Retarded Society
 
-Less [retarded](retard.md) society (LRS, same [acronym](acronym.md) as [less retarded software](lrs.md)) is a model of ideal society towards which we, the [LRS](lrs.md), want to be moving. Less retarded society is a [peaceful](pacifism.md), collaborative society based on [love](love.md) of all [life](life.md), which aims for maximum well being of all living beings, a society without violence, [money](money.md), oppression, need for [work](work.md), social [competition](competition.md), poverty, scarcity, criminality, [censorship](censorship.md), [self-interest](self_interest.md), [government](government.md), police, [laws](law.md), [bullshit](bullshit.md), slavery and many other negative phenomena. It equally values all living beings and establishes true social equality in which everyone can pursue his true desires freely -- it is a TRULY [leftist](left_vs_right.md) society, NOT a [pseudoleftist](pseudoleft.md) one. The society works similarly to that described by the [Venus Project](venus_project.md) and various [anarchist](anarchism.md) theories (especially [anarcho pacifist](anpac.md) [communism](communism.md)), but it also takes good things from elsewhere, even various [religions](religion.md) (without itself actually becoming a religion in traditional sense); for example parts of teaching of [Jesus](jesus.md) and [Buddha](buddhism.md). As Freddie Mercury put it, *this could be heaven for everyone* -- achieving heaven for everyone to us is a goal truly worth living for.
+Less [retarded](retard.md) society (LRS, same [acronym](acronym.md) as [less retarded software](lrs.md)) is a model of ideal society towards which we, the [LRS](lrs.md), want to be moving. Less retarded society is a [peaceful](pacifism.md), collaborative society based on [love](love.md) of all [life](life.md), which aims for maximum well being of all living beings, a society without violence, [money](money.md), oppression, need for [work](work.md), social [competition](competition.md), poverty, scarcity, criminality, [censorship](censorship.md), [self-interest](self_interest.md), [government](government.md), police, [laws](law.md), [bullshit](bullshit.md), slavery and many other negative phenomena. It equally values all living beings and establishes true social equality in which everyone can pursue his true desires freely -- it is a TRULY [leftist](left_vs_right.md) society, NOT a [pseudoleftist](pseudoleft.md) one. The society works similarly to that described by the [Venus Project](venus_project.md) and various [anarchist](anarchism.md) theories (especially [anarcho pacifist](anpac.md) [communism](communism.md)), but it also takes good things from elsewhere, even various [religions](religion.md) (without itself actually becoming a religion in traditional sense); for example parts of teaching of [Jesus](jesus.md) and [Buddha](buddhism.md). LRS isn't searching or arguing for ways to force people to behave well, it is arguing for people to behave well.
 
 **How is this different from other ideologies and "life philosophies"?** Well, one principal difference is that **LRS doesn't want to [fight](fight_culture.md)**, in fact LRS adopts a **[pessimistic](pessimism.md), [defeatist](defeatism.md) mindset** to not compromise [morality](morality.md) by any desire to "win the game", behaving correctly is more important than achieving a goal, ends do NOT justify the means. In order to establish a truly good society a crucial realization is that **harm is only ever done by those trying to force their ideas** -- it is even irrelevant what the ideas are, whether it's self-interest, equality, collectivism, sharing, important is only that forcing any idea will do harm, so giving up force and violence is the absolutely essential first step we have to make. That's in stark contrast with today's mentality. Nowadays as well as in the past society has always been about conflict, playing a **game** against others (nowadays e.g. market competition, employment competition, media competition, ...) in which some win, some can manage and some lose. Most political parties nowadays just want to change the rules of the game or downright switch to a different kind of game, some want to make the rules "more fair", or to make it favor their represented minority (so called [fascism](fascism.md)), some just want to [hack](hacking.md) the game, some want to [cheat](cheat.md) to win the game easily, some want to play fair but still win (i.e. become "successful"). LRS simply sees any kind of such game as unnecessary, cruel, unethical and harmful in many ways not just to us, but to the whole planet. LRS therefore simply wants to stop the game, not by force but by making everyone see how bad the game is. It says that **competition and conflict must seize to be the basis of society**. There is no value in achieving anything by violence, such a change will soon be reverted by counter revolution, people themselves have to understand what's good and choose it voluntarily. That is one of the reasons why we are **[pacifists](pacifism.md)** and **reject all violence**, only wanting to promote our ideas by [education](education.md). We accept we may not achieve our goals and we most certainly won't achieve anything during our lifetime and that gives us the freedom to behave truly morally. We try to **never be [proud](pride.md)** of anything, as pride leads to violence and fascism. We are also in many ways aligned with the ideals of **[cynicism](cynicism.md)**.
 

lisp.md

@@ -0,0 +1,101 @@
+# Lisp
+
+{ I'm not a Lisper, let me know if something I claim here is wrong. ~drummyfish }
+
+WIP
+
+Lisp (for "[list](list.md) processing") constitutes a family of [minimalist](minimalism.md) [programming languages](programming_language.md), such as *Common Lisp*, *Scheme* or *Clojure*, which all descend from an old (1960, by [John McCarthy](john_mccarthy.md)) language called LISP. Given the big number of different Lisp languages (called *Lisp dialects*) that have spawned from the original LISP along the way (in a fashion similar to [Linux](linux.md) distros, just among programming languages), it's hard to make general statements about all of them, but as a high altitude overview let's state this much: Lisp languages are based on **[functional](functional.md) [paradigm](paradigm.md)** and [lambda calculus](lambda_calculus.md) (though not strictly enforcing functional programming, side effects of functions are still allowed as well as imperative and other paradigms), they're **[high level](high_level.md)** (but simple), very dynamic and **flexible**, **dynamically typed**, usually interpreted (or compiled to [bytecode](bytecode.md), though some also compile to native code), [garbage collected](garbage_collection.md), use a **prefix notation with brackets** (e.g. `(+ 1 2)` instead of `1 + 2`) and are quite **[elegant](beauty.md) and [minimalist](minimalism.md)** -- many [hackers](hacking.md) consider (some form of) Lisp to be the pinnacle of beauty and minimalism; in this Lisp competes mainly with [Forth](forth.md), another extremely minimalist language. While Forth wins on some fronts, mainly that of performance and being a better fit for typical hardware, Lisp is the more **[mathematically](math.md) elegant** language, it IS the mathematician's wet dream -- [Alan Kay](alan_kay.md) went as far as calling it the "Maxwell’s Equations of software" once he saw it could be described on a single page. I.e., unlike Forth, Lisp is normally not among the fastest languages (for example [Emacs](emacs.md) is in great part written in Lisp but has to rely on [C](c.md) core for performance critical parts) -- likely due to the overhead of dynamic typing and high [abstraction](abstraction.md) (e.g. arbitrarily precise numbers, garbage collection etc.) -- but it has to be said Lisp can run exceptionally fast on special [hardware](hw.md) that is made to run Lisp -- in fact there used to be such machines, called *Lisp Machines*, however they fell out of popularity. Lisp is infamous for employing an excessive number of brackets -- for this Lisp programmers are usually sensitive about proper code [formatting](programming_style.md). Lisp is often used as a [scripting](scripting.md) language for extensions, e.g. in [Emacs](emacs.md) or [GIMP](gimp.md).
+
+Lisps typically employ **strict evaluation** (i.e. they evaluate all function parameters whether they're needed or not, just like the "mainstream imperative languages" rather than purely functional ones) -- this is probably because purely functional paradigm isn't enforced, imperative constructs are supported (though often discouraged). This takes away a bit of elegance because now there have to exist so called *special forms*, i.e. constructs that look like functions (they use the same syntax) but are exception from how normal functions behave -- for example while normal functions always have all their parameters evaluated, *if* branch is a special form that only evaluates a certain branch, depending on condition (consider e.g. `(if #t (display "yes") (display "no"))`; evaluating all arguments would lead to executing both branches). Strictly functional languages like [Haskell](haskell.md) don't suffer from this, however it seems like Lisp kind of masterfully break this rule to allow a bit more practicality, it just found a nice balance of imposing rules but removing limitations.
+
+Part of the Lisp philosophy/[paradigm](paradigm.md) is that **program and data are represented in the same way**, i.e. that there is little distinction between code and data: both are just lists or, in Lisp terms, so called **S-expressions** (symbolic expressions, basically the bracketed expressions in which the first symbol is understood to be the operator/function and the rest are its arguments). This allows for example dynamically constructing a program and executing it at runtime.
+
+Lisps also have various systems of [macros](macro.md) that allow to extend the language on-the-go (similarly to [Forth](forth.md)), i.e. it is possible to create even new control structures etc.
+
+**Lisp is high level but [minimalist](minimalism.md)**, a rare beast to witness, an unusual combination to see at least [nowadays](21st_century.md), but not a bad combination -- high level languages are not necessarily evil, it's just that [bloat](bloat.md) is evil and high level usually implies bloat. However Lisp manages to stay nice -- the language is defined in very abstract ways, treating values in memory as abstract entities rather than sequences of [bits](bit.md), not bothering the programmer with memory management etc. -- this is subsequently usually [optimized](optimization.md) under the hood by compilers/interpreters to a more machine friendly code, however the programmer doesn't have to care, it's enough he knows the abstract behavior. Of course there are penalties for this, ignoring what's going on behind the curtains always comes for a price, but Lisp makes this choice willingly and implements it so as to gain the advantages of high level while minimizing the penalties -- for example the language is designed so that it can be implemented in a minimalist way. So basically we could call Lisp a *high level language done right*.
+
+**How do the Lisp dialects differ?** Potentially in many different ways: some focus on pragmatism, some on minimalism, some add their own extensions and features, some modify the language itself while some just provide extra libraries, some just put more emphasis on different things (e.g. PicoLisp is more datacentric), some try to support more paradigms such as [OOP](oop.md), some just try to do things differently than others. For example let's examine Common Lisp versus Scheme: Common Lisp is more "bloated", has a big standard library, Scheme is more minimalist, enforces tail recursion to be optimized (and so more encourages functional programming) and mostly doesn't specify order of argument evaluation, Common Lisp evaluates arguments from left to right and supports dynamic scope while Scheme only supports lexical scope, and so on and so [forth](forth.md). From someone coming from the world of C -- where C is simply C -- this world may invoke a cultural shock and information overload: there are different Lisp dialects, each with different standards, each with different implementation. But ultimately there is richness, evolution and a great deal of choice in it. Some of the most notable List dialects include:
+
+- **Common Lisp** (CL): The "big", [bloated](bloat.md) (for Lisp standards), "feature rich" kind of Lisp, around since 1984; it is widely supported and well standardized by ANSI.
+- **Scheme** (and descendants such as *Racket*): Well established minimalist branch of Lisp, around since 1975.
+- **Clojure**: Some shitty Lisp in [Java](java.md) or something.
+- **PicoLisp**: Another minimalist kind of Lisp, looks cool but probably not as famous as Scheme.
+- **Emacs Lisp**: Used in [Emacs](emacs.md) text editor.
+- ...
+
+## Details (Scheme Lisp)
+
+**From now on we'll be talking about Scheme Lisp**. This is because it's the most minimalist of the big Lisp languages, so it's of the biggest interest to [us](lrs.md). Furthermore there are several **standards** of Scheme, most notable are probably the ones called *Revised Report^N on the Algorithmic Language Scheme* where *N* is integer, which is shortened to *rNrs*. It seems like the most classic one is r5rs from 1998, which is the one we will adopt here.
+
+As said, basically every construct in Lisp has the form `(f a1 a2 a3 ...)` where *f* is a function (e.g. `+`, `sin` or `myFunction`) and *a1*, *a2* etc. are arguments, which themselves are either of the same format or represent some atomic value, such as a number (e.g. `123`) or string (e.g. `"hello"`). So what in [C](c.md) we would write as `myVariable = myFunction(1,2,strLen("abc"))` in Lisp we write like `(set! myVariable (myFunction 1 2 (strLen "abc")))`. This format applies also to control structures, macros and so on.
+
+**How to**: there are many Scheme implementations, for example *scm*, *mit-scheme* or *Guile*. We'll choose *scm* here. To run a Scheme source code from a file just do: `scm -f source.scm`.
+
+As for **[data types](data_type.md)**: Scheme (and Lisp in general) is dynamically typed, i.e. values have data types but variables don't -- it is possible to assign any value to any variable and type checking happens at run time. All variables can be seen as [pointers](pointer.md) to a general object type (which carries information about its type). Data types in scheme include:
+
+- *[boolean](bool.md)*: Data type for [binary](binary.md) logic, can hold one of two values: `#t` (true) and `#f` (false). In Scheme (but not necessarily elsewhere) `#f` is considered the only false value, everything else is true. 
+- *[number](number.md)*: In Lisps numbers are more abstract that in traditional languages, they are normally unbounded and arbitrarily precise; [complex](complex_number.md) numbers and rational numbers are supported (i.e. we can e.g. keep value 1/3 exactly). Furthermore every number is either **exact or [inexact](approximation.md)**, i.e. computing for example square root of two will return a special kind of number marked as a mere approximation.
+- *character*: Element of strings.
+- *string*: Sequence of characters.
+- *pair*: Very important type capable of holding exactly two ordered values, the first one denoted **car**, the other one **cdr** (the names are weird for [historical](history.md) reasons). This is used to make lists.
+- *list*: Linked list made from pairs; in a pair the first item is a value and the other one points to another pair -- next chain in the link. The last item points to a special value called *empty list* that terminates the list. Lists are extremely important in Lisp (they literally gave it the name).
+- *[vector](vector.md)*: Collection of items, similar to a list but with better performance in random access.
+- *symbol*: Not to be confused with strings, they're more of tokens, for example `+`. This helps us be able to treat code as data and vice versa.
+- *[procedure](function.md)*: Procedures are first class citizens in Lisp, i.e. we may assign them to variables etc.
+
+Here is a small cheatsheet:
+
+- **comments**: Start with `;` and go until new line.
+- **basic operators/predicates**: `+`, `-`, `*`, `/`, `=`, `<`, `>`, `<=`, `>=`, `abs`, `max`, `min`, `zero?`, `positive?`, `1+` (increment), `-1+`, `quotient`, `remainder`, `modulo`, `gcd`, `and`, `or`, `not` ...
+- **numbers**: `floor`, `ceiling`, `round`, `exact?`, `inexact?`, `number?`, `integer?`, `rational?`, `real?`, `complex?`, `numerator`, `rationalize`, `real-part`, `exact->inexact`, ...
+- **branching**: `(if cond thenCommand)` or `(if cond thenCommand elseCommand)` (with else branch), is a SPECIAL form, i.e. lazily evaluates only the correct branch, returns the value of the branch. Switch is made with `(cond (test1 actions1 ...) (test2 actions2 ...) ...)` which evaluates tests one by one until one is found to be true, then actions are performed and the value of the last one is returned.
+- **do loop** (tail recursion is preferred to loops): `(do ((var init step) ...) (test expr1 expr2 ...) command1 command2 ...)` makes a loop that initializes local variables (*var* with initial value *init*, each iteration *step* is performed), then performs *test*; if false, then commands are executed left to right and loop repeats, otherwise expressions *expr1*, *expr2* etc. are evaluated and the value of last one is returned.
+- **sequence**: `(begin command1 command2 command3 ...)` is used to create a block of commands that will evaluate from left to right, the value of last command (expression) will be returned.
+- **variables**: `(define varName value)` creates variable *varName* with initial value set. Similarly `(let ((v1 a) (v2 b) ...) commands)` creates a block (similar to C's `{`/`}` block) with local variables *v1*, *v2* etc. (with initial values *a*, *b* etc.). Then `(set! var value)` is used to set the variable value (`!` indicates a side effect).
+- **functions**: `(define (fName x y z) ...)` creates function *fName* with parameters *x*, *y* and *z*; `(fName a b c)` calls the function. Expressions in function are evaluated from left to right, the value of last expression is returned by the function.
+- **[input/output](io.md)**: `(read)` reads a value from input, `(display x)` prints out value *x*.
+- **other**: `sin`, `cos`, `log`, `exp`, `sqrt`, `number->string`, `string->number`, `string?`, `list?`, `character?`, `cons` (creates pair from two values), `list` (creates list from all arguments), `quote` (special form, creates a list without evaluating it), `(lambda (x y ...) commands ...)` (creates anonymous function), ...
+
+**Example**: here is our standardized **divisor tree** program written in Scheme:
+
+```
+;;; returns the divisor tree string
+(define (divisorTreeStr x)
+  (define divs (cons 0 1)) ; divisors (a, b)
+
+  (do                      ; find two closest divisors
+    ((i 2 (+ i 1)))
+    ((or (> i (/ x 2)) (>= (car divs) (cdr divs))))
+    (if (zero? (remainder x i))
+      (set! divs (cons i (/ x i)))))
+
+  (string-append
+    "("
+    (if (zero? (car divs))
+      ""
+      (string-append (divisorTreeStr (car divs)) " "))
+    (number->string x)
+    (if (zero? (car divs))
+      ""
+      (string-append " " (divisorTreeStr (cdr divs))))
+    ")"))
+
+(define inVal 0)
+
+(define (mainLoop) ; main loop, read values from the user
+  (define inVal 0)
+  (display "Enter a number: ")
+  (set! inVal (read))
+
+  (if (not (and (integer? inVal) (>= inVal 0)))
+    #f
+    (begin
+      (display (string-append (divisorTreeStr inVal) "\n"))
+      (mainLoop))))
+
+(mainLoop)
+```
+
+
+
+

lrs.md

@@ -29,7 +29,7 @@ The definition here is not strict but rather [fuzzy](fuzzy.md), it is in a form
 - Being **[free culture](free_culture.md)**, i.e. LRS programs are free as a whole, including art assets, data etc.
 - **Minimizing [dependencies](dependency.md)**, even those such as standard library or relying on OS concepts such as files or threads, even indirect ones such as build systems and even non-software ones (e.g. avoiding [floating point](float.md), GPU, 64bit etc.).
 - Very **[portable](portability.md)**, hardware non-discriminating, i.e. being written in a portable language, minimizing resource usage (RAM, CPU, ...) and so on.
-- Being written in a **good, [suckless](suckless.md) programming language** -- which languages are acceptable is debatable, but some of them most likely include [C](c.md) (C89 or C99), [comun](comun.md), [Forth](forth.md), [Lisp](lisp.md), maybe even [Brainfuck](brainfuck.md), [False](false.md), [Lua](lua.md), [Smalltalk](smalltalk.md), [Pascal](pascal.md) etc. On the other hand bloated languages like [Python](python.md), [JavaScript](js.md) or [Rust](rust.md) are absolutely unacceptable.
+- Being written in a **good, [suckless](suckless.md) programming language** -- which languages are acceptable is debatable, but some of them most likely include [C](c.md) (C89 or C99), [comun](comun.md), [Forth](forth.md), [Lisp](lisp.md) (mainly [Scheme](scheme.md)), maybe even [Brainfuck](brainfuck.md), [False](false.md), [Lua](lua.md), [Smalltalk](smalltalk.md), [Pascal](pascal.md) etc. On the other hand bloated languages like [Python](python.md), [JavaScript](js.md) or [Rust](rust.md) are absolutely unacceptable.
 - **[Future-proof](future_proof.md)**, **[self-contained](self_contained.md)** (just compile and run, no unnecessary config files, daemons, database services, ...), [finished](finished.md) as much as possible, not controlled by anyone (should follow from other points). This may even include attributes such as physical durability and design that maximizes the devices life.
 - **[Hacking](hacking.md) friendly**, repairable and inviting to improvements and customization, highly adhering to [hacker culture](hacking.md).
 - Built on top of other LRS or LRS-friendly technology such as the [C99](c.md) language, comun, Unix, our own libraries etc.
@@ -93,7 +93,7 @@ Apart from this software a lot of other software developed by other people and g
 - **[dwm](dwm.md)**: Official [suckless](suckless.md) [window manager](wm.md).
 - **[Collapse OS](collapseos.md)** and **[Dusk OS](duskos.md)**: Extremely minimalist [operating systems](operating_system.md).
 - **[LIL](lil.md)**: Tiny embeddable [scripting](script.md) programming language.
-- **[Lisp](lisp.md)**: Programming language with a pretty elegant design.
+- **[Lisp](lisp.md)** (mainly [Scheme](scheme.md)): Programming language with a pretty elegant design.
 - **[st](st.md)**: Official [suckless](suckless.md) [terminal emulator](terminal.md).
 - **[badwolf](badwolf.md)**: Very small yet very usable [web browser](browser.md).
 - **[netsurf](netsurf.md)**: Nice minimalist web browser.

lrs_dictionary.md

@@ -30,6 +30,7 @@ WORK IN PROGRESS
 | [democracy](democracy.md)                  | democrazy                                                   |
 | digital garden                             | digital swamp                                               |
 | digital rights management ([DRM](drm.md))  | digital restrictions management                             |
+| Discord                                    | Discunt                                                     |
 | [economy](economy.md)                      | money religion                                              |
 | [encryption](encryption.md)                | bloatcryption                                               |
 | [entrepreneur](entrepreneur.md)            | murderer                                                    |
@@ -61,6 +62,7 @@ WORK IN PROGRESS
 | [microtransaction](microtransaction.md)    | microtheft                                                  |
 | [moderation](moderation.md)                | [censorship](censorship.md)                                 |
 | [modern](modern.md)                        | malicious, shitty                                           |
+| [.NET](dot_net.md)                         | .NEET                                                       |
 | [network](network.md)                      | notwork                                                     |
 | neurodivergent                             | retarded, neuroretarded                                     |
 | neurotypical                               | typical retard                                              |

number.md

@@ -196,6 +196,8 @@ While mathematicians work mostly with infinite number sets and all kind of "weir
   - **[quaternion](quaternion.md)**: Analogous to mathematical quaternions.
   - **symbolic**: Used in some specialized mathematical software to perform symbolic computation, i.e. computation done in a human-like way, by manipulating symbols without using concrete values that would have to resort to approximation.
   - ...
+  
+However some programming languages, such as [Lisp](lisp.md), sometimes treat numbers in very abstract, more mathematical ways (for the price of some performance loss and added [complexity](bloat.md)) such as exactly handling rational numbers with arbitrary precision, distinguishing between exact and inexact numbers etc.
 
 ## Notable Numbers
 

political_correctness.md

@@ -30,7 +30,7 @@ As political correctness is reaching new heights with every passed year, we are
 
 Political correctness is a typical [woman](woman.md) thinking emotional [bullshit](bullshit.md) that looks for problems where they're not instead on focusing on solving real issues. For example in the world of technology a man will focus on designing a good computer, creating minimalist design, good [API](api.md)s and programming languages, while a woman will become obsessed about what color to paint it, what animal mascot it should have and what nickname to give it so that it sounds cute but doesn't touch anyone feelings -- political correctness makes this relatively harmless little quirk of woman thinking into [cancerous](cancer.md) society wide obsession and forces everyone to be preoccupied with it. It is stupidity that got out of hand. It happened partially because society took women their dolls they could play these games with and forced them into fields that were meant only for men. It is also further worsened by [cultural castration](cultural_castration.md) of men -- a man in [21st century](21st_century.md) is already half woman.
 
-While political correctness loves to boast about "diversity" and somehow "protecting it", it is doing the exact opposite -- **political correctness kills diversity in society**, it aims for **a unified, sterile society** that's afraid of even hinting on someone else's difference out of fear of punishment. People are different, [stereotypes](stereotype.md) are based on reality, acknowledging this -- and even [joking](jokes.md) about it -- doesn't at all mean we have to start to hate each other (in fact that requires some fucked up mental gymnastics and a shitty society that pushes [competitive](capitalism.md) thinking), diversity is good, keeps us aware of strength in unity: everyone is good at something and bad at something, and sometimes we just do things differently, a westener might approach problem differently than Asian or Arab, they look different, think and behave differently, and that's a good thing; political correctness forbids such thinking and only states "there is no such thing as differences in people or culture, don't even dare to hint on it", it will go on to censor anything showing the differences do actually exist and leave nothing but plain white sheet of paper without anything on it, a robotic member of society that's afraid to ask someone about his gender or even place where he comes from, someone unable of thinking or communicating on his own, only resorting to preapproved "safe" ways of communication. Indeed, reality yet again starts beating dystopian fiction horrors.
+While political correctness loves to boast about "diversity" and somehow "protecting it", it is doing the exact opposite -- **political correctness kills diversity in society**, it aims for **a unified, sterile society** that's afraid of even hinting on someone else's difference out of fear of punishment. People are different, [stereotypes](stereotype.md) are based in reality, acknowledging this -- and even [joking](jokes.md) about it -- doesn't at all mean we have to start to hate each other (in fact that requires some fucked up mental gymnastics and a shitty society that pushes [competitive](capitalism.md) thinking), diversity is good, keeps us aware of strength in unity: everyone is good at something and bad at something, and sometimes we just do things differently, a westener might approach problem differently than Asian or Arab, they look different, think and behave differently, and that's a good thing; political correctness forbids such thinking and only states "there is no such thing as differences in people or culture, don't even dare to hint on it", it will go on to censor anything showing the differences do actually exist and leave nothing but plain white sheet of paper without anything on it, a robotic member of society that's afraid to ask someone about his gender or even place where he comes from, someone unable of thinking or communicating on his own, only resorting to preapproved "safe" ways of communication. Indeed, reality yet again starts beating dystopian fiction horrors.
 
 **Political correctness goes strictly against [free speech](free_speech.md)**, it tries to force people "to behave" and be afraid of words and talking, it creates conflict, divides society (for dividing the working class it is criticized e.g. by [Marxists](marxism.md)) and also TEACHES people to be [offended](offended_culture.md) by language -- i.e. even if a specific word wouldn't normally be used or seen in a hostile way (e.g. the *master branch* in git repositories), political correctness establishes that NOW IT IS OFFENSIVE and specific minorities SHOULD take offense, even if they normally wouldn't, supporting [offended culture](offended_culture.md) and [fight culture](fight_culture.md). I.e. political correctness can be called a [cancer](cancer.md) of society. **[LRS](lrs.md) must never adhere to political correctness!**
 
@@ -42,7 +42,9 @@ Political correctness comes with a funny little phenomenon in a form of constant
 
 **Political correctness fuels racism** (racism in the true sense of the word, i.e. hatred between human races). Before political correctness there wasn't as much hatred between human races as there is today. Exploitation yes -- black people were exploited just like workers are exploited by bourgeoisie, but there wasn't really hatred, just as there isn't a hatred of your boss towards you or of as there is no hatred of the slaughterer towards the pig. Hate is a construct of political correctness that tries to start a [war](war.md) to which hatred is a prerequisite.
 
-Yet another harmfulness of political correctness is by making people too focused on shallow words instead of focusing on real issues. It's not just the harsh punishments for saying certain banned words, even if they wouldn't do much actual damage, it is also the opposite -- inventing new words and offering them as "solutions" to issues. For example it's completely absurd how some very old people who have been outsiders for their whole lives because they're simply weird, shy, too stupid or smart, are suddenly offered a supposed comfort by being told: "you're not weird, you're just neurodivergent!" The guy is like "OH MY GOD, my whole life I have suffered, I thought I was just not good with people, but in fact I was just neurodivergent my whole life -- if only I knew back then!". The amount of stupidity is incredible.
+Yet another harm of political correctness lies in making people too focused on shallow words instead of focusing on real issues, it actually makes people feel they are helping while they're not. It's not just the harsh punishments for saying bad words, even if they wouldn't do much actual damage, it is also the opposite -- inventing new words and offering them as "solutions" to issues, which has a similar effect of providing false comfort like for example the Facebook mindset of "I am helping the world by changing my profile picture to Ukrainian flag!". For example it's completely absurd how some very old people who have been outsiders for their whole lives because they're simply weird, shy, too stupid or smart, are suddenly offered a supposed comfort by being told: "you're not weird, you're just neurodivergent!" The guy is like "OH MY GOD, my whole life I have suffered, I thought I was just not good with people, but in fact I was just neurodivergent my whole life -- if only I knew back then!". The amount of stupidity is incredible.
+
+More and more minorities start to jump on the wave of political correctness to kickstart the multiplication of their political capital, everyone wants to get on the scene by demanding more "[rights](rights_culture.md)" and complaints about "offenses" are one of the most effective ways of doing so -- "Hey society, we are the arachnophobia minority and we demand you remove all pictures of spiders because it makes us sad!" Now society has to stop showing spiders, make spider toys, even mention the word spider. What about people who actually like spiders? Fuck them. Did you know there probably exist people who are afraid of color green or maybe cars or circle shapes? Remove all that shit, it might cause slight discomfort to someone! Eventually political correctness, in an attempt to remove any and all possibility of causing discomfort to someone, cripples the whole world for everyone.
 
 Let us now compare how we, [LRS](lrs.md), approch the issue of "getting offended" versus how the pseudoleft does it. We start with the "problem": people are getting offended. What do we do?
 

programming_language.md

@@ -116,7 +116,7 @@ Here is a table of notable programming languages in chronological order (keep in
 | ----------------------- | ---------------- | ----- | ------- | -------- | ------------------------ | ---- | ---------------------- | ----------------------------------------------------------------------- |
 |"[assembly](assembly.md)"| **yes but...**   | 1947? |         |          |                          |      |                        | NOT a single language, non-[portable](portability.md)                   |
 | [Fortran](fortran.md)   | **kind of**      | 1957  | 1.95 (G)| 7.15 (G) |                          |      | 300, proprietary (ISO) | similar to Pascal, compiled, fast, was used by scientists a lot         |
-| [Lisp](list.md)         | **yes**          | 1958  | 3.29 (G)| 18 (G)   | 100 (judg. by jmc lisp)  |      | 1?                     | elegant, KISS, functional, many variants (Common Lisp, Closure, ...)    |
+| [Lisp](list.md)(s)      | **yes**          | 1958  | 3.29 (G)| 18 (G)   | 100 (judg. by jmc lisp)  | 35   | 40 (r3rs)              | elegant, KISS, functional, many variants (Common Lisp, Scheme, ...)     |
 | [Basic](basic.md)       | kind of?         | 1964  |         |          |                          |      |                        | mean both for beginners and professionals, probably efficient           |
 | [Forth](forth.md)       | **YES**          | 1970  |         |          | 100 (judg. by milliforth)| 77   | 200 (ANS Forth)        | [stack](stack.md)-based, elegant, very KISS, interpreted and compiled   |
 | [Pascal](pascal.md)     | **kind of**      | 1970  | 5.26 (G)| 2.11 (G) |                          |      | 80, proprietary (ISO)  | like "educational C", compiled, not so bad actually                     |
@@ -131,8 +131,8 @@ Here is a table of notable programming languages in chronological order (keep in
 | [Perl](perl.md)         | rather not       | 1987  | 77 (G)  | 8.64 (G) |                          |      |                        | interpreted, focused on strings, has kinda cult following               |
 | [Bash](bash.md)         | well             | 1989  |         |          |                          |      |                        | Unix scripting shell, very ugly syntax, not so elegant but bearable     |
 | [Haskell](haskell.md)   | **kind of**      | 1990  | 5.02 (G)| 8.71 (G) |                          |      | 150, proprietary       | [functional](functional.md), compiled, acceptable                       |
-| [Python](python.md)     | NO               | 1991  | 45 (G)  | 7.74 (G) |                          |      | 200? (p. lang. ref.)   | interpreted, huge bloat, slow, lightweight OOP, artificial obsolescence |
+| [Python](python.md)     | NO               | 1991  | 45 (G)  | 7.74 (G) |                          | 32   | 200? (p. lang. ref.)   | interpreted, huge bloat, slow, lightweight OOP, artificial obsolescence |
-| POSIX [shell](shell.md) | well, "kind of"  | 1992  |         |          |                          | 32   | 50, proprietary (paid) | standardized (std 1003.2-1992) Unix shell, commonly e.g. [Bash](bash.md)|
+| POSIX [shell](shell.md) | well, "kind of"  | 1992  |         |          |                          |      | 50, proprietary (paid) | standardized (std 1003.2-1992) Unix shell, commonly e.g. [Bash](bash.md)|
 |[Brainfuck](brainfuck.md)| **yes**          | 1993  |         |          | 100 (judg. by dbfi)      |      | 1                      | extremely minimal (8 commands), hard to use, [esolang](esolang.md)      |
 | [FALSE](false.md)       | **yes**          | 1993  |         |          |                          |      | 1                      | very small yet powerful, Forth-like, similar to Brainfuck               |
 | [Lua](lua.md)           | **quite yes**    | 1993  | 91 (G)  | 5.17 (G) | 7K (LuaInLua)            |      | 40, free               | small, interpreted, mainly for scripting (used a lot in games)          |

recursion.md

@@ -1,6 +1,6 @@
 # Recursion
 
-*See [recursion](recursion.md).* { Lame but effective :D ~drummyfish }
+*See [recursion](recursion.md).*
 
 Recursion (from Latin recursio, "running back") in general is a situation in which a [definition](definition.md) refers to itself; for example the definition of a human's ancestor as "the human's parents and the ancestors of his parents" ([fractals](fractal.md) are also very nice example of what a simple recursive definition can achieve). In [programming](programming.md) recursion denotes a **[function](function.md) that calls itself**; this is the meaning we'll assume in this article unless noted otherwise.
 

reddit.md

@@ -1,6 +1,6 @@
 # Reddit
 
-Reddit, established in 2005, marketing itself as the "frontpage of the [Internet](internet.md)", was an extremely successful, popular and a quite nice website for sharing links, ideas and leading discussions about them, before it got absolutely destroyed by [capitalists](capitalism.md) right before they year 2020. It used to be a forum with great amount of [free speech](free_speech.md) and with quite enjoyable, plain user interface; in a swift turn of events however it flipped completely over and is now among the worst, most [censored](censorship.dm) sites on the whole [web](www.md), a place [toxic](toxic.md) with [SJW](sjw.md) fumes and its site is literally unusable for the amount of [bloat](bloat.md) and [ads](marketing.md) it employs. Never visit the site if you don't have to.
+Reddit, established in 2005, marketing itself as the "frontpage of the [Internet](internet.md)", was an extremely successful, popular and a quite nice website for sharing links, ideas and leading discussions about them, before it got absolutely destroyed by [capitalists](capitalism.md) right before they year 2020. It used to be a forum with great amount of [free speech](free_speech.md) (see e.g. [beatingWomen subreddit](https://web.archive.org/web/20110429073233/reddit.com/r/beatingwomen)) and with quite enjoyable, plain user interface; in a swift turn of events however it flipped completely over and is now among the worst, most [censored](censorship.dm) sites on the whole [web](www.md), a place [toxic](toxic.md) with [SJW](sjw.md) fumes and its site is literally unusable for the amount of [bloat](bloat.md) and [ads](marketing.md) it employs. Never visit the site if you don't have to.
 
 Reddit users are the kind of "moderate rebels", the sort of absolutely insignificant people who think they're doing heroic acts by changing a profile picture or sharing a mildly unpopular opinion on [Facebook](facebook.md), like "I actually think [piracy](piracy.md) is not bad! Take this [corporations](corporation.md)!". [Nowadays](21st_century.md) the users are exclusively [SJWs](sjw.md), all the popular post are attempts at [virtue signaling](virtue_signaling.md) and circlejerking, you'll find annoying propaganda inserted into absolutely unrelated subreddits, e.g. in a subreddit for sharing interesting pictures the all time top post will be something like a motivational tweet by Zelenski or some other [gay](gay.md) (of course there are now annoying sponsored posts inserted in too, literally makes you wanna [kill yourself](kys.md)). Very infamous are for example reddit [atheists](atheism.md) who are very enlightened by Neil De Grass documentaries, they don't understand how a medieval peasant could believe in irrational things, conform to orthodox preaching and participate in witch hunts, but if you suggest [removing the age of consent](pedophilia.md) or opposing [feminism](feminism.md) they pick up the torches and go full angry mob yelling "Stone that heretic to death!" That's because they're just trained to react to [key words](shortcut_thinking.md), they can't do much more.
 

vector.md

@@ -1,6 +1,6 @@
 # Vector
 
-Vector is a basic [mathematical](math.md) object that expresses direction and magnitude (such as velocity, force etc.) and is very often expressed as (and many times misleadingly equated with) an "[array](array.md) of [numbers](number.md)". Nevertheless in [programming](programming.md) 1 dimensional arrays are somewhat synonymous with vectors -- for example in two dimensional space an array `[4,3]` expresses a vector pointing 4 units to the "right" (along X axis) and 3 units "up" (along Y axis) and has the magnitude 5 (which is the vector's [length](length.md)). Vectors are one of the very basic concepts of advanced math and are used almost in any advanced area of math, physics, programming etc. -- basically all of physics and engineering operates with vectors, programmers will mostly encounter them in areas such as computer [graphics](graphics.md) (e.g 3D graphics, 2D [vector graphics](vector_graphic.md), ...), [physics engines](physics_engine.md) (forces, velocities, acceleration, ...), [machine learning](machine_learning.md) (feature vectors, ...) or [signal processing](signals.md) (e.g. [Fourier transform](fourier_transform.md) just interprets a signal as a vector and transforms it to a different basis) etc. In this article we will implicitly focus on vectors from programmer's point of view (i.e. "arrays of numbers") which to a mathematician will seem very simplified, but we'll briefly also foreshadow the mathematical view.
+Vector is a basic [mathematical](math.md) object that expresses direction and magnitude (such as velocity, force etc.) and is very often expressed as (and many times misleadingly equated with) an "[array](array.md) of [numbers](number.md)". Nevertheless in [programming](programming.md) one dimensional arrays are somewhat synonymous with vectors -- for example in two dimensional space an array `[4,3]` expresses a vector pointing 4 units to the "right" (along X axis) and 3 units "up" (along Y axis) and has the magnitude 5 (which is the vector's [length](length.md)). Vectors are one of the very basic concepts of advanced math and are used almost in any advanced area of math, physics, programming etc. -- basically all of physics and engineering operates with vectors, programmers will mostly encounter them in areas such as computer [graphics](graphics.md) (e.g 3D graphics, 2D [vector graphics](vector_graphic.md), ...), [physics engines](physics_engine.md) (forces, velocities, acceleration, ...), [machine learning](machine_learning.md) (feature vectors, ...) or [signal processing](signals.md) (e.g. [Fourier transform](fourier_transform.md) just interprets a signal as a vector and transforms it to a different basis) etc. In this article we will implicitly focus on vectors from programmer's point of view (i.e. "arrays of numbers") which to a mathematician will seem very simplified, but we'll briefly also foreshadow the mathematical view.
 
 (NOTE: the term *vector* is used a lot in different contexts and fields, usually with some connection to the mathematical idea of vector which is sometimes however very loose, e.g. in low-level programming *vector* means a memory holding an address of some event handler. It's better to just look up what "vector" means in your specific area of interest.)
 

wiki_stats.md

@@ -2,10 +2,10 @@
 
 This is an autogenerated article holding stats about this wiki.
 
-- number of articles: 588
+- number of articles: 589
-- number of commits: 861
+- number of commits: 862
-- total size of all texts in bytes: 4201344
+- total size of all texts in bytes: 4227365
-- total number of lines of article texts: 31851
+- total number of lines of article texts: 32048
 - number of script lines: 262
 - occurences of the word "person": 7
 - occurences of the word "nigger": 91
@@ -35,99 +35,100 @@ longest articles:
 
 top 50 5+ letter words:
 
-- which (2375)
+- which (2387)
-- there (1827)
+- there (1836)
-- people (1626)
+- people (1633)
-- example (1396)
+- example (1409)
-- other (1296)
+- other (1303)
-- number (1173)
+- number (1197)
-- software (1144)
+- software (1143)
-- about (1125)
+- about (1135)
-- program (944)
+- program (948)
-- because (884)
+- because (886)
-- their (877)
+- their (882)
-- would (874)
+- would (878)
-- called (816)
+- called (822)
-- being (801)
+- being (804)
-- things (796)
+- language (798)
-- something (792)
+- things (795)
-- language (785)
+- something (795)
-- numbers (768)
+- numbers (778)
-- simple (750)
+- simple (749)
-- computer (750)
+- computer (749)
-- without (710)
+- without (713)
-- programming (694)
+- programming (702)
-- function (686)
+- function (698)
-- these (678)
+- these (679)
-- different (658)
+- different (665)
-- however (653)
+- however (659)
-- system (623)
+- system (629)
-- world (614)
+- world (619)
-- should (603)
+- doesn (609)
-- doesn (601)
+- should (605)
 - point (586)
+- while (581)
 - games (578)
-- society (574)
+- society (576)
-- while (570)
 - drummyfish (549)
-- though (543)
+- simply (548)
-- simply (543)
+- though (546)
-- using (538)
+- using (544)
-- still (535)
+- still (540)
-- possible (527)
+- possible (530)
-- memory (519)
+- memory (520)
-- similar (511)
+- similar (515)
-- https (507)
+- https (510)
-- course (504)
+- course (503)
+- value (496)
 - technology (496)
-- basically (483)
+- always (484)
-- always (481)
+- basically (480)
-- value (479)
+- really (472)
-- really (473)
+- first (462)
-- first (457)
 
 latest changes:
 
 ```
-Date:   Mon Aug 12 13:51:40 2024 +0200
+Date:   Thu Aug 15 12:41:06 2024 +0200
-  c.md
+  bloat.md
-  encyclopedia.md
+  censorship.md
-  exercises.md
+  consumerism.md
-  faq.md
+  cpp.md
+  determinism.md
+  devuan.md
+  digital_signature.md
+  diogenes.md
+  drummyfish.md
+  faggot.md
   forth.md
+  information.md
+  internet.md
+  ioccc.md
+  island.md
+  javascript.md
+  john_carmack.md
   jokes.md
-  lrs.md
+  just_werks.md
-  main.md
+  kids_these_days.md
+  kwangmyong.md
+  lambda_calculus.md
+  left_right.md
   minimalism.md
-  oop.md
+  money.md
-  people.md
+  often_confused.md
   programming_language.md
+  proprietary.md
+  quine.md
   random_page.md
-  steve_jobs.md
+  rgb565.md
+  stereotype.md
+  wavelet_transform.md
   wiki_pages.md
   wiki_stats.md
-  woman.md
+  wiki_style.md
-Date:   Thu Aug 8 22:37:16 2024 +0200
+  www.md
-  acronym.md
+  zero.md
-  bloat.md
+Date:   Mon Aug 12 13:51:40 2024 +0200
-  bootstrap.md
-  c.md
-  comun.md
-  duskos.md
-  faq.md
-  forth.md
-  gui.md
-  idiot_fallacy.md
-  lrs.md
-  lrs_dictionary.md
-  people.md
-  programming_language.md
-  random_page.md
-  teletext.md
-  trolling.md
-  unix_philosophy.md
-  viznut.md
-  wiki_pages.md
 ```
 
 most wanted pages:
@@ -135,7 +136,6 @@ most wanted pages:
 - [data_type](data_type.md) (14)
 - [irl](irl.md) (12)
 - [embedded](embedded.md) (12)
-- [lisp](lisp.md) (11)
 - [cli](cli.md) (11)
 - [buddhism](buddhism.md) (11)
 - [array](array.md) (11)
@@ -144,46 +144,47 @@ most wanted pages:
 - [meme](meme.md) (10)
 - [drm](drm.md) (10)
 - [complex_number](complex_number.md) (10)
+- [pointer](pointer.md) (9)
 - [syntax](syntax.md) (8)
 - [sdl](sdl.md) (8)
-- [pointer](pointer.md) (8)
-- [html](html.md) (8)
 - [gpu](gpu.md) (8)
 - [gpl](gpl.md) (8)
-- [cryptography](cryptography.md) (8)
+- [emacs](emacs.md) (8)
 - [comun_shell](comun_shell.md) (8)
+- [war](war.md) (7)
+- [waiver](waiver.md) (7)
 
 most popular and lonely pages:
 
-- [lrs](lrs.md) (293) 
+- [lrs](lrs.md) (294) 
-- [capitalism](capitalism.md) (239) 
+- [capitalism](capitalism.md) (241) 
-- [c](c.md) (219) 
+- [c](c.md) (221) 
-- [bloat](bloat.md) (210) 
+- [bloat](bloat.md) (214) 
 - [free_software](free_software.md) (176) 
 - [game](game.md) (141) 
-- [suckless](suckless.md) (139) 
+- [suckless](suckless.md) (140) 
-- [proprietary](proprietary.md) (122) 
+- [proprietary](proprietary.md) (123) 
 - [computer](computer.md) (98) 
 - [kiss](kiss.md) (97) 
 - [modern](modern.md) (95) 
-- [minimalism](minimalism.md) (93) 
+- [minimalism](minimalism.md) (95) 
+- [linux](linux.md) (92) 
 - [gnu](gnu.md) (91) 
-- [linux](linux.md) (90) 
+- [programming](programming.md) (86) 
-- [programming](programming.md) (85) 
 - [censorship](censorship.md) (85) 
 - [fun](fun.md) (84) 
-- [free_culture](free_culture.md) (81) 
+- [free_culture](free_culture.md) (82) 
 - [fight_culture](fight_culture.md) (81) 
 - [less_retarded_society](less_retarded_society.md) (80) 
-- [math](math.md) (77) 
+- [hacking](hacking.md) (80) 
-- [hacking](hacking.md) (77) 
+- [bullshit](bullshit.md) (80) 
-- [bullshit](bullshit.md) (77) 
+- [math](math.md) (79) 
+- [art](art.md) (77) 
 - [shit](shit.md) (76) 
 - [public_domain](public_domain.md) (76) 
-- [art](art.md) (76) 
+- [programming_language](programming_language.md) (75) 
 - [foss](foss.md) (75) 
-- [programming_language](programming_language.md) (73) 
+- [corporation](corporation.md) (73) 
-- [corporation](corporation.md) (72) 
 - [chess](chess.md) (71) 
 - ...
 - [anal_bead](anal_bead.md) (5)