Update

100r.md

@@ -1,3 +1,3 @@
 # Hundred Rabbits
 
-These motherfuckers are [toxic](toxic.md) [SJWs](sjw.md), avoid them like the devil. For now see [xxiivv](xxiivv.md).
+More like hundred retards :D These bitches are [toxic](toxic.md) as fuck [SJWs](sjw.md), avoid them at any cost. For more detail see [xxiivv](xxiivv.md).

books.md

@@ -22,6 +22,7 @@ Here there will be a constantly WIP list of [books](book.md) that might be of in
 - **Masters of Doom** (Kushner, 2003): Another nice book for [Doom](doom.md) fans, this time not really technical but rather just retelling the story of the game's development -- quite comfy, a lot if interesting trivia.
 - **[The Jargon File](jargon_file.md)** (1975...): [Hacker culture](hacking.md) dictionary, a lot of wisdom, inside jokes, and things related to oldschool hacking.
 - **Rebel Code** (Moody, 2001): A bit of a mainstream view at the whole "[open source](open_source.md)" history -- though it's a small brain business view which we have to keep in mind at all times, it's a nice introduction to the whole FOSS world for the newcomers, as the book covers most of the relevant projects and [people](people.md).
+- **Starting Forth** (Leo Brodie, 1981): Good book to learn [Forth](forth.md).
 - **The Chrysalids** (John Wyndham, 1955): Apocalyptic sci-fi about a middle-age-like deeply religious dystopia after a nuclear war, it's among the author's best works.
 - **The Country of the Blind** by H. G. Wells (1911): Very nice story, also in the public domain and digitized online, easily accessible. Though not related to technology, it's a great food for thought as it entertains an idea of a population of people who are completely blind which has interesting implications for their lives, and furthermore it shows that if you place someone too competent in a group of retards, they won't recognize his competence, in fact they'll see him as someone yet more retarded than they are themselves.
 - **The Nostalgia Nerd's Retro Tech**: Nice small database of all the old consoles/computers (SNES, Amiga, C64, ...), each one with high quality photos, short summary, specs and notable games. There is not much text, it's more like tl;drs of the most important stuff, it's an ideal overview of the old computers for a newcomers but can also serve as a quick reference to anyone.

c.md

@@ -89,7 +89,7 @@ enter a number: 7
 (7)
 enter a number: 0
 (0)
-enter a number: 4
+enter a number: 15
 ((5) 15 (3))
 enter a number: quit
 ```

consumerism.md

@@ -1,6 +1,8 @@
 # Consumerism
 
-Consumerism is [cancer](cancer.md) of society created by [capitalism](capitalism.md), it is the societal tendency towards and force established [culture](culture.md) of making members of society into mere slaves that have to constantly keep consuming products and services just for the sake of keeping bullshit businesses running. Consumers have to stand with open mouths at the end of [producer](productivity_cult.md) asses that are constantly shitting out new and new excrement, and this process must never stop. This soon degenerates into such things as [artificial scarcity](artificial_scarcity.md) and [planned obsolescence](planned_obsolescence.md), things that could last long must be made so that they will NOT last long, they must break soon so that the user has to consume a new one periodically, just like he consumes food, because that's what makes the [corporation](corporation.md) most money. So people are consuming computers, cars, swimming pools, cell phones, doctors, political drama, healthcare, things that make them sick, thing that make them healthy again, and so on and so forth. Even things that could be made to last long, such as buildings, or even forever, such as discovered [information](information.md) -- e.g. old books -- are artificially killed (for example using [copyright](copyright.md)), so that new ones have to be made so that people can keep having [jobs](work.md) and be miserable and don't have to lie on the beach and be happy. Businesses that would want to create non-consumerist products cannot exist -- a business that sells a thing that lasts 100 years will have to wait 100 years to sell another one, so naturally there is no chance for it to survive among those that make it so that they're selling the same thing each half a year, that's why consumerism in capitalism is unavoidable: it simply pays off, it makes the company rich and the richer company survives. Of course this is all pure [bullshit](bullshit.md) that wastes lives of people, makes them miserable consuming machines that get depressed and commit suicides, while also creating enormous amounts of waste that are destroying the environment, just capitalism as usual. Under consumerism your life is expected to go like this: be born, consume, die.
+Consumerism is [cancer](cancer.md) of society created by [capitalism](capitalism.md), it is the societal tendency towards and force established [culture](culture.md) of making members of society into mere slaves that have to constantly keep consuming products and services just for the sake of keeping bullshit businesses running. Consumers have to stand with open mouths at the end of [producer](productivity_cult.md) asses that are constantly shitting out new and new excrement, and this process must never stop. This soon degenerates into such things as **[artificial scarcity](artificial_scarcity.md)** and **[planned obsolescence](planned_obsolescence.md)**, things that could last long must be made so that they will NOT last long, they must break soon so that the user has to consume a new one periodically, just like he consumes food, because that's what makes the [corporation](corporation.md) most money. So people are consuming computers, cars, swimming pools, cell phones, doctors, political drama, healthcare, things that make them sick, thing that make them healthy again, and so on and so forth. Even things that could be made to last long, such as buildings, or even forever, such as discovered [information](information.md) -- e.g. old books -- are artificially killed (for example using [copyright](copyright.md)), so that new ones have to be made so that people can keep having [jobs](work.md) and be miserable and don't have to lie on the beach and be happy. Businesses that would want to create non-consumerist products cannot exist -- a business that sells a thing that lasts 100 years will have to wait 100 years to sell another one, so naturally there is no chance for it to survive among those that make it so that they're selling the same thing each half a year, that's why consumerism in capitalism is unavoidable: it simply pays off, it makes the company rich and the richer company survives. Of course this is all pure [bullshit](bullshit.md) that wastes lives of people, makes them miserable consuming machines that get depressed and commit suicides, while also creating enormous amounts of waste that are destroying the environment, just capitalism as usual. Under consumerism your life is expected to go like this: be born, consume, die.
+
+Consumerism is additionally pushed by capitalists by many other means, for instance by psychological pressure such as extreme [marketing](marketing.md) that constantly creates artificial trends, hypes and fashion waves, or by economic means such as [inflation](inflation.md) created by printing money -- this is a simple trick for a state (nowadays controlled by [corporations](corporation.md)) to take away money from people so that people can do nothing about it, and this is how capitalism makes it impossible to save money: once you try to save money, it simply loses its value and you end up with nothing, so you're forced to immediately spend any money that you make. You must not stop, just consume, work, consume and work -- people that don't want to engage in this cycle are unwanted by the system and left to starve.
 
 If you don't want to consume, you made a very big mistake by being born in [21st century](21st_century.md).
 

fixed_point.md

@@ -1,6 +1,6 @@
 # Fixed Point
 
-Fixed point arithmetic is a simple and often [good enough](good_enough.md) method of computer representation of [fractional](rational_number.md) numbers (i.e. numbers with higher precision than [integers](integer.md), e.g. 4.03), as opposed to [floating point](float.md) which is a more complicated way of doing this which in most cases we consider a worse, [bloated](bloat.md) alternative. Probably in 99% cases when you think you need floating point, fixed point will do just fine. Fixed point arithmetic is not to be [confused](often_confused.md) with fixed point of a function in mathematics (fixed point of a function *f(x)* is such *x* that *f(x) = x*), a completely unrelated term.
+Fixed point arithmetic is a simple and often [good enough](good_enough.md) method of computer representation of [fractional](rational_number.md) numbers (i.e. numbers with higher precision than [integers](integer.md), e.g. 4.03), as opposed to [floating point](float.md) which is a more complicated way of doing this which in most cases we consider a worse, [bloated](bloat.md) alternative. Probably in 99% cases when you think you need floating point, fixed point will do just fine (this is also advocated e.g. in the book *Starting Forth*). Fixed point arithmetic is not to be [confused](often_confused.md) with fixed point of a function in mathematics (fixed point of a function *f(x)* is such *x* that *f(x) = x*), a completely unrelated term.
 
 Fixed point has at least these advantages over floating point:
 

forth.md

@@ -10,21 +10,25 @@ Forth ("fourth generation" shortened to four characters due to technical limitat
 
 It is usually presented as [interpreted](interpreter.md) language but may as well be [compiled](compiler.md), in fact it maps pretty nicely to [assembly](assembly.md). Even if interpreted, it can still be very fast. Forth systems traditionally include not just a compiler/interpreter but also an **interactive environment**, kind of [REPL](repl.md) language shell.
 
-There are several Forth standards, most notably ANSI 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.
+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 to the older one.
 
 A [free](free_software.md) implementation is e.g. GNU Forth ([gforth](gforth.md)) or [pforth](pforth.md) (a possibly better option by LRS standards, favors [portability](portability.md) over performance).
 
-Forth was invented by Charles Moore in 1968, for programming radio telescopes.
+There is a book called **Starting Forth** that's freely downloadable and quite good at teaching the language.
+
+Forth was invented by [Charles Moore](charles_moore.md) (NOT the one of the [Moore's Law](moores_law.md) though) in 1968, for programming radio telescopes.
 
 ## Language
 
 Forth is case-insensitive (this may however not be the case in some implementations).
 
-The language operates on an evaluation **[stack](stack.md)**: e.g. the operation + takes the two values at the top of the stack, adds them together and pushed the result back on the stack. Besides this there are also some "advanced" features like variables living outside the stack, if you want to use them.
+The language operates on an evaluation **[stack](stack.md)**: e.g. the operation + takes the two values at the top of the stack, adds them together and pushed the result back on the stack (i.e. for example `1 2 +` in Forth is the same as `1 + 2` in C). Besides this there are also some "advanced" features like variables living outside the stack, if you want to use them.
 
-The stack is composed of **cells**: the size and internal representation of the cell is implementation defined. There are no data types, or rather everything is just of type signed int.
+In fact there are two stacks in Forth: the **parameter stack** (also data stack) and **return stack**. Parameter stack is the "normal" stack on which we do most computations and on which we pass parameters and return values. Returns stack is the stack on which return addresses are stored, BUT it is also used as a temporary stack so that we can let's say put aside a few values to dive deeper on the main stack, however this has to be done carefully -- before end of word ("function") is reached, the return stack must be restored to the original state of course.
 
-Basic [abstraction](abstraction.md) of Forth is so called **word**: a word is simply a string without spaces like `abc` or `1mm#3`. A word represents some operation on stack (and possible other effect such as printing to the console), for example the word `1` adds the number 1 on top of the stack, the word `+` performs the addition on top of the stack etc. The programmer can define his own words which can be seen as "[functions](function.md)" or rather procedures or macros (words don't return anything or take any arguments, they all just invoke some operations on the stack). A word is defined like this:
+The stack is composed of **cells**: the size of the cell is implementation defined. The values stored in cells are just binary, they don't have any data type, so whether a value in given cell is considered signed or unsigned is up to the programmer -- some operators treat numbers as signed and some as unsigned (just like in [comun](comun.md)); note that with many operators the distinction doesn't matter (e.g. addition doesn't care if the numbers are signed or not, but comparison does).
+
+Basic [abstraction](abstraction.md) of Forth is so called **word**: a word is simply a string without spaces like `abc` or `1mm#3`. A word represents simply some operations, which may include running native code, pushing numbers on stack or calling other words, for example the word the word `+` performs the addition on top of the stack, `dup` duplicates the top of the stack etc. The programmer can define his own words -- so words are basically kind of "[functions](function.md)" or rather procedures (however words don't return anything or take any arguments in traditional way, they all just invoke some operations -- arguments and return values are passed using the stack). Defining new words expands the current **dictionary**, so Forth basically extends itself as it's running. A word is defined like this:
 
 ```
 : myword operation1 operation2 ... ;
@@ -36,33 +40,47 @@ For example a word that computes and average of the two values on top of the sta
 : average + 2 / ;
 ```
 
-Built-in words include:
+Forth programmers use so called **stack notation** to document the function's "signature", i.e. what it does with the stack -- they write this notation in a comment above a defined word to signify 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 built-in words include:
 
 ```
 GENERAL:
 
-+           add                       a b -> (a + b)
++           add                     ( a b -- [a+b] )
--           subtract                  a b -> (a . b)
+-           subtract                ( a b -- [a-b] )
-*           multiply                  a b -> (a * b)
+*           multiply                ( a b -- [a*b] )
-/           divide                    a b -> (a / b)
+/           divide                  ( a b -- [a/b] )
-=           equals                    a b -> (-1 if a = b else 0)
+=           equals                  ( a b -- [-1 if a = b else 0] )
-<           less than                 a b -> (-1 if a < b else 0)
+<>          not equals              ( a b -- [-1 if a != b else 0] )
->           greater than              a b -> (-1 if a > b else 0)
+<           less than               ( a b -- [-1 if a < b else 0] )
-mod         modulo                    a b -> (a % b)
+>           greater than            ( a b -- [-1 if a > b else 0] )
-dup         duplicate                   a -> a a
+mod         modulo                  ( a b -- [a % b] )
-drop        pop stack top               a ->
+dup         duplicate                 ( a -- a a )
-swap        swap items                a b -> b a
+drop        pop stack top             ( a -- )
-rot         rotate 3                a b c -> b c a
+swap        swap items              ( a b -- b a )
-pick        push Nth item     xN ... x0 N -> ... x0 xN
+rot         rotate 3              ( a b c -- b c a )
-.           print top & pop
+pick        push Nth item   ( xN ... x0 N -- ... x0 xN )
+.           pop & print number as signed
+u.          pop & print number as unsigned
 key         read char on top
 .s          print stack
-emit        print char & pop
+emit        pop & print top as char
 cr          print newline
-cells       times cell width            a -> (a * cell width in bytes)
+cells       times cell width          ( a -- [a * cell width in bytes] )
-depth       pop all & get d.        a ... -> (previous stack size)
+depth       pop all & get d.      ( a ... -- [previous stack size] )
+quit        don't print "ok" at the end of execution
 bye         quit
 
+RETURN STACK:
+
+>r          pops value, pushed it to return stack
+r>          pops value from return stack, pushes it
+r@          pushes value from return stack (doesn't pop it)
+i           pushes value from return stack (without pop)
+i'          pushes second value from return stack (without pop)
+j           pushes third value from return stack (without pop)
+
 VARIABLES/CONSTS:
 
 variable X      creates var named X (X is a word that pushed its addr)
@@ -74,18 +92,21 @@ C               pushes the value of constant C
 
 SPECIAL:
 
-( )                   comment (inline)
+( )                       comment (inline)
-\                     comment (until newline)
+\                         comment (until newline)
-." S "                print string S
+." S"                     print string S (compiles in the string)
-X if C then           if X, execute C // only in word def.
+X if C then               if X, execute C (only in word def., X is popped)
-X if C1 else C2 then  if X, execute C1 else C2 // only in word def.
+X if C1 else C2 then      if X, execute C1 else C2 (only in word def.)
-do C loop             loops from stack top value to stack second from,
+do C loop                 loops from stack top value to stack second from,
-                      top, special word "i" will hold the iteration val.
+                          top, special word "i" will hold the iteration val.
-begin C until         like do/loop but keeps looping as long as top = 0
+begin C until             like do/loop but keeps looping as long as top = 0
-begin C while         like begin/until but loops as long as top != 0
+begin C while             like begin/until but loops as long as top != 0
-allot                 allocates memory, can be used for arrays
+begin C again             infinite loop
-recurse               recursively call the word currently being defined
+begin C1 while C2 repeat  loop with middle condition
-
+leave                     loop break (only for counted loops)
+allot                     allocates memory, can be used for arrays
+recurse                   recursively call the word currently being defined
+see W                     shows the definition of word W
 ```
 
 example programs:
@@ -102,6 +123,89 @@ cr ." hey bitch " cr \ prints: hey bitch
 : myloop 5 0 do i . loop ; myloop \ prints 0 1 2 3 4
 ```
 
+TODO: local variables, addresses
+
+## Examples
+
+Here is our standardized **[divisor tree](divisor_tree.md)** program written in Forth:
+
+```
+\ takes x, pops it and recursively prints its divisor tree
+: printdivisortree
+  dup 3 <= if
+    0 swap 1 swap          \ stack now: 0 1 x
+  else
+    >r 0 1 r>              \ stack now: a b x
+
+    dup 2 / 1 + 2 do       \ find the closest divisors (a, b)
+      dup i mod 0 = if     \ i divides x?
+        2 pick 2 pick < if \ a < b?
+          i
+          swap
+          >r               \ use return stack for tmp storage
+          swap drop
+          swap drop
+          dup r@ swap /
+          r>
+        then
+      then
+    loop
+  then
+
+  ." ( "
+
+  2 pick 0 <> if           \ divisors found?
+    2 pick recurse
+    dup .
+    1 pick recurse
+  else
+    dup .
+  then
+
+  ." ) "
+
+  drop drop drop
+;
+
+: digittonum
+  dup dup 48 >= swap 57 <= and if
+    48 -
+  else
+    drop -1
+  then
+;
+
+: main
+  begin \ main loop, read numbers from user
+    0
+    begin
+      key
+
+      dup 13 <> while \ newline?
+
+      digittonum
+
+      dup -1 = if
+        bye
+      then
+
+      swap 10 * +
+    repeat
+
+    drop \ key
+
+    dup 1000 < if
+      printDivisorTree cr
+    else
+      bye
+    then
+  again
+;
+
+main
+bye
+```
+
 ## How To
 
 Source code files usually have `.fs` extension. We can use mentioned gforth to run our files. Let's create file `my.fs`; in it we write: { Hope the code is OK, I never actually programmed in Forth before. ~drummyfish }

gui.md

@@ -2,9 +2,9 @@
 
 "*Always  add a commandline interface to your software. Graphical User interfaces are for sissies.*" --[bitreich](bitreich.md) manifesto
 
-Graphical user interface (GUI) is a visual [user interface](ui.md) that uses graphics such as images and geometrical shapes. This stands in contrast with [text user interface](tui.md) (TUI) which is also visual but only uses text for communication.
+Graphical user interface (GUI) is a visual [user interface](ui.md) that uses graphical elements such as images, many distinct [colors](color.md) and fine geometrical shapes. This stands in contrast with [text user interface](tui.md) (TUI) which is also visual but only uses text for communication (TUI can further be pure line-based [command line interface](cli.md) or a graphical, grid-based text interface that mimics a true GUI, e.g. with [ASCII art](ascii_art.md)).
 
-Expert computer users normally frown upon GUI because it is the "noobish", inefficient, limiting, cumbersome, hard to automate way of interacting with computer. GUI brings [complexity](complexity.md) and [bloat](bloat.md), they are slow, inefficient and distracting. We try not to use them and prefer the [command line](cli.md).
+Expert computer users normally frown upon GUI because it is the "noobish", inefficient, limiting, cumbersome, hard to automate, [capitalist](capitalism.md) consumer-style way of interacting with computer. GUI brings [complexity](complexity.md) and [bloat](bloat.md), they are slow, inefficient, distracting, hard to automatize and test. GUI is like baby pictures or simple books with pictures for [illiterate people](plan9.md) and Chimpanzees, for people who need to click on boxes and have flashing strip club colors to keep them entertained, while command line is for normal adults who can read and want to do thing efficiently -- there is a reason why [programming languages](programming_language.md) are plain text (with exception of the ones literally aimed at babies in kindergarden). [Text is universal interface](unix_philosophy.md). So we try not to use GUIs and prefer the [command line](cli.md).
 
 "[Modern](modern.md)" GUIs mostly use [callback](callback.md)-based programming, which again is more complicated than standard polling non-interactive I/O. If you need to do GUI, just use a normal infinite loop FFS.
 

javascript.md

@@ -27,7 +27,6 @@ Below is our standardized [divisor tree](divisor_tree.md) program written in bro
 function divisorTreeStr(x)
 {
   let a = -1, b = -1;
-  let s = "";
 
   for (let i = 2; i <= x / 2; i++) // find closest divisors
     if (x % i == 0)
@@ -37,14 +36,10 @@ function divisorTreeStr(x)
 
       if (b <= a)
         break;
-    }  
+    }
 
-  s += "("
+  return "(" + (a > 1 ? divisorTreeStr(a) + " " + x + " " +
-
+    divisorTreeStr(b) : x) + ")";
-  s += a > 1 ?
-    divisorTreeStr(a) + " " + x + " " + divisorTreeStr(b) : x;
-
-  return s + ")";
 }
 
 function main()

kiss.md

@@ -22,6 +22,7 @@ Apparently the term *KISS* originated in the US Army plane engineering: the plan
 - Using a trivial [shell](shell.md) script for compiling your programs rather than a complex build system such as [CMake](cmake.md).
 - Using [ASCII art](ascii_art.md) instead of bitmap images.
 - [Beatboxing](beatbox.md) to produce a back track for rap songs, as opposed to using (or even paying for) some kind of music software.
+- Using hammock instead of bed -- it is much simpler, cheaper, portable and has an extra swinging feature for which it is considered by many to even be superior in terms of comfort.
 - In the world of [coffee](coffee.md) so called *Turkish coffee* without any milk and sugar is probably the most KISS option, you just put coffee ground in a mug and pour hot water on it. Compare this to Espresso with milk and sugar which needs a quite complex and expensive machine. { Yeah, I drink the most KISS coffee, though sometimes I also use French press -- that one is still quite simple. ~drummyfish }
 - ...
 

programming_language.md

@@ -112,48 +112,48 @@ Judging languages may further be complicated by the question of what the languag
 
 Here is a table of notable programming languages in chronological order (keep in mind a language usually has several versions/standards/implementations, this is just an overview).
 
-| language                | minimalist/good? | since | speed   | mem.     | ~min. selfhos. impl. LOC |spec. (~no stdlib pages)|           notes                                                         |
+| language                | minimalist/good? | since | speed   | mem.     | ~min. selfhos. impl. LOC |DT LOC|spec. (~no stdlib pages)|           notes                                                         |
-| ----------------------- | ---------------- | ----- | ------- | -------- | ------------------------ | ---------------------- | ----------------------------------------------------------------------- |
+| ----------------------- | ---------------- | ----- | ------- | -------- | ------------------------ | ---- | ---------------------- | ----------------------------------------------------------------------- |
-|"[assembly](assembly.md)"| **yes but...**   | 1947? |         |          |                          |                        | NOT a single language, non-[portable](portability.md)                   |
+|"[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         |
+| [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)         | **yes**          | 1958  | 3.29 (G)| 18 (G)   | 100 (judg. by jmc lisp)  |      | 1?                     | elegant, KISS, functional, many variants (Common Lisp, Closure, ...)    |
-| [Basic](basic.md)       | kind of?         | 1964  |         |          |                          |                        | mean both for beginners and professionals, probably efficient           |
+| [Basic](basic.md)       | kind of?         | 1964  |         |          |                          |      |                        | mean both for beginners and professionals, probably efficient           |
-| [Forth](forth.md)       | **yes**          | 1970  |         |          | 100 (judg. by milliforth)| 1                      | [stack](stack.md)-based, elegant, very KISS, interpreted and compiled   |
+| [Forth](forth.md)       | **yes**          | 1970  |         |          | 100 (judg. by milliforth)| 74   | 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                     |
+| [Pascal](pascal.md)     | **kind of**      | 1970  | 5.26 (G)| 2.11 (G) |                          |      | 80, proprietary (ISO)  | like "educational C", compiled, not so bad actually                     |
-| **[C](c.md)**           | **kind of**      | 1972  | 1.0     | 1.0      | 10K? (judg. by chibicc)  | 160, proprietary (ISO) | compiled, fastest, efficient, established, suckless, low-level, #1 lang.|
+| **[C](c.md)**           | **kind of**      | 1972  | 1.0     | 1.0      | 10K? (judg. by chibicc)  | 49   | 160, proprietary (ISO) | compiled, fastest, efficient, established, suckless, low-level, #1 lang.|
-| [Prolog](prolog.md)     | maybe?           | 1972  |         |          |                          |                        | [logic](logic.md) paradigm, hard to learn/use                           |
+| [Prolog](prolog.md)     | maybe?           | 1972  |         |          |                          |      |                        | [logic](logic.md) paradigm, hard to learn/use                           |
-|[Smalltalk](smalltalk.md)| **quite yes**    | 1972  | 47 (G)  | 41 (G)   |                          | 40, proprietary (ANSI) | PURE (bearable kind of) [OOP](oop.md) language, pretty minimal          |
+|[Smalltalk](smalltalk.md)| **quite yes**    | 1972  | 47 (G)  | 41 (G)   |                          |      | 40, proprietary (ANSI) | PURE (bearable kind of) [OOP](oop.md) language, pretty minimal          |
-| [C++](cpp.md)           | no, bearable     | 1982  | 1.18 (G)| 1.27 (G) |                          | 500, proprietary       | bastard child of C, only adds [bloat](bloat.md) ([OOP](oop.md)), "games"|
+| [C++](cpp.md)           | no, bearable     | 1982  | 1.18 (G)| 1.27 (G) |                          |      | 500, proprietary       | bastard child of C, only adds [bloat](bloat.md) ([OOP](oop.md)), "games"|
-| [Ada](ada.md)           | ???              | 1983  |         |          |                          |                        | { No idea about this, sorry. ~drummyfish }                              |
+| [Ada](ada.md)           | ???              | 1983  |         |          |                          |      |                        | { No idea about this, sorry. ~drummyfish }                              |
-| Object Pascal           | no               | 1986  |         |          |                          |                        | Pascal with OOP (like what C++ is to C), i.e. only adds bloat           |
+| Object Pascal           | no               | 1986  |         |          |                          |      |                        | Pascal with OOP (like what C++ is to C), i.e. only adds bloat           |
-| Objective-C             | probably not     | 1986  |         |          |                          |                        | kind of C with Smalltalk-style "pure" objects?                          |
+| Objective-C             | probably not     | 1986  |         |          |                          |      |                        | kind of C with Smalltalk-style "pure" objects?                          |
-| [Oberon](oberon.md)     | kind of?         | 1987  |         |          |                          |                        | simplicity as goal, part of project Oberon                              |
+| [Oberon](oberon.md)     | kind of?         | 1987  |         |          |                          |      |                        | simplicity as goal, part of project Oberon                              |
-| [Perl](perl.md)         | rather not       | 1987  | 77 (G)  | 8.64 (G) |                          |                        | interpreted, focused on strings, has kinda cult following               |
+| [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     |
+| [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                       |
+| [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) |                          |      | 200? (p. lang. ref.)   | interpreted, huge bloat, slow, lightweight OOP, artificial obsolescence |
-| POSIX [shell](shell.md) | well, "kind of"  | 1992  |         |          |                          | 50, proprietary (paid) | standardized (std 1003.2-1992) Unix shell, commonly e.g. [Bash](bash.md)|
+| 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)|
-|[Brainfuck](brainfuck.md)| **yes**          | 1993  |         |          | 100 (judg. by dbfi)      | 1                      | extremely minimal (8 commands), hard to use, [esolang](esolang.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               |
+| [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)          |
+| [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)          |
-| [Java](java.md)         | NO               | 1995  | 2.75 (G)| 21.48 (G)|                          | 800, proprietary       | forced [OOP](oop.md), "platform independent" (bytecode), slow, bloat    |
+| [Java](java.md)         | NO               | 1995  | 2.75 (G)| 21.48 (G)|                          |      | 800, proprietary       | forced [OOP](oop.md), "platform independent" (bytecode), slow, bloat    |
-| [JavaScript](js.md)     | NO               | 1995  | 8.30 (G)| 105 (G)  | 50K (est. from QuickJS)  | 500, proprietary?      | interpreted, the [web](web.md) lang., bloated, classless [OOP](oop.md)  |
+| [JavaScript](js.md)     | NO               | 1995  | 8.30 (G)| 105 (G)  | 50K (est. from QuickJS)  | 34   | 500, proprietary?      | interpreted, the [web](web.md) lang., bloated, classless [OOP](oop.md)  |
-| [PHP](php.md)           | no               | 1995  | 23 (G)  | 6.73 (G) |                          | 120 (by Google), CC0   | server-side web lang., OOP                                              |
+| [PHP](php.md)           | no               | 1995  | 23 (G)  | 6.73 (G) |                          |      | 120 (by Google), CC0   | server-side web lang., OOP                                              |
-| [Ruby](ruby.md)         | no               | 1995  | 122 (G) | 8.57 (G) |                          |                        | similar to Python                                                       |
+| [Ruby](ruby.md)         | no               | 1995  | 122 (G) | 8.57 (G) |                          |      |                        | similar to Python                                                       |
-| [C#](c_sharp.md)        | NO               | 2000  | 4.04 (G)| 26 (G)   |                          |                        | proprietary (yes it is), extremely bad lang. owned by Micro$oft, AVOID  |
+| [C#](c_sharp.md)        | NO               | 2000  | 4.04 (G)| 26 (G)   |                          |      |                        | proprietary (yes it is), extremely bad lang. owned by Micro$oft, AVOID  |
-| [D](d.md)               | no               | 2001  |         |          |                          |                        | some expansion/rework of C++? OOP, generics etcetc.                     |
+| [D](d.md)               | no               | 2001  |         |          |                          |      |                        | some expansion/rework of C++? OOP, generics etcetc.                     |
-| [Rust](rust.md)         | NO! lol          | 2006  | 1.64 (G)| 3.33 (G) |                          | 0 :D                   | extremely bad, slow, freedom issues, toxic community, no standard, AVOID|
+| [Rust](rust.md)         | NO! lol          | 2006  | 1.64 (G)| 3.33 (G) |                          |      | 0 :D                   | extremely bad, slow, freedom issues, toxic community, no standard, AVOID|
-| [Go](go.md)             | **kind of**      | 2009  | 4.71 (G)| 5.20 (G) |                          | 130, proprietary?      | "successor to C" but not well executed, bearable but rather avoid       |
+| [Go](go.md)             | **kind of**      | 2009  | 4.71 (G)| 5.20 (G) |                          |      | 130, proprietary?      | "successor to C" but not well executed, bearable but rather avoid       |
-| [LIL](lil.md)           | **yes**          | 2010? |         |          |                          |                        | not known too much but nice, "everything's a string"                    |
+| [LIL](lil.md)           | **yes**          | 2010? |         |          |                          |      |                        | not known too much but nice, "everything's a string"                    |
-| [uxntal](uxn.md)        | **yes** but SJW  | 2021  |         |          |  400 (official)          | 2? (est.), proprietary | assembly lang. for a minimalist virtual machine, PROPRIETARY SPEC.      |
+| [uxntal](uxn.md)        | **yes** but SJW  | 2021  |         |          | 400 (official)           |      | 2? (est.), proprietary | assembly lang. for a minimalist virtual machine, PROPRIETARY SPEC.      |
-| **[comun](comun.md)**   | **yes**          | 2022  |         |          | < 3K?                    | 2, CC0                 | "official" [LRS](lrs.md) language, WIP, similar to Forth                |
+| **[comun](comun.md)**   | **yes**          | 2022  |         |          | 4K                       | 76   | 2, CC0                 | "official" [LRS](lrs.md) language, WIP, similar to Forth                |
 
-NOTE on performance data: the `speed`/`mem.` column says a benchmarked estimate running time/memory consumption of the best case (best compiler, best run, ...) relateive to C (i.e. "how many times the language is worse than C"). The data may come from various sources, for example the *[The Computer Language Benchmark Game](https://sschakraborty.github.io/benchmark/task-descriptions.html)* (G), own measurement (O) etc.
+NOTES on the table above:
-
-NOTE on implementation size: this is just very rough estimate based on the smallest implementation found, sometimes guessed and rounded to some near value (for example finding a small implementation whose main goal isn't small size we may conclude it could be written yet a bit smaller).
-                                                               
-TODO: add "relative speed" column, make some kinda benchmark program and say how many times each languages is slower than C
 
+- performance data: the `speed`/`mem.` column says a benchmarked estimate running time/memory consumption of the best case (best compiler, best run, ...) relateive to C (i.e. "how many times the language is worse than C"). The data may come from various sources, for example the *[The Computer Language Benchmark Game](https://sschakraborty.github.io/benchmark/task-descriptions.html)* (G), own measurement (O) etc.
+- implementation size: this is just very rough estimate based on the smallest implementation found, sometimes guessed and rounded to some near value (for example finding a small implementation whose main goal isn't small size we may conclude it could be written yet a bit smaller).
+- DT LOC is the number of [lines of code](loc.md) of our standardized [divisor tree](divisor_tree.md) program at the time of writing this   
+                                                            
 TODO: Tcl, Rebol
 
 ## Interesting Languages

wiki_stats.md

@@ -3,9 +3,9 @@
 This is an autogenerated article holding stats about this wiki.
 
 - number of articles: 588
-- number of commits: 857
+- number of commits: 858
-- total size of all texts in bytes: 4173470
+- total size of all texts in bytes: 4180781
-- total number of lines of article texts: 31398
+- total number of lines of article texts: 31680
 - number of script lines: 262
 - occurences of the word "person": 7
 - occurences of the word "nigger": 91
@@ -21,8 +21,8 @@ longest articles:
 - [chess](chess.md): 56K
 - [faq](faq.md): 52K
 - [number](number.md): 52K
-- [programming_language](programming_language.md): 44K
 - [c](c.md): 44K
+- [programming_language](programming_language.md): 44K
 - [3d_model](3d_model.md): 40K
 - [bloat](bloat.md): 36K
 - [woman](woman.md): 36K
@@ -35,40 +35,40 @@ longest articles:
 
 top 50 5+ letter words:
 
-- which (2362)
+- which (2363)
-- there (1819)
+- there (1820)
-- people (1618)
+- people (1619)
-- example (1384)
+- example (1387)
-- other (1293)
+- other (1294)
-- number (1146)
+- number (1165)
 - software (1142)
-- about (1120)
+- about (1121)
-- program (929)
+- program (943)
 - because (880)
 - their (876)
-- would (871)
+- would (873)
-- called (812)
+- called (813)
-- being (800)
+- being (802)
 - things (794)
-- something (787)
+- something (791)
-- language (770)
+- language (772)
-- numbers (751)
+- numbers (757)
 - computer (750)
-- simple (745)
+- simple (746)
 - without (704)
-- programming (684)
+- programming (686)
-- function (676)
+- function (683)
 - these (675)
 - different (656)
 - however (648)
 - system (616)
 - world (613)
-- should (601)
+- should (602)
 - doesn (594)
 - point (584)
 - games (578)
-- society (573)
+- society (574)
-- while (560)
+- while (563)
 - drummyfish (548)
 - though (543)
 - simply (540)
@@ -89,6 +89,26 @@ top 50 5+ letter words:
 latest changes:
 
 ```
+Date:   Mon Aug 5 22:39:28 2024 +0200
+  ascii.md
+  c.md
+  censorship.md
+  comun.md
+  drummyfish.md
+  feminism.md
+  forth.md
+  island.md
+  javascript.md
+  kiss.md
+  main.md
+  pride.md
+  privacy.md
+  project.md
+  python.md
+  random_page.md
+  recursion.md
+  wiki_pages.md
+  wiki_stats.md
 Date:   Sun Aug 4 16:49:53 2024 +0200
   3d_rendering.md
   aliasing.md
@@ -108,26 +128,6 @@ Date:   Sun Aug 4 16:49:53 2024 +0200
   newspeak.md
   number.md
   political_correctness.md
-  public_domain.md
-  random_page.md
-  stereotype.md
-  trolling.md
-  wiki_pages.md
-  wiki_stats.md
-  wiki_style.md
-  woman.md
-  work.md
-Date:   Thu Aug 1 02:31:53 2024 +0200
-  21st_century.md
-  3d_rendering.md
-  42.md
-  cancel_culture.md
-  doom.md
-  duke3d.md
-  faq.md
-  interpolation.md
-  jokes.md
-  main.md
 ```
 
 most wanted pages:
@@ -169,12 +169,12 @@ most popular and lonely pages:
 - [minimalism](minimalism.md) (91) 
 - [gnu](gnu.md) (91) 
 - [linux](linux.md) (90) 
+- [censorship](censorship.md) (85) 
 - [programming](programming.md) (84) 
 - [fun](fun.md) (84) 
-- [censorship](censorship.md) (84) 
 - [free_culture](free_culture.md) (81) 
+- [less_retarded_society](less_retarded_society.md) (80) 
 - [fight_culture](fight_culture.md) (80) 
-- [less_retarded_society](less_retarded_society.md) (79) 
 - [math](math.md) (77) 
 - [hacking](hacking.md) (77) 
 - [bullshit](bullshit.md) (77) 
@@ -183,7 +183,7 @@ most popular and lonely pages:
 - [art](art.md) (76) 
 - [foss](foss.md) (75) 
 - [programming_language](programming_language.md) (72) 
-- [corporation](corporation.md) (70) 
+- [corporation](corporation.md) (71) 
 - [chess](chess.md) (70) 
 - ...
 - [anal_bead](anal_bead.md) (5) 

woman.md

@@ -1,5 +1,7 @@
 # <3 Woman <3
 
+{ Hello, if you're offended scroll down, I actually apologize to some women at the end :D ~drummyfish }
+
 A woman (also girl, gril, gurl, femoid, toilet, wimminz, the weaker sex, the dumber sex or succubus; [tranny](tranny.md) girl being called [t-girl](tgirl.md), troon, [trap](trap.md), [femboy](femboy.md), fake girl or [mtf](mtf.md)) is one of two genders ([sexes](sex.md)) of [humans](human.md), the other one being [man](man.md) -- traditionally woman is defined as that who was born with a vagina. Women are the weaker sex, they are [cute](cute.md) (sometimes) but notoriously bad at [programming](programming.md), [math](math.md) and [technology](technology.md): in the field they usually "work" on [bullshit](bullshit.md) (and mostly [harmful](harmful.md)) positions such as "diversity department", [marketing](marketing.md), "[HR](human_resources.md)", [UI](ui.md)/[user experience](ux.md), or as a [token](token.md) girl for media. If they get close to actual technology, their highest "skills" are mostly limited to casual "[coding](coding.md)" (which itself is a below-average form of [programming](programming.md)) in a baby language such as [Python](python.md), [Javascript](javascript.md) or [Rust](rust.md). Mostly they are just hired for quotas and make coffee for men who do the real work (until TV cameras appear). Don't let yourself be fooled by the propaganda, women have always been bad with tech. But indeed, very rarely a somewhat skilled woman may appear (we're not saying women can't be capable, just that they rarely are).
 
 The symbol for woman is a circle with cross at its bottom ([Unicode](unicode.md) U+2640). Women mostly like pink [color](color.md) and similar colors like red and purple.