Update

c.md

@@ -176,6 +176,7 @@ Now let's admit that nothing is [perfect](perfect.md), not even C; it was one of
 - **Some undefined/unspecified behavior is probably unnecessary** -- undefined behavior isn't bad in general of course, it is what allows C to be so fast and efficient in the first place, but some of it has shown to be rather cumbersome; for example the unspecified representation of integers, their binary size and behavior of floats leads to a lot of trouble (unknown upper bounds, sizes, dangerous and unpredictable behavior of many operators, difficult testing etc.) while practically all computers have settled on using 8 bit bytes, [two's complement](twos_complement.md) and IEEE754 for [floats](float.md) -- this could easily be made a mandatory assumption which would simplify great many things without doing basically any harm. New versions of C actually already settle on two's complement. This doesn't mean C should be shaped to reflect the degenerate "[modern](modern.md)" trends in programming though!
 - Some basic things that are part of libraries or extensions, like fixed width types and binary literals and possibly very basic I/O (putchar/readchar), could be part of the language itself rather than provided by libraries.
 - All that stuff with *.c* and *.h* files is unnecessary, there should just be one file type probably.
+- It's not [Forth](forth.md).
 - ...
 
 ## Basics

encyclopedia.md

@@ -56,7 +56,7 @@ Here is a list of notable encyclopedias, focused on general knowledge English la
 | The Nuttall Encyclopaedia      | 1907  | PD (old)         | 1 vol.      | 16K       | short articles, oldschool, digitized (gutenberg)                                                           |
 | [Vikidia](vikidia.md)          |2006...| CC BY-SA         | online      | 4K        | "Wikipedia for kids", probably as censored as Wikipedia                                                    |
 |Webster's Unabridged Dictionary |1864   | PD (old)         | paper       | 476K      | short descriptions, digitized (gutenberg)                                                                  |
-| [Wikidata](wikidata.md)        |2012...| Pd (CC0)         | online/elec.| 109M      | database, Wikipedia sister project                                                                         |
+| [Wikidata](wikidata.md)        |2012...| PD (CC0)         | online/elec.| 109M      | database, Wikipedia sister project                                                                         |
 | **[Wikipedia](wikipedia.md)**  |2001...| CC BY-SA         | online      | 6M        | largest and most famous, EXTREME PSEUDOLEFTIST CENSORSHIP AND POLITICAL PROPAGANDA, free culture           |
 | Wiktionary                     |2002...| CC BY-SA         | online      | 1M        | dictionary, Wikipedia's sister project, many language versions                                             |
 | Old Wikipedia                  | 2001  | GFDL             | online      | 19K       | archived old Wikipedia, less censorship, https://nostalgia.wikipedia.org                                   |

exercises.md

@@ -215,7 +215,8 @@ Bear in mind the main purpose of this quiz is for you to test your understanding
 108. Explain at least one of the following [chess](chess.md) concepts: fork, pin, smothered mate.
 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. Did you enjoy this quiz?
+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?
 
 ### Answers
 
@@ -330,7 +331,8 @@ sin(x) / cos(x) - log2(2) = tg(x) - 1*, so we get *tg(x) >= 1*. So that will hol
 108. Fork: attacking two (or more) pieces at once (often done with knight) so that the opponent can only save one. Pin: attacking a piece so that if it moves away, it will reveal another piece behind it to be taken (often pinning to king). Smothered mate: checkmate by knight in which king can't move anywhere because he's blocked by own pieces.
 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. yes
+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
 
 ## Other
 

faq.md

@@ -44,7 +44,7 @@ See the article on [less retarded society](less_retarded_society.md), it contain
 
 Well, firstly LRS by [anarchist](anarchism.md) principles avoids establishing a centralized community with things such as platforms, senior members, moderators, bureaucracy, codified rules etc. Every nice thing that went this way turned to shit once it became more popular and grew, corruption always appears and prevails (see [Wikipedia](wikipedia.md), [GNU](gnu.md)/[FSF](fsf.md), [Linux](linux.md) etc.). So we rather aim for a community of decentralized, loosely associated individuals and small entities with greatly overlapping sets of values rather than any organizations etc. So rather think something like many people with their own websites referring and linking to each other.
 
-At the moment this wiki/movement/ideology/etc. is basically me ([drummyfish](drummyfish.md)), with about one friend who I would say is a pure LRS supporter and AFAIK shares all the important views. There are a handful of people who told me they like this wiki a lot, share many of my views and values and who I am in regular contact with mostly over email. Then there are quite a few people who like this to various degree and contact me from time to time, many just write me a one time email, suggest something, thank me, suggest I kill myself etc. -- currently I would count these in dozens, from which I estimate there is a non-negligible number of lurkers (given that only 1 in relatively many readers will actually write me an email).
+At the moment this wiki/movement/ideology/etc. is basically me ([drummyfish](drummyfish.md)), and there are a few people around who agree more or less with me. There are quite a few people who like this to various degree and contact me from time to time, many just write me a one time email, suggest something, thank me, suggest I kill myself etc. -- currently I would count these in dozens, from which I estimate there is a non-negligible number of silent lurkers (given that only 1 in relatively many readers will actually write me an email).
 
 I don't have any web analytics set up, I could probably dig up at least number of site downloads or something but I don't even look at that, I don't want to aim for popularity.
 

forth.md

@@ -1,38 +1,40 @@
 # Forth
 
-{ I'm a bit ashamed but I'm not really "fluent" at Forth, I just played around with it for a bit. Yes, I'm planning to get into it more after I do the other million things on my TODO list. Let me know if there is some BS, thank u <3 ~drummyfish }
+{ I'm a bit ashamed but I really got into Forth quite recently, it's possible I spread some misinformation here, please let me know if I do, thanks <3 ~drummyfish }
 
-Forth ("fourth generation" shortened to four characters due to technical limitations) is a very [elegant](beauty.md), extremely [minimal](minimalism.md) [stack](stack.md)-based [programming language](programming_language.md) that uses [postfix](notation.md) (reverse Polish) notation -- it is one of the very best programming languages ever conceived. Its vanilla form is super simple, it's much simpler than [C](c.md), it is cleverly designed and its compiler/interpreter can be made easily, giving it high practical freedom (i.e. not being practically controlled by any central organization). As of writing this the smallest Forth implementation, [milliforth](milliforth.md), has just **340 bytes** (!!!) of [machine code](machine_code.md), that's just incredible. Forth is used e.g. in [space](space.md) technology (e.g. [RTX2010](rtx2010.md), a radiation hardened space computer directly executing Forth) and [embedded](embedded.md) systems as a way to write efficient [low level](low_level.md) programs that are, unlike those written in [assembly](assembly.md), [portable](portability.md) (fun fact: there even exist computers directly running Forth in hardware). Forth was the main influence for [Comun](comun.md), the [LRS](lrs.md) programming language, it is also used by [Collapse OS](collapseos.md) and [Dusk OS](duskos.md) as the main language. In its minimalism Forth competes a bit with [Lisp](lisp.md).
+Forth ("fourth generation" shortened to four characters due to technical limitations) is a very [elegant](beauty.md), extremely [minimal](minimalism.md) [stack](stack.md)-based [programming language](programming_language.md) (and a general computing environment) that uses [postfix](notation.md) (reverse Polish) notation -- it is one of the very best programming languages ever conceived. Forth's vanilla form is super simple, much simpler than [C](c.md), its design is ingenious and a compiler/interpreter can be made with little effort, giving it high [practical freedom](freedom_distance.md) (that is to say Forth can really be in the hands of the people). As of writing this the smallest Forth implementation, [milliforth](milliforth.md), has just **340 bytes** (!!!) of [machine code](machine_code.md), that's just incredible. Forth is used for example in [space](space.md) computers (e.g. [RTX2010](rtx2010.md), a radiation hardened space computer directly executing Forth) and [embedded](embedded.md) systems as a way to write efficient [low level](low_level.md) programs that are, unlike those written in [assembly](assembly.md), [portable](portability.md). Forth was the main influence for [Comun](comun.md), the [LRS](lrs.md) programming language, it is also used by [Collapse OS](collapseos.md) and [Dusk OS](duskos.md) as the main language. In minimalism Forth competes a bit with [Lisp](lisp.md), however Forth is ultimately superior -- not just in efficiency but also in elegance.
 
-**Forth is magical and may be the greatest thing yet conceived in computing**, it really looks like the pinnacle of programming. While in the world of "normal" programming languages you have to make tradeoffs, such as sacrificing performance for flexibility, Forth beats basically all traditional languages at EVERYTHING at once: [simplicity](minimalism.md), [beauty](beauty.md), memory compactness, flexibility, performance and [portability](portability.md). It is also more than just a programming language, it is just a system for computing and can serve for example as a [text editor](text_editor.md) or even an [operating system](os.md) (that is why e.g. DuskOS is written in Forth -- it is not as much written in Forth as it actually IS Forth). Of course you may ask: if it's so great, why isn't it used very much? Someone somewhere once summed it up like this: Forth gives one extreme freedom and this allows [retards](soydev.md) to make bad design and fuck things up -- [capitalism](capitalism.md) needs languages for monkeys, that's why [bad languages](rust.md) are widely used. And remember: popularity has never been a measure of quality -- the best art will never be mainstream, it can only be understood by a few.
+**Forth may be one of best [programming](programming.md) systems yet conceived**, it is a pinnacle of programming genius. While in the world of "normal" programming languages we're used to suffering tradeoffs such as sacrificing performance for flexibility, Forth beats basically all such traditional languages at EVERYTHING at once: [simplicity](minimalism.md), [beauty](beauty.md), memory compactness, flexibility, performance and [portability](portability.md). It is also more than just a programming language, it is a system for computing, a calculator, programming language and its own debugger but can also serve for example as a [text editor](text_editor.md) and even a whole [operating system](os.md) (that is why e.g. DuskOS is written in Forth -- it is not as much written in Forth as it actually IS Forth). Of course you may ask: if it's so great, why isn't it used very much? Once someone summed it up as follow: Forth gives one unprecedented freedom and that allows [retards](soydev.md) to create bad design and fuck things up -- [capitalism](capitalism.md) needs languages for monkeys, that's why [bad languages](rust.md) are widely used. Remember: popularity has never been a measure of quality -- the best art will never be mainstream, it can only be understood and mastered by a few.
 
-Forth is a bit unique in its philosophy, it can really be hardly compared to traditional languages such as [C++](cpp.md) or [Java](java.md) -- while the "typical language" is always basically the same thing for the programmer (no matter the implementation) and provides a few predefined, highly complex, universal, hardcoded constructs that are simply there and cannot be changed (such as an [OOP](oop.md) system, templates, control structures, ...), **Forth adopts [Unix philosophy](unix_philosophy.md)** by defining just the concept of a word and maybe providing a few simple words and letting the programmer extend the language (that is even the compiler/interpreter itself) by defining new words out of the simpler ones, and this includes even things such as control structures (branches, loops, ...) for example. For instance: in traditional languages you have a few predefined formats in which you may write numbers, e.g. in C you may use decimal numbers as `123` or hexadecimal numbers as `0x7b`; in Forth you may change the base at any time to any value by assigning to the `base` variable, which will change how Forth parses and outputs numbers (while a number is considered any word that's not been found in dictionary). Almost everything in Forth can be modified this way, so pure Forth without any words is not much more than a description of a format of how words will be represented and handled on a very basic level -- something on the level of simplicity of let's say [lambda calculus](lambda_calculus.md) -- and only a *Forth system* of basic words (such as that defined by ANS Forth standard) provides a basic "practically usable" language. The point is this can still be extended yet further, without end or limitations.
+Forth is unique in its philosophy, it can really be hardly compared to traditional languages such as [C++](cpp.md) or [Java](java.md) -- while the "typical language" is always basically the same thing for the programmer (no matter the implementation) and provides a few predefined, highly complex, universal, hardcoded constructs that are simply there and cannot be changed (such as an [OOP](oop.md) system, templates, control structures, ...), **Forth adopts [Unix philosophy](unix_philosophy.md)** (maybe in a better way than Unix itself) by defining just the concept of a word and maybe providing a few simple words and letting the programmer extend the language (that is even the compiler/interpreter itself) by defining new words out of the simpler ones, and this includes even things such as control structures (branches, loops, ...), primitive data types, variables and constant. For instance: in traditional languages there are a few predefined formats in which numbers may be written -- let's say in C you may use decimal numbers as `123` or hexadecimal numbers as `0x7b` -- in Forth you may change the base at any time to any value by assigning to the `base` variable which will change how Forth parses and outputs numbers (while a number is considered any word that's not been found in dictionary), and it is even possible to completely rewrite the number parsing procedure itself. Almost everything in Forth can be modified this way, so pure Forth without any words is not much more than a description of a [data structure](data_structure.md) and simpler parser of space-separated words, it plainly dictates a format of how words will be represented and handled on a very basic level (that's on the simplicity level of, let's say, [lambda calculus](lambda_calculus.md)) and only a *Forth system* (i.e. one with a specific dictionary of defined words, such as that defined by ANS Forth standard) provides a basic "practically usable" language. The point is this can still be extended yet further, without any end or limitation.
-
-{ There used to be a nice Forth wiki at wiki.forthfreak.net, now it has to be accessed via archive as it's dead. Also some nice site here https://www.forth.org/compilers.html. ~drummyfish }
 
 { Since Forth adopts a kind of unique philosophy, there are some discussion about how low level Forth really is, if it really is a language or something like a "metalanguage", or an "environment" to create your own language by defining your own words. Now this is not a place to go very deep on this but kind of a sum up may be this: Forth in its base version is very low level, however it's very extensible and many Forth systems extend the base language to some kind of much higher level language, hence the debates. ~drummyfish }
 
-The language is usually presented as [interpreted](interpreter.md) but may perfectly well be [compiled](compiler.md) too, in fact it maps very well to [assembly](assembly.md). Some words may be written directly in machine code, so we may possibly see Forth as a kind of a "wrapper for assembly". And even if interpreted, the language can still be very fast thanks to its simplicity. Forth systems traditionally include not just a compiler/interpreter but also an **interactive environment**, kind of [REPL](repl.md) language shell.
+The language is usually presented as [interpreted](interpreter.md), however that's a bit misleading (interpreting Forth is almost like native execution), but 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).
 
-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.
+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.
 
-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).
+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.
+
+A [free](free_software.md) Forth 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).
 
 There is a book called **Starting Forth** that's freely downloadable and quite good at teaching the language.
 
+{ There used to be a nice Forth wiki at wiki.forthfreak.net, now it has to be accessed via archive as it's dead. Also some nice site here: https://www.taygeta.com/forth/dpans.html. ~drummyfish }
+
 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).
+Forth is usually case-insensitive.
 
-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 language operates on an evaluation **[stack](stack.md)** with postfix notation: for example 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.
 
-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.
+In fact there are two global 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 from functions are stored (remember that this is needed e.g. for [recursion](recursion.md)), 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.
 
-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).
+The stack is composed of **cells**: the size of the cell is implementation defined but must have at least 16 bits. 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) and [assembly](assembly.md) languages); 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). Forth programmers also often work with double numbers, i.e. numbers that take two cells (and so have double the range of the normal number) -- the words that work with these are prefixed with *2* (e.g. *2+*).
 
-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 or routines (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:
+Basic [abstraction](abstraction.md) in Forth is so called **word**: a word is simply a string without spaces like `abc` or `1mm#3`. A word represents some action, which may include running native code, pushing numbers on stack or executing other words, for example the word `+` performs 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 or routines (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. Part of Forth philosophy is to try define many small words rather than writing big walls of code. A word is defined like this:
 
 ```
 : myword operation1 operation2 ... ;
@@ -48,7 +50,7 @@ Dictionary is a very important concept in Forth, it usually stores the words as
 
 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:
+Some predefined words usually present in Forth systems include:
 
 ```
 GENERAL:
@@ -124,11 +126,12 @@ exit                      exits from current word
 recurse                   recursively call the word currently being defined
 see W                     shows (decompiles) the definition of word W
 ' W                       get address of word W
+MARKER W                  creates word W, executing W will delete W and all later words
 ```
 
 Forth uses counted **strings** (unlike [C](c.md) which uses NULL terminated strings), i.e. a string consists of an address pointing to the string start, and number saying the length of the string.
 
-TODO: local variables, addresses, arrays, compile-time behavior of words, strings, double words
+TODO: local variables, addresses, arrays, compile-time behavior of words, strings, double words, format of the word in memory
 
 ## Examples
 
@@ -248,8 +251,26 @@ bye
 
 We can run this simply with `gforth my.fs`, the programs should write `120`.
 
+## A Bit More Details
+
+Genius of Forth resides under the hood. Here are some very basics about that.
+
+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:
+
+- *flags*: Flags specifying the type of word (some words may be "special", e.g. those that have compile time behavior). Valid words have the highest bit also set to 1; 0 here means end of the dictionary (terminating the linked list).
+- *name length*: Length of the word's name, e.g. 6 for "myword". Some systems limit the name length, there may be a fixed size for the name (even as few as 3) and this field may be omitted. This field may also be merged into a single byte with the flags etc.
+- *name*: Characters of the word name. Note that this serves for looking up words during compilation but is NOT needed for executing the code.
+- *link* (LFA): Link to previous word in dictionary (this creates the linked list of words).
+- *code pointer* (CFA): Pointer to the native (machine) code that's executed by this word. For example words that represent constants have a pointer to the (same) piece of machine code that pushes the constant's value -- this code is the same for all constants but, of course, the values of the constants are different -- that's what PFA is for; before executing the code, address of the PFA is pushed on stack so that the code can access the word's specific parameters. Notable case here is the colon definition (words defined with the `: ... ;` syntax) -- here the code traverses through PFA, which stores addresses of the words in the definition, and just executes each address (also pushing the return addresses on stack etc.).
+- *parameter field* (PFA): This is a variable-length piece of memory that holds the data, the parameters for the code of this specific word -- so e.g. for the value of the constant for words that represent a constant, value of a variable for words representing variables etc. Arrays and strings also store their data here, the field is just longer. Colon definition have addresses of the words they contain here (notice that once the addresses are compiled here, we no longer need the word names).
+
+Then there is a special pointer called *H* which points to the end of dictionary memory, i.e. at the end of the latest added word; adding a new word will happen here. This pointer is important e.g. for allocation: the word *ALLOT* (that allocated more memory cells for previously created pointer) just advanced the *H* pointer, making more room in the PFA. Quite clever, isn't it?
+
+TODO: compile time behavior, control structures, ...
+
 ## See Also
 
 - [Lisp](lisp.md)
+- [Scheme](scheme.md)
 - [comun](comun.md)
 - [Tcl](tcl.md)

jokes.md

@@ -75,9 +75,11 @@ Also remember the worst thing you can do to a joke is put a [disclaimer](disclai
 - The goal of [computer science](compsci.md) is to create things that will last at
 least until we're finished building them.
 - How many lesbians do you need to screw a lightbulb? Eleven: one to screw it and ten to talk about how great it was doing it without a man.
+- Look at that obese singer typing something on her laptop. I think it's a Dell.
 - A fine is tax for doing bad, a tax is fine for doing good.
 - What do you like most in a [woman](woman.md)? My dick.
 - [USA](usa.md) is the fastest progressing country in the world: it managed to jump from the uncivilized stage right to decadence without even going through the transitional stage of civilization.
+- Autocorrect is my worst enema.
 - Hey I won a box with lifetime supply of condoms in an [assembly](assembly.md) programming competition! Turns out the box was just empty.
 - The new version of [Windows](windows.md) is going to be backdoor free! The backdoor will be free of charge.
 

lrs.md

@@ -97,7 +97,7 @@ Apart from this software a lot of other software developed by other people and g
 - **[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.
-- **[Forth](forth.md)**: Small programming language with very nice design.
+- **[Forth](forth.md)**: Minimalist programming language, one of the best examples of good design.
 - **[surf](surf.md)**: Official [suckless](suckless.md) [web browser](browser.md).
 - **[tcc](tcc.md)**: Small [C](c.md) [compiler](compiler.md) (alternative to [gcc](gcc.md)).
 - **[musl](musl.md)**: Tiny [C](c.md) standard library (alternative to [glibc](glibc.md)).

minimalism.md

@@ -2,10 +2,12 @@
 
 *No gain, no pain.*
 
-In context of [technology](tech.md) minimalism is a design philosophy which puts great emphasis on [simplicity](kiss.md), it says technology should be as simple as possible while still achieving given goal, possibly even a little bit simpler. Minimalism is one of the most (if not the most) important concepts in [programming](programming.md) and technology in general, it could almost be said that becoming a true expert in technology is strongly connected to realizing the importance of simplicity (see e.g. [Unix philosophy](unix_philosophy.md)). One of the first things to stress about minimalism is that it's firstly about **internal simplicity**, i.e. the simplicity of design/repairing/[hacking](hacking.md), and only secondly about the simplicity from the [user](user.md)'s point of view (otherwise we are only dealing with [pseudominimalism](pseudominimalism.md)). The opposite of minimalism is [maximalism](maximalism.md). See also [minimal viable program](minimal_viable_program.md).
+In context of [technology](tech.md) minimalism is a design philosophy which puts great emphasis on [simplicity](kiss.md), it says technology should be as simple as possible while still achieving given goal, possibly even a little bit simpler. Minimalism is one of the most (if not the most) important concepts in [programming](programming.md) and technology in general, it could almost be said that becoming a true expert in technology is strongly connected to realizing the importance of simplicity (see e.g. [Unix philosophy](unix_philosophy.md)). One of the first things to stress about minimalism is that it's firstly about **internal simplicity**, i.e. the simplicity of design/repairing/[hacking](hacking.md), and only secondly about the simplicity from the [user](user.md)'s point of view (otherwise we are only dealing with [pseudominimalism](pseudominimalism.md)). The opposite of minimalism is [maximalism](maximalism.md).
 
 Antoine de Saint-Exupery sums it up with a quote: *we achieve perfection not when there is nothing more to add but when there is nothing left to take away.*
 
+**[Forth](forth.md)** is perhaps the best example of software minimalism and demonstrates that clever, strictly minimalist design can be absolutely superior to the best efforts of maximalists.
+
 The concept of minimalism is also immensely important in [art](art.md), religion and other aspects of culture and whole society, for example in architecture and design we see a lot of minimalism, and basically every major religion values frugality and letting go material desired, be it [Christianity](christianity.md), [Islan](islam.md) or [Buddhism](buddhism.md). Therefore there also exists the generalized concept of **life minimalism** which applies said wisdom and philosophy to all areas of [life](life.md) and which numerous technological minimalists quite naturally start to follow along the way -- life minimalism is about letting go of objects, thoughts and desires that aren't necessarily needed because such things enslave us and mostly just make us more miserable; from time to time you should meditate a little bit about what it is that you really want and need and only keep that. Indeed this is nothing new under the Sun, this wisdom has been present for as long as humans have existed, most religions and philosophers saw a great value in [asceticism](asceticism.md), frugality and even poverty, as owning little leads to [freedom](freedom.md). For instance owning a [car](car.md) is kind of a slavery, you have to clean it, protect it, repair it, [maintain](maintenance.md) it, pay for parking space, pay for gas, pay for insurance -- this is not a small commitment and you sacrifice a significant part of your life and [head space](head_space.md) to it (especially considering additional commitments of similar magnitude towards your your house, garden, clothes, electronics, furniture, pets, bank accounts, social networks and so forth), a minimalist will rather choose to get a simple [suckless](suckless.md) bicycle, travel by public transport or simply walk.
 
 Minimalism is a sign of high [IQ](iq.md) and better developed mind, it is something that requires an intellect strong enough to overcome the human instinct for hoarding to which the unintelligent is a slave -- an instinct that was important in times of scarce resources but one that's become harmful in times when certain resources are abundant and can be consumed without limits. It is like with overeating: the intelligent man is able to restrain from unhealthy overeating to which he is pushed by his instinct.

oop.md

@@ -53,7 +53,7 @@ After many people realized OOP is kind of shit, there has been a boom of "OOP al
 
 In short: NONE, **by default use the [imperative](imperative.md) paradigm** (also here many times interchangeably called "[procedural](procedural.md)"). Remember this isn't to say you shouldn't ever apply a different paradigm, but imperative should be the default, most prevalent and suitable one to use in solving most problems. There is nothing new to invent or "beat" OOP.
 
-But why imperative? Why can't we simply improve OOP or come up with something ultra genius to replace it with? Why do we say OOP is bad because it's forced and now we are forcing imperative paradigm? The answer is that the **imperative paradigm is special because it is how computers actually work**, it is not made up but rather it's the **natural low level paradigm with minimum [abstraction](abstraction.md) that reflects the underlying nature of computers**. You may say this is just bullshit arbitrary rationalization but no, these properties makes imperative paradigm special among all other paradigms because:
+But why imperative? Why can't we simply improve OOP or come up with something ultra genius to replace it with? Why do we say OOP is bad because it's forced and now we are forcing imperative paradigm? The answer is that the **imperative paradigm is special because it is how computers actually work**, i.e. imperative paradigm just copies the hardware paradigm and thus is natural, logical, predictable and has practically no compilation overhead. It is not made up but rather it's the **natural low level paradigm with minimum [abstraction](abstraction.md) that reflects the underlying nature of computers**. You may say this is just bullshit arbitrary rationalization but no, these properties makes imperative paradigm special among all other paradigms because:
 
 - Its implementation is simple and [suckless](suckless.md)/[LRS](lrs.md) because it maps nicely and naturally to the underlying hardware -- basically commands in a language simply translate to one or more instructions. This makes construction of compilers easy.
 - It's predictable and efficient, i.e. a programmer writing imperative code can see quite clearly how what he's writing will translate to the assembly instructions. This makes it possible to write highly efficient code, unlike high level paradigms that perform huge amounts of [magic](magic.md) for translating foreign concepts to machine instructions -- and of course this magic may differ between compilers, i.e. what's efficient code in one compiler may be inefficient in another (similar situation arose e.g. in the world of [OpenGL](opengl.md) where driver implementation started to play a huge role and which led to the creation of a more low level API [Vulkan](vulkan.md)).

people.md

@@ -2,7 +2,7 @@
 
 *"People are retarded."* --[Osho](osho.md)
 
-All people are idiots, [love](love.md) all of them, never make anyone a [leader](hero_culture.md). So far people seem to be the least intelligent species that ever appeared on [Earth](earth.md), the only thing stupider than people are [feminists](feminism.md) and [capitalists](capitalism.md).
+All people are idiots, [love](love.md) all of them, never make anyone a [leader](hero_culture.md). So far people seem to be mentally the most inferior of all species on [Earth](earth.md), the only thing stupider than people are [feminists](feminism.md) and [capitalists](capitalism.md) (which is basically the same thing). Humans possess high level of intelligence which allows them to be extremely stupid, much more than other organisms can dream of -- just like playing the worst [chess](chess.md) moves requires deep understanding of chess, behaving in most stupid ways possible requires an intellect capable of deducing what is indeed the most stupid thing to do at any given time -- at this humans excel.
 
 Remember: a cover mostly says just enough about the book.
 

programming_language.md

@@ -118,7 +118,7 @@ Here is a table of notable programming languages in chronological order (keep in
 | [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, ...)    |
 | [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   |
+| [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                     |
 | **[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                           |

steve_jobs.md

@@ -2,7 +2,7 @@
 
 *"I'm not glad he'd dead, but I'm glad he's gone."* -- [Richard Stallman](rms.md)
 
-Steve Jobs (also Steve Jewbs) was the prototypical evil [CEO](ceo.md) and co-founder of one of the worst [corporations](corporation.md) in the world: [Apple](apple.md). He was a psychopathic entrepreneur with a [cult of personality](hero_culture.md) that makes [Americans](usa.md) cum. He was mainly known for his ability to manipulate people and he worsened technology by making it more consumerist, expensive and incompatible with already existing technology. All americans masturbate daily to Steve Jobs so he can also be considered the most famous US porn star. Someone once said that there are essentially two types of men in technology: those who understand what they don't manage and those who manage what they don't understand. Jobs was the latter.
+Steve Jobs (also Steve Jewbs) was the prototypical evil [CEO](ceo.md) dictator and co-founder of one of the worst [corporations](corporation.md) in the world: [Apple](apple.md). He was a psychopathic entrepreneur with a [cult of personality](hero_culture.md) that makes [Americans](usa.md) cum. He was mainly known for his ability to manipulate people and he worsened technology by making it more consumerist, expensive and incompatible with already existing technology. All americans masturbate daily to Steve Jobs so he can also be considered the most famous US porn star. Someone once said that there are essentially two types of men in technology: those who understand what they don't manage and those who manage what they don't understand. Jobs was the latter.
 
 { LOL how come in the American movies the villain is always some rich boss of a huge corporation clearly resembling Steve Jobs, doing literally the same things, it's almost as if the average American actually somehow KNOWS and feels deep inside these people are pure evil, but suddenly outside of a Hollywood movie their brain switches to "aaaaah, that guy is amazing" and they just eat all his bullshit. I just can't comprehend this. ~drummyfish }
 

wiki_stats.md

@@ -3,9 +3,9 @@
 This is an autogenerated article holding stats about this wiki.
 
 - number of articles: 588
-- number of commits: 859
+- number of commits: 860
-- total size of all texts in bytes: 4187152
+- total size of all texts in bytes: 4194967
-- total number of lines of article texts: 31785
+- total number of lines of article texts: 31822
 - number of script lines: 262
 - occurences of the word "person": 7
 - occurences of the word "nigger": 91
@@ -35,60 +35,83 @@ longest articles:
 
 top 50 5+ letter words:
 
-- which (2367)
+- which (2370)
-- there (1823)
+- there (1825)
-- people (1624)
+- people (1625)
-- example (1389)
+- example (1392)
 - other (1295)
-- number (1167)
+- number (1171)
-- software (1142)
+- software (1143)
-- about (1122)
+- about (1125)
 - program (944)
-- because (880)
+- because (882)
 - their (876)
 - would (874)
 - called (815)
 - being (802)
-- things (794)
+- things (797)
-- something (791)
+- something (792)
-- language (773)
+- language (784)
-- numbers (761)
+- numbers (765)
+- simple (750)
 - computer (750)
-- simple (748)
+- without (710)
-- without (707)
+- programming (692)
-- programming (687)
 - function (685)
-- these (675)
+- these (677)
-- different (656)
+- different (657)
 - however (651)
-- system (617)
+- system (622)
-- world (613)
+- world (614)
-- should (602)
+- should (603)
-- doesn (597)
+- doesn (600)
-- point (585)
+- point (586)
 - games (578)
 - society (574)
-- while (566)
+- while (570)
 - drummyfish (549)
-- though (544)
+- simply (544)
-- simply (542)
+- though (543)
-- using (537)
+- using (538)
-- still (534)
+- still (535)
 - possible (524)
 - similar (511)
-- memory (509)
+- memory (511)
 - https (505)
-- course (502)
+- course (503)
 - technology (497)
-- always (480)
+- basically (482)
-- basically (479)
+- always (481)
-- value (475)
+- value (476)
-- really (469)
+- really (472)
 - first (457)
 
 latest changes:
 
 ```
+Date:   Thu Aug 8 22:37:16 2024 +0200
+  acronym.md
+  bloat.md
+  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
+  wiki_stats.md
+  xxiivv.md
 Date:   Tue Aug 6 22:19:44 2024 +0200
   100r.md
   books.md
@@ -104,27 +127,6 @@ Date:   Tue Aug 6 22:19:44 2024 +0200
   wiki_pages.md
   wiki_stats.md
   woman.md
-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
 ```
 
 most wanted pages:
@@ -148,30 +150,30 @@ most wanted pages:
 - [gpu](gpu.md) (8)
 - [gpl](gpl.md) (8)
 - [cryptography](cryptography.md) (8)
-- [war](war.md) (7)
+- [comun_shell](comun_shell.md) (8)
 
 most popular and lonely pages:
 
 - [lrs](lrs.md) (293) 
-- [capitalism](capitalism.md) (238) 
+- [capitalism](capitalism.md) (239) 
-- [c](c.md) (217) 
+- [c](c.md) (219) 
 - [bloat](bloat.md) (210) 
 - [free_software](free_software.md) (176) 
 - [game](game.md) (141) 
 - [suckless](suckless.md) (139) 
-- [proprietary](proprietary.md) (121) 
+- [proprietary](proprietary.md) (122) 
 - [computer](computer.md) (98) 
 - [kiss](kiss.md) (97) 
 - [modern](modern.md) (95) 
-- [minimalism](minimalism.md) (91) 
+- [minimalism](minimalism.md) (93) 
 - [gnu](gnu.md) (91) 
 - [linux](linux.md) (90) 
 - [censorship](censorship.md) (85) 
 - [programming](programming.md) (84) 
 - [fun](fun.md) (84) 
 - [free_culture](free_culture.md) (81) 
+- [fight_culture](fight_culture.md) (81) 
 - [less_retarded_society](less_retarded_society.md) (80) 
-- [fight_culture](fight_culture.md) (80) 
 - [math](math.md) (77) 
 - [hacking](hacking.md) (77) 
 - [bullshit](bullshit.md) (77) 

woman.md

@@ -114,6 +114,7 @@ Here is a list of almost all historically notable women (this is NOT cherrypicke
 - **[Marie Curie](marie_curie.md)**: this one was actually probably quite skilled and based, won two Nobel Prizes (at the time when there were no diversity quotas so it actually counts), though she probably stole most of her work from her husband. She was quite ugly tho.
 - **Lisa Nowak**: a female astronaut, military pilot, i.e. someone who would ideally be among those with highest mental stability and reliability, who nonetheless one day went on a rage frenzy over a sexual affair with some army chad, pepper sprayed some other bitch and was subsequently charged with attempted murder after weapons were found in her car... women... :D
 - **Lisa Simpson**: smart girl, fictional.
+- **Mary**: famous for giving birth to [most famous man in history](jesus.md).
 - **Miss Marple**: smart woman detective, fictional.
 - **Olga Hepnarova**: ran over 8 people with a truck, later executed.
 - **Sharon Stone**: showed vagina on camera