Update

acronym.md

@@ -299,6 +299,7 @@ Here is a list of some acronyms:
 - **[ROM](rom.md)** ([read-only](read_only.md) memory)
 - **[RPG](rpg.md)** (role playing game)
 - **[RPI](rpi.md)** (Raspberry Pi)
+- **[RPN](rpn.md)** (reverse Polish notation)
 - **[RT](rt.md)** (real time)
 - **[RTFM](rtfm.md)** (read the fucking manual)
 - **[RTOS](rtos.md)** (real time operating system)

bloat.md

@@ -81,7 +81,7 @@ The **path of [degeneracy](degenerate_software.md)** drawn in the graph shows ho
 
 Please note there may arise some disagreement among minimalist groups about where the band is drawn exactly, especially old Unix hackers could be heard arguing for allowing (or even requiring) even trivial programs, maybe as long as the source code isn't shorter than the utility name, but then the discussion might even shift to questions like "what even is a program vs what's just a 10 characters long line" and so on.
 
-As a quick [heuristic](heuristic.md) for judging programs you can really take a look at the lines of code (as long as you know it's a simplification that ignores dependencies, formatting style, language used etc.) and use the following classes (basically derived from how [suckless](suckless.md) programs are often judged):
+As a quick [heuristic](heuristic.md) for judging programs you can really take a look at the [lines of code](loc.md) (as long as you know it's a simplification that ignores dependencies, formatting style, language used etc.) and use the following classes (basically derived from how [suckless](suckless.md) programs are often judged):
 
 - < 10: Extremely small but may be useful, may be also too trivial for such small size to be justifiable, can aim to be completely bug-free. Example could be the [cat](cat.md) program.
 - 11 to 100: Very small, can be debugged to a great level, many greatly useful utilities, e.g. [compression](compression.md) programs, may fit this class.

bootstrap.md

@@ -13,7 +13,7 @@ Bootstrapping -- as the general concept of letting a big thing grow out of a sma
 
 Bootstrapping has to start with some initial prerequisite machine dependent binary code that kickstarts the self-establishing process, i.e. it's not possible to get rid of absolutely ALL binary code and have a pure bootstrappable code that would run on every computer -- that would require making a program that can native run on any computer, which can't be done -- but it is possible to get it to absolute minimum -- let's say a few dozen bytes of machine code that can even be hand-made on paper and can be easily inspected for "safety". This initial binary code is called *bootstrapping binary seed*. This code can be as simple as a mere translator of some extremely simple bytecode (that may consist only of handful of instructions) to the platform's assembly language. There even exists the extreme case of a single instruction computer, but in practice it's not necessary to go as far. The initial binary seed may then typically be used to translate a precompiled bytecode of our system's compiler to native runnable code and voila, we can now happily start compiling whatever we want.
 
-[Forth](forth.md) is a language that has traditionally been used for making bootstrapping environments; [Dusk OS](duskos.md) is an example of such project. Similarly simple language such as [Lisp](lisp.md) and [comun](comun.md) can work too (GNU Mes uses a combination of [Scheme](scheme.md) and C).
+[Forth](forth.md) is a language that has traditionally been used for making bootstrapping environments -- its paradigm and philosophy is ideal for bootstrapping as it's based on the concept of building a computing environment practically from nothing just by defining new and new words using previously defined simpler words, fitting the definition of bootstrapping perfectly. [Dusk OS](duskos.md) is a project demonstrating this. Similarly simple language such as [Lisp](lisp.md) and [comun](comun.md) can work too (GNU Mes uses a combination of [Scheme](scheme.md) and C).
 
 **How to do this then?** To make a computing environment that can bootstrap itself you can do it like this:
 

c.md

@@ -2,7 +2,7 @@
 
 { We have a [C tutorial](c_tutorial.md)! ~drummyfish }
 
-C is an [old](old.md) [low level](low_level.md) structured [statically typed](static_typing.md) [imperative](imperative.md) compiled [programming language](programming_language.md), it is very fast and currently mostly used by [less retarded software](lrs.md). Though by very strict standards it would still be considered [bloated](bloat.md), compared to any mainstream [modern](modern.md) language it is very bullshitless, [KISS](kiss.md) and greatly established and "culturally stable", so it is also the go-to language of the [suckless](suckless.md) community as well as most true experts, for example the [Linux](linux.md) and [OpenBSD](openbsd.md) developers, because of its good, relatively simple design, **uncontested performance**, **wide support**, great number of compilers, level of control and a greatly established and tested status. C is **perhaps the most important language in history**; it influenced, to smaller or greater degree, basically all of the widely used languages today such as [C++](c.md), [Java](java.md), [JavaScript](javascript.md) etc., however it is not a thing of the past -- in the area of low level programming C is still the number one unsurpassed language. C is by no means perfect but it is currently probably the best choice of a programming language (along with [comun](comun.md), of course). Though C is almost always compiled, there have appeared some C interpreters as well.
+C is an [old](old.md) [low level](low_level.md) structured [statically typed](static_typing.md) [imperative](imperative.md) compiled [programming language](programming_language.md), it is very fast and currently mostly used by [less retarded software](lrs.md). Though by very strict standards it would still be considered [bloated](bloat.md), compared to any mainstream [modern](modern.md) language it is very bullshitless, [KISS](kiss.md) and greatly established and "culturally stable", so it is also the go-to language of the [suckless](suckless.md) community as well as most true experts, for example the [Linux](linux.md) and [OpenBSD](openbsd.md) developers, because of its good, relatively simple design, **uncontested performance**, **wide support**, great number of compilers, level of control and a greatly established and tested status. C doesn't belong to the class of most minimal languages but it is among the most minimalist "traditional" kind of languages. C is **perhaps the most important language in history**; it influenced, to smaller or greater degree, basically all of the widely used languages today such as [C++](c.md), [Java](java.md), [JavaScript](javascript.md) etc., however it is not a thing of the past -- in the area of low level programming C is still the number one unsurpassed language. C is by no means perfect but it is currently probably the best choice of a programming language (along with [comun](comun.md), of course). Though C is almost always compiled, there have appeared some C interpreters as well.
 
 { See https://wiki.bibanon.org/The_Perpetual_Playthings. Also look up *The Ten Commandments for C Programmers* by Henry Spencer. Also the *Write in C* song (parody of *Let it Be*). ~drummyfish }
 

comun.md

@@ -1,6 +1,6 @@
 # Comun
 
-Comun is a [beautiful](beauty.md), greatly [minimalist](minimalism.md) [programming language](programming_language.md) made by [drummyfish](drummyfish.md) in 2022, based on his ideals of good, [selfless](selflessness.md) [technology](technology.md) known as *[less retarded software](lrs.md)* (LRS), of which it is now considered the official programming language, though still a greatly work in progress one. In the future it should gradually replace [C](c.md) as the preferred LRS language, however let's keep in mind the language is still highly experimental and work in progress, it may yet change more or less. The language has been inspired mainly by [Forth](forth.md) but also [C](c.md), [brainfuck](brainfuck.md) and other ones. Though already usable, it is still in development; currently there is a [suckless](suckless.md) implementation of comun in [C](c.md) as well as a basic [self hosted](self_hosting.md) one which should gradually replace the C version. There is also a number of supplemental materials such as a specification, tutorial and some example programs. The project repository is currently at https://codeberg.org/drummyfish/comun. The aim now is to make a [self hosted](self_hosting.md) implementation, i.e. write comun in comun. Though very young, **comun is probably already the best programming language ever conceived** :-)
+Comun is a [beautiful](beauty.md), greatly [minimalist](minimalism.md) [programming language](programming_language.md) made by [drummyfish](drummyfish.md) in 2022, based on his ideals of good, [selfless](selflessness.md) [technology](technology.md) known as *[less retarded software](lrs.md)* (LRS), of which it is now considered the official programming language, though still a greatly work in progress one. In the future it should gradually replace [C](c.md) as the preferred LRS language, however let's keep in mind the language is still highly experimental and work in progress, it may yet change more or less. The language has been inspired mainly by [Forth](forth.md) but also [C](c.md), [brainfuck](brainfuck.md) and other ones. Though already usable, it is still in development; currently there is a [suckless](suckless.md) implementation of comun in [C](c.md) as well as a basic [self hosted](self_hosting.md) one which should gradually replace the C version. There is also a number of supplemental materials such as a specification, tutorial and some example programs. The project repository is currently at https://codeberg.org/drummyfish/comun. The aim now is to make a [self hosted](self_hosting.md) implementation, i.e. write comun in comun.
 
 **How minimal is comun?** The specification fits on one sheet of A4 paper (using both sides) and the minimal self hosted compiler without preprocessor and fancy features has some 2400 [lines of code](loc.md), a lot of which are documenting comments (the whole self hosted codebase that also includes a more "feature rich" compiler, optimizer, interpreter etc. still has fewer than 5000 lines).
 
@@ -10,7 +10,9 @@ The language is intended to be the foundation of a completely new, non-[capitali
 
 Comun is planned to closely interact with [comun shell](comun_shell.md), though the two parts will be completely independent.
 
-**A quick sum up** is following: comun is **[minimalist](minimalism.md)**, **[low level](low_level.md)** with minimum [abstraction](abstraction.md), **[portable](portability.md)**, **[imperative](imperative.md)** and **[stack](stack.md)-based**, using **reverse Polish notation**. It can be **both [compiled](compiler.md) and [interpreted](interpreter.md)**. There are **only primitive integer [data types](data_type.md)** (native integer size by default with possibility to specify exact width where necessary, signed/unsigned interpretation is left to the programmer) and **optional [pointers](pointer.md)** that can be used as variables, for managing multiple stacks, creating [arrays](array.md) etc. Its **specification can fit on a sheet of paper** and is **completely [public domain](public_domain.md)** under [CC0](cc0.md) (as is its current implementation). It has **no [standard library](stdlib.md)**. There are **no [English](english.md) keywords**; commands are rather very short (mostly 1 to three symbols) math-like symbols. Source code only allows [ASCII](ascii.md) symbols (no [unicode](unicode.md)). There is an **optional [preprocessor](preprocessor.md) that uses comun itself** (i.e. it doesn't use any extra language). **[Functions](function.md) and [recursion](recursion.md)** are supported. Many features of the language are optional and never burden the programmer if he doesn't use them. Simplified versions of the language (minicomun and microcomun) are also specified.
+**A quick sum up** is following: comun is **[minimalist](minimalism.md)**, **[low level](low_level.md)** with minimum [abstraction](abstraction.md), **[portable](portability.md)**, **[imperative](imperative.md)** and **[stack](stack.md)-based**, using **reverse Polish notation**. It can be **both [compiled](compiler.md) and [interpreted](interpreter.md)**. There are **only primitive integer [data types](data_type.md)** (native integer size by default with possibility to specify exact width where necessary, signed/unsigned interpretation is left to the programmer) and **optional [pointers](pointer.md)** that can be used as variables, for managing multiple stacks, creating [arrays](array.md) etc. Its **specification can fit on a sheet of paper** and is **completely [public domain](public_domain.md)** under [CC0](cc0.md) (as is its current implementation). It has **no [standard library](stdlib.md)**. There are **no [English](english.md) keywords**; commands are rather very short (mostly 1 to three symbols) math-like symbols. Source code only allows [ASCII](ascii.md) symbols (no [unicode](unicode.md)). There is an **optional [preprocessor](preprocessor.md) that uses comun itself** (i.e. it doesn't use any extra language). **[Functions](function.md) and [recursion](recursion.md)** are supported. Many features of the language are optional and never burden the programmer if he doesn't use them. Simplified versions of the language (minicomun and microcomun) are also specified. The only I/O in pure comun is standard input and standard output, i.e. there is no input/output from/to files, screen, network etc., the language merely processes input values into output values -- handling more complex I/O is left for libraries and/or comun's wrapping environment, such as [comun shell](comun_shell.md).
+
+TODO: compare to Forth
 
 ## Examples
 
@@ -176,3 +178,4 @@ printDivisorTree:
 - [uxn](uxn.md)
 - [minim](minim.md)
 - [Oberon](oberon.md)
+- [C](c.md)

duskos.md

@@ -1,6 +1,6 @@
 # Dusk OS
 
-Dusk OS (http://duskos.org/) is a work in progress non-[Unix](unix.md) extremely [minimalist](minimalism.md) 32 bit [free as in freedom](free_software.md) [operating system](operating_system.md) whose primary purpose is to be helpful during societal [collapse](collapse.md) but which will still likely be very useful even before it happens. It is made mainly by [Virgil Dupras](dupras.md), the developer of [Collapse OS](collapseos.md), as a bit "bigger" version of Collapse OS, one that's intended for the first stage of societal collapse and will be more "powerful" and comfortable to use for the price of increased complexity (while Collapse OS is simpler and meant for the use during later stages). But don't be fooled, Dusk OS is still light year ahead in simplicity than the most minimal [GNU](gnu.md)/[Linux](linux.md) distro you can imagine; by this extremely minimalist design Dusk OS is very close to the ideals of our [LRS](lrs.md), it is written in [Forth](forth.md) but also additionally (unlike Collapse OS) includes a so called "Almost [C](c.md)" compiler allowing [ports](port.md) of already existing programs, e.g. Unix [command line](cli.md) utilities. It is also available under [CC0](cc0.md) [public domain](public_domain.md) just as official LRS projects, that's simply unreal.
+Dusk OS (http://duskos.org/) is a work in progress non-[Unix](unix.md) extremely [minimalist](minimalism.md) 32 bit [free as in freedom](free_software.md) [operating system](operating_system.md) whose primary purpose is to be helpful during societal [collapse](collapse.md) but which will still likely be very useful even before it happens. It is made mainly by [Virgil Dupras](dupras.md), the developer of [Collapse OS](collapseos.md), as a bit "bigger" version of Collapse OS, one that's intended for the first stage of societal collapse and will be more "powerful" and comfortable to use for the price of increased complexity (while Collapse OS is simpler and meant for the use during later stages). But don't be fooled, Dusk OS is still light year ahead in simplicity than the most minimal [GNU](gnu.md)/[Linux](linux.md) distro you can imagine; by this extremely minimalist design Dusk OS is very close to the ideals of our [LRS](lrs.md), it is written in [Forth](forth.md) but also additionally (unlike Collapse OS) includes a so called "Almost [C](c.md)" compiler allowing [ports](port.md) of already existing programs, e.g. Unix [command line](cli.md) utilities. It can also be seen as a Forth implementation/system. The project is available under [CC0](cc0.md) [public domain](public_domain.md) just as official LRS projects, that's simply unreal.
 
 The project has a private mailing list. Apparently there is talk about the system being useful even before the collapse and so it's even considering things like [networking](network.md) support etc. -- as [capitalism](capitalism.md) unleashes hell on [Earth](earth.md), any simple computer capable of working on its own and allowing the user complete control will be tremendously useful, even if it's just a programmable calculator. Once [GNU](gnu.md)/[Linux](linux.md) and [BSD](bsd.md)s sink completely (very soon), this may be where we find the safe haven.
 
@@ -27,3 +27,7 @@ Let's sum up some of the interesting features of the system:
 - sound: ???
 - networking: being considered
 - NOT a Unix-like but will naturally be aligned with many of its concepts as per simplicity
+
+## See Also
+
+- [DuckOS](duckos.md)

faq.md

@@ -112,7 +112,7 @@ Firstly technological [progress](progress.md) is secondary to the primary type o
 
 Secondly examining any existing subject in depth requires also understanding its context anyway. Politics and technology nowadays are very much intertwined and the politics of a society ultimately significantly affects what its technology looks like ([capitalist SW](capitalist_software.md), [censorship](censorship.md), [bloat](bloat.md), [spyware](spyware.md), [DRM](drm.md), ...), what goals it serves (consumerism, [productivity](productivity_cult.md), control, war, peace, ...) and how it is developed ([COCs](cos.md), [free software](free_software.md), ...), so studying technology ultimately requires understanding politics around it. I hate arguing about politics, sometimes it literally make me suicidal, but it is inevitable, we have to specify real-life goals clearly if we're to create good technology. Political goals guide us in making important design decisions about features, [tradeoffs](tradeoff.md) and other attributes of technology.
 
-Thirdly society and computer programs are in many ways similar and we naturally see analogies between both the problems and the solutions.
+Thirdly society and computer programs are in many ways similar and we naturally see analogies between both these problems and the solutions.
 
 Of course you can fork this wiki and try to remove politics from it, but I think it won't be possible to just keep the technology part alone so that it would still make sense, most things will be left without justification and explanation.
 
@@ -158,6 +158,8 @@ It also has the nice side effect of making this less likely to be used by corpor
 
 ### How can you say you love all living beings and use offensive language at the same time?
 
+Rather ask why you cannot do the same -- really, [think about it deeper](shortcut_thinking.md). Why are we forbidding "offensive" language? Maybe because in the spoiled mainstream culture offensive language implies aggression and threat, it may incite violence, encourage destruction and so on. In LRS culture this is in no way so, we practice [free speech](free_speech.md), i.e. we simply don't put on any masks or hide our thoughts from others, we are honest: if I think someone is stupid, why should I lie and say I think he is not stupid? (Keep in mind that staying silent may also be a form of lying and pretense.) This doesn't mean I can't love the individual -- if I couldn't love stupid beings, I couldn't love dogs and cats because they don't reach my level of intelligence, but I do love them. In LRS culture expressing disgust, frustration and strong disagreements doesn't at all mean hostility or an incentive to [fight](fight_culture.md) and destroy. Swearing and insults are an important way of expressing certain kinds of emotions and strong disagreement, we will not give up this tool, we have it and it's useful, so we will use it.
+
 The culture of being offended is [bullshit](bullshit.md), it is a [pseudoleftist](pseudoleft.md) (fascist) invention that serves as a weapon to justify censorship, canceling and bullying of people. Since I love all people, I don't support any weapons against anyone (not even against people I dislike or disagree with). People are offended by language because they're taught to be offended by it by the propaganda, I am helping them unlearn it. [Political correctness](political_correctness.md) is one of the most retarded and toxic things to ever have been invented. Learn to separate being evil and being angry.
 
 ### But don't you think someone can misinterpret your politically incorrect speech for inciting violence, fascism etc.?

forth.md

@@ -2,13 +2,17 @@
 
 { 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 }
 
-Forth ("fourth generation" shortened to four characters due to technical limitations) is a very good, extremely [minimal](minimalism.md) [stack](stack.md)-based untyped [programming language](programming_language.md) that uses [postfix](notation.md) (reverse Polish) notation. Its vanilla form is super simple, it's miles simpler than [C](c.md), it's very [elegant](elegant.md) and its compiler/interpreter can be made very 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) 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 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 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.
 
 { 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 }
 
-{ There is also 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 extend it to some kind of much higher level language, hence the debates. ~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 }
 
-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.
+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.
 
 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.
 
@@ -28,7 +32,7 @@ In fact there are two stacks in Forth: the **parameter stack** (also data stack)
 
 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:
+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:
 
 ```
 : myword operation1 operation2 ... ;
@@ -40,6 +44,8 @@ For example a word that computes and average of the two values on top of the sta
 : average + 2 / ;
 ```
 
+Dictionary is a very important concept in Forth, it usually stores the words as a [linked list](list.md), starting with the oldest word -- this allows for example temporary shadowing of previously defined words with the same name.
+
 Forth programmers 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:
@@ -53,8 +59,13 @@ GENERAL:
 /           divide                  ( a b -- [a/b] )
 =           equals                  ( a b -- [-1 if a = b else 0] )
 <>          not equals              ( a b -- [-1 if a != b else 0] )
-<           less than               ( a b -- [-1 if a < b else 0] )
+<           less than (signed)      ( a b -- [-1 if a < b else 0] )
->           greater than            ( a b -- [-1 if a > b else 0] )
+>           greater than (signed)   ( a b -- [-1 if a > b else 0] )
+u<          less than (unsigned)    ( a b -- [-1 if a u< b else 0] )
+u>          greater than (unsigned) ( a b -- [-1 if a u> b else 0] )
+0=          equals zero               ( a -- [-1 if a = 0 else 0] )
+and         bitwise and             ( a b -- [a&b] )
+or          bitwise or              ( a b -- [a|b] )
 mod         modulo                  ( a b -- [a % b] )
 dup         duplicate                 ( a -- a a )
 drop        pop stack top             ( a -- )
@@ -68,7 +79,7 @@ key         read char on top
 emit        pop & print top as char
 cr          print newline
 cells       times cell width          ( a -- [a * cell width in bytes] )
-depth       pop all & get d.      ( a ... -- [previous stack size] )
+depth       gets stack size       ( a ... -- [previous stack size] )
 quit        don't print "ok" at the end of execution
 bye         quit
 
@@ -83,11 +94,12 @@ 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)
+variable X      creates var named X (X will be a word that pushed its addr.), allocates 1 cell
+create X        assigns X address (without allocating memory)
 N X !           stores value N to variable X
 N X +!          adds value N to variable X
 X @             pushes value of variable X to stack
-N constant C    creates constant C with value N
+N constant C    creates constant C with value N (C will be a new word)
 C               pushes the value of constant C
 
 SPECIAL:
@@ -95,6 +107,8 @@ SPECIAL:
 ( )                       comment (inline)
 \                         comment (until newline)
 ." S"                     print string S (compiles in the string)
+" S"                      create string S (don't print, pushes pointer and length)
+type                      print string (expects pointer and length)
 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.)
 do C loop                 loops from stack top value to stack second from,
@@ -104,12 +118,21 @@ begin C while             like begin/until but loops as long as top != 0
 begin C again             infinite loop
 begin C1 while C2 repeat  loop with middle condition
 leave                     loop break (only for counted loops)
-allot                     allocates memory, can be used for arrays
+N allot                   allocates N bytes of memory (moves end-of-mem ptr), e.g. for arrays
+here                      returns current end-of-mem address ("H" pointer)
+exit                      exits from current word
 recurse                   recursively call the word currently being defined
-see W                     shows the definition of word W
+see W                     shows (decompiles) the definition of word W
+' W                       get address of word W
 ```
 
-example programs:
+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
+
+## Examples
+
+These are some tiny example programs:
 
 ```
 100 1 2 + 7 * / . \ computes and prints 100 / ((1 + 2) * 7)
@@ -123,15 +146,11 @@ cr ." hey bitch " cr \ prints: hey bitch
 : myloop 5 0 do i . loop ; myloop \ prints 0 1 2 3 4
 ```
 
-TODO: local variables, addresses
+And here is our standardized **[divisor tree](divisor_tree.md)** program written in Forth:
-
-## 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
+: printDivisorTree
   dup 3 <= if
     0 swap 1 swap          \ stack now: 0 1 x
   else
@@ -167,7 +186,7 @@ Here is our standardized **[divisor tree](divisor_tree.md)** program written in
   drop drop drop
 ;
 
-: digittonum
+: digitToNum
   dup dup 48 >= swap 57 <= and if
     48 -
   else
@@ -177,13 +196,15 @@ Here is our standardized **[divisor tree](divisor_tree.md)** program written in
 
 : main
   begin \ main loop, read numbers from user
-    0
+    ." enter a number: "
+
+    0   \ number to read
     begin
       key
 
       dup 13 <> while \ newline?
 
-      digittonum
+      digitToNum
 
       dup -1 = if
         bye
@@ -195,6 +216,7 @@ Here is our standardized **[divisor tree](divisor_tree.md)** program written in
     drop \ key
 
     dup 1000 < if
+      dup . cr
       printDivisorTree cr
     else
       bye

gui.md

@@ -4,7 +4,7 @@
 
 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, [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).
+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); text is a [formal language](formal_language.md) that can be handled mathematically well, it is a [stream](stream.md) of data easy to process by any languages, etc. 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.
 

idiot_fallacy.md

@@ -8,6 +8,7 @@ Some examples include:
 
 - "He likes guns, therefore he also likes [war](war.md), violence, hunting etc."
 - "He likes to watch gore videos, therefore he is a violent man and supports violence in real life."
+- "He isn't politically correct, therefore he is a rightist."
 - "He opposes bullying of [pedophiles](pedophilia.md), therefore he is a pedophile." -- This reasoning is guaranteed to be made by every single [American](USA.md) as Americans cannot comprehend any other motive than [self interest](self_interest.md), to them it's physically impossible to try to benefit a group one is not part of.
 - "He opposes [bloat](bloat.md), therefore he supports the [privacy](privacy.md) and [productivity](productivity_cult.md) hysteria and his hobby must be ricing tiling window managers."
 - "He acknowledges the existence and significance of [human races](race.md), therefore he is hostile to other races and supports their genocide."

lrs.md

@@ -93,11 +93,11 @@ Apart from this software a lot of other software developed by other people and g
 - **[dwm](dwm.md)**: Official [suckless](suckless.md) [window manager](wm.md).
 - **[Collapse OS](collapseos.md)** and **[Dusk OS](duskos.md)**: Extremely minimalist [operating systems](operating_system.md).
 - **[LIL](lil.md)**: Tiny embeddable [scripting](script.md) programming language.
-- **[lisp](lisp.md)**: Programming language with a pretty elegant design.
+- **[Lisp](lisp.md)**: Programming language with a pretty elegant design.
 - **[st](st.md)**: Official [suckless](suckless.md) [terminal emulator](terminal.md).
 - **[badwolf](badwolf.md)**: Very small yet very usable [web browser](browser.md).
 - **[netsurf](netsurf.md)**: Nice minimalist web browser.
-- **[FORTH](forth.md)**: Small programming language with very nice design.
+- **[Forth](forth.md)**: Small programming language with very nice 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)).

lrs_dictionary.md

@@ -94,6 +94,7 @@ WORK IN PROGRESS
 | voice assistant                            | personal spy agent                                          |
 | [wayland](wayland.md)                      | whyland                                                     |
 | [webassembly](webassembly.md)              | weebassembly                                                |
+| website                                    | webshite                                                    |
 | Wikipedian                                 | wikipedo                                                    |
 | [Windows](windows.md)                      | Winshit, Windoze, Winbloat, Backdoors? :D                   |
 | [woman](woman.md)                          | femoid                                                      |

people.md

@@ -18,6 +18,7 @@ Here is a list of people notable in technology or in other ways related to [LRS]
 - **[Bill Gates](bill_gates.md)**: founder and CEO of [Micro$oft](microsoft.md), huge faggot
 - **[Bobby Tables](bobby_tables.md)**: full name `Robert'); DROP TABLE Students;--`, appeared in [xkcd](xkcd.md) 327, see also [SQL](sql.md) [injection](injection.md)
 - **[Buddha](buddha.md)** (Siddhartha Gautama): started [buddhism](buddhism.md), a religion seeking enlightenment attained by searching for the ultimate truth and so freeing oneself from all desire
+- **[Charles Moore](charles_moore.md)**: inventor of [Forth](forth.md), advocate of software [minimalism](minimalism.md), oldschool hacker
 - **David Mondou-Labbe** ("""Devine Lu Linvega"""): some weird narcissist soyboy making minimalist stuff, [100r](100r.md) member, cryptocapitalist, [pseudoleftist](pseudoleft.md) fascist, heavily utilizing [NC](nc.md) licenses
 - **[Dennis Ritchie](dennis_ritchie)**: creator of [C](c.md) language and co-creator of [Unix](unix.md)
 - **[Diogenes](diogenes.md)**: based Greek philosopher who opposed all authorities in very cool ways

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)| 74   | 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                           |

teletext.md

@@ -14,4 +14,6 @@ The pages allowed fixed width font text and some very blocky graphics, both coul
 
 - [videotex](videotex.md)
 - [world broadcast](world_broadcast.md)
+- [BBS](bbs.md)
 - [VHS](vhs.md)
+- [ICQ](icq.md)

trolling.md

@@ -12,7 +12,7 @@ Trolling is highly associated with the troll face [meme](meme.md) -- the face ha
 
 A typical example of troll occurred e.g. circa 2006 when in the game [World of Warcraft](wow.md) some guys pulled the world boss Lord Kazzak into Stormwind, one of the game's main cities, where of course this beast towering above all buildings proceeded to assrape the whole city and anything that stood in his way -- the boss couldn't even be killed because he healed every time he killed someone and with so many low level noobs and NPCs in reach he was just healing constantly. This was an ingenious move but of course, Blizzard like a huge unfunny pussy just stepped in, restarted the server and stopped all the fun because constantly dying several hours in a row was making some of their customers potentially unhappy. Blizzard is full of imbeciles who only listen to money of course.
 
-Trolling in chat rooms and forums typically start with so called **[bait](bait.md)**, a deliberately provocative post that's meant to plant a seed of a heated discussion (see also [flame war](flame_war.md)). Such bait will intentionally say something controversial, stupid, logically faulty etc., exactly to provoke a response, it wants to attract some smartass like a fishing bait wants to attract a fish. However the art is in striking the correct balance between stupidity and seriousness, the bait mustn't be too obvious otherwise it will of course be spotted and fail (4chan calls this a "low quality bait", a famous image of highly JPEGed fishing bait is typically attached).
+Trolling in chat rooms and forums typically starts with so called **[bait](bait.md)**, a deliberately provocative post that's meant to plant a seed of a heated discussion (see also [flame war](flame_war.md)). Such bait will intentionally say something controversial, stupid, logically faulty etc., exactly to provoke a response, it wants to attract some smartass like a fishing bait wants to attract a fish. However the art is in striking the correct balance between stupidity and seriousness, the bait mustn't be too obvious otherwise it will of course be spotted and fail (4chan calls this a "low quality bait", a famous image of highly JPEGed fishing bait is typically attached).
 
 Here are some potentially entertaining ways of trolling (they'll be written from the point of view of a fictional character so as to avoid legal responsibility for potential crimes they may inspire lol):
 

unix_philosophy.md

@@ -4,7 +4,7 @@ Unix philosophy is one of the most important and essential approaches to [progra
 
 NOTE: see also *[everything is a file](everything_is_a_file.md)*, another famous design principle of Unix -- this one is rather seen as a Unix-specific design choice rather than part of the general Unix philosophy itself, but it helps paint the whole picture.
 
-As written in the [GNU](gnu.md) coreutils introduction, a Swiss army knife (universal tool that does many things at once) can be useful, but it's not a good tool for experts at work, they note that a professional carpenter will rather use a set of relatively simple, highly specialized tools, each of which is extremely efficient at its job. Unix philosophy brings this observation over to the world of expert programmers.
+As written in the [GNU](gnu.md) coreutils introduction, a Swiss army knife (universal tool that does many things at once) can be useful, but it's not a good tool for experts at work, they note that a professional carpenter will rather use a set of relatively simple, highly specialized tools, each of which is extremely efficient at its job. Unix philosophy brings this observation over to the world of expert programmers. The same analogy is made in book *Starting Forth* about the [Forth](forth.md) programming language that in this sense follows Unix philosophy as well -- while typical programming languages such as [C++](cpp.md) or [Java](java.md) offer a few highly complex, [hardcoded](hardcoded.md), Swiss army knife style constructs (such as [objects](oop.md), [templates](template.md), macros and so on), Forth is built on top of many extremely simple definitions of different *words* out of which the language is built (including such things as control structures or declaring variables for example) AND is left to be further extended by the programmer himself.
 
 In 1978 [Douglas McIlroy](mcilroy.md) has written a short overview of the Unix system (*UNIX Time-Sharing System*) in which he gives the main points of the system's style; this can be seen as a summary of the Unix philosophy (the following is paraphrased):
 

viznut.md

@@ -4,7 +4,7 @@ Viznut (real name Ville-Matias Heikkilä) is a Finnish [demoscene](demoscene.md)
 
 { Lol he's not responding to my emails :] ~drummyfish }
 
-His work is pretty based, in many ways aligned with [LRS](lrs.md), he contributed a great deal to minimalist technology. Unfortunately in some ways he also seems pretty retarded: he uses [facebook](facebook.md), [twitter](twitter.md) and [github](github.md) and also mentions "personal pronouns" on his twitter xD Pretty disappointing TBH. This would make Viznut a [type A fail](fail_ab.md).
+His work is pretty based, in many ways aligned with [LRS](lrs.md), he contributed a great deal to minimalist technology. Unfortunately in some ways he also seems pretty retarded: he uses [facebook](facebook.md), [twitter](twitter.md) and [github](github.md) and also mentions "personal pronouns" on his twitter xD Pretty disappointing TBH. This would make Viznut is an [SJW](sjw.md) and a [type A fail](fail_ab.md). Very sad.
 
 His personal site is at http://viznut.fi/en/ and his blog at http://countercomplex.blogspot.com/. He collects many files at http://viznut.fi/files/, including very interesting writings about demoscene, programming experiments etc.
 

wiki_stats.md

@@ -3,9 +3,9 @@
 This is an autogenerated article holding stats about this wiki.
 
 - number of articles: 588
-- number of commits: 858
+- number of commits: 859
-- total size of all texts in bytes: 4180781
+- total size of all texts in bytes: 4187152
-- total number of lines of article texts: 31680
+- total number of lines of article texts: 31785
 - number of script lines: 262
 - occurences of the word "person": 7
 - occurences of the word "nigger": 91
@@ -35,60 +35,75 @@ longest articles:
 
 top 50 5+ letter words:
 
-- which (2363)
+- which (2367)
-- there (1820)
+- there (1823)
-- people (1619)
+- people (1624)
-- example (1387)
+- example (1389)
-- other (1294)
+- other (1295)
-- number (1165)
+- number (1167)
 - software (1142)
-- about (1121)
+- about (1122)
-- program (943)
+- program (944)
 - because (880)
 - their (876)
-- would (873)
+- would (874)
-- called (813)
+- called (815)
 - being (802)
 - things (794)
 - something (791)
-- language (772)
+- language (773)
-- numbers (757)
+- numbers (761)
 - computer (750)
-- simple (746)
+- simple (748)
-- without (704)
+- without (707)
-- programming (686)
+- programming (687)
-- function (683)
+- function (685)
 - these (675)
 - different (656)
-- however (648)
+- however (651)
-- system (616)
+- system (617)
 - world (613)
 - should (602)
-- doesn (594)
+- doesn (597)
-- point (584)
+- point (585)
 - games (578)
 - society (574)
-- while (563)
+- while (566)
-- drummyfish (548)
+- drummyfish (549)
-- though (543)
+- though (544)
-- simply (540)
+- simply (542)
-- using (535)
+- using (537)
 - still (534)
-- possible (525)
+- possible (524)
 - similar (511)
 - memory (509)
 - https (505)
-- course (501)
+- course (502)
 - technology (497)
 - always (480)
-- basically (477)
+- basically (479)
+- value (475)
 - really (469)
-- value (467)
 - first (457)
 
 latest changes:
 
 ```
+Date:   Tue Aug 6 22:19:44 2024 +0200
+  100r.md
+  books.md
+  c.md
+  consumerism.md
+  fixed_point.md
+  forth.md
+  gui.md
+  javascript.md
+  kiss.md
+  programming_language.md
+  random_page.md
+  wiki_pages.md
+  wiki_stats.md
+  woman.md
 Date:   Mon Aug 5 22:39:28 2024 +0200
   ascii.md
   c.md
@@ -110,24 +125,6 @@ Date:   Mon Aug 5 22:39:28 2024 +0200
   wiki_pages.md
   wiki_stats.md
 Date:   Sun Aug 4 16:49:53 2024 +0200
-  3d_rendering.md
-  aliasing.md
-  anarch.md
-  c.md
-  cc0.md
-  censorship.md
-  disease.md
-  drummyfish.md
-  duskos.md
-  feminism.md
-  forth.md
-  io.md
-  jokes.md
-  license.md
-  lrs_dictionary.md
-  newspeak.md
-  number.md
-  political_correctness.md
 ```
 
 most wanted pages:
@@ -156,7 +153,7 @@ most wanted pages:
 most popular and lonely pages:
 
 - [lrs](lrs.md) (293) 
-- [capitalism](capitalism.md) (237) 
+- [capitalism](capitalism.md) (238) 
 - [c](c.md) (217) 
 - [bloat](bloat.md) (210) 
 - [free_software](free_software.md) (176) 
@@ -182,8 +179,8 @@ most popular and lonely pages:
 - [public_domain](public_domain.md) (76) 
 - [art](art.md) (76) 
 - [foss](foss.md) (75) 
-- [programming_language](programming_language.md) (72) 
+- [programming_language](programming_language.md) (73) 
-- [corporation](corporation.md) (71) 
+- [corporation](corporation.md) (72) 
 - [chess](chess.md) (70) 
 - ...
 - [anal_bead](anal_bead.md) (5) 

xxiivv.md

@@ -2,11 +2,11 @@
 
 { Still researching this shit etc. ~drummyfish }
 
-XXIIVV is a [proprietary](proprietary.md) [soynet](soynet.md) snobbish website and personal [wiki](wiki.md) (in its concept similar to [our wiki](lrs_wiki.md)) of a Canadian [narcissist](egoism.md) [minimalist](minimalism.md)/esoteric programmer/"artist"/[generalist](generalism.md) David Mondou-Labbe who calls himself "Devine Lu Linvega" ([lmao](lmao.md)) who is a part of a highly cringe [fascist](fascism.md) artist/programmer group called [Hundred Rabbits](100r.md) (100r) who live on a small boat or something. David seems to be a normie [SJW](sjw.md) [fascist](fascist.md) (see also [snowflake](snowflake.md)), proclaiming "aggressivity" on his web (under "/ethics.html" on his site). The site is accessible at http://wiki.xxiivv.com/site/home.html. There are some quite good and pretty bad things about it.
+XXIIVV is a [proprietary](proprietary.md) [soynet](soynet.md) snob website and personal [wiki](wiki.md) (in its concept similar to [our wiki](lrs_wiki.md)) of a Canadian [narcissist](egoism.md) [minimalist](minimalism.md)/esoteric programmer/"artist"/[generalist](generalism.md) David Mondou-Labbe who calls himself "Devine Lu Linvega" ([lmao](lmao.md)) who is a part of a highly cringe [SJW](sjw.md) [fascist](fascism.md) "artist"/programmer group called [Hundred Rabbits](100r.md) (100r) who live on a small boat or something. David seems to be a normie [feminist](feminism.md)/[gay](gay.md) [fascist](fascist.md) (see also [snowflake](snowflake.md)), proclaiming "aggressivity" on his web (under "/ethics.html" on his site). He's also a [plan9](plan9.md) fanboy (i.e. a [pseudominimalist](pseudominimalism.md)). The site is accessible at http://wiki.xxiivv.com/site/home.html. There are some quite good and pretty bad things about it.
 
-{ Holy shit his webring is cringe and toxic as fuck. One huge gay nazi wannabe "artist" circlejerk. It's like a small village worth of the kind of psychopaths who draw cute childish drawings of tiny animals with small hearts and love all around while at the same time advocating live castration of anyone who dislikes them. ~drummyfish }
+{ Holy shit his webring is toxic AF, do not research it. Basically a one huge gay nazi wannabe "artist" circlejerk, it's like a small village worth of the kind of [furry](furry.md) psychopaths who like to draw cute cartoon animals while also advocating slow torture and castration of people who dislike them. ~drummyfish }
 
-Firstly let's see the letdowns, which greatly prevail: the site is proprietary and **he licenses his "art" and some of his code under the proprietary [CC-BY-NC-SA](cc_by_nc_sa.md), RETARD ALERT**. This bro is just lacking some chromosomes. He's a [capitalist](capitalist.md) [open soars](open_source.md) fanboy trying to monopolize art by keeping exclusive "commercial intellectual property rights", as if it had any commercial value lol. At least some of his code is [MIT](mit.md), but he also makes fucking **[PROPRIETARY](proprietary.md) PAID software** (e.g. Verreciel), then he somehow tries to manipulate readers of his website to believe he is "against capitalism" :'D (Or is he not? I dunno. Definitely seems to be riding the [eco](eco.md) wave.) The guy also seems **[egoistic](egoism.md) as fuck**, invents weird hipster names and "personal pronouns", has some ugly body disfigurements, wears cringe rabbit costumes, he thinks his art is so good he has to "protect" it with capitalist licenses and writes in a super cringe snobbish/pompous/cryptic/poetic tryhard style probably in an attempt to appear smart while just making it shithard to make sense of his texts -- truly his tech writings are literal torture to read. The only thing he's missing is a fedora. Anyway, that's just a quick sum up of the [cancer](cancer.md).
+Firstly let's see about the letdowns: the site is [proprietary](proprietary.md) and **he licenses his "art" and some of his code under the proprietary [CC-BY-NC-SA](cc_by_nc_sa.md)**, big RETARD ALERT. This means he's a [capitalist](capitalist.md) [open soars](open_source.md) fanboy trying to monopolize art by keeping exclusive "commercial intellectual property rights" (as if his amateur stick figure level "art" had any commercial value lol). At least some of his code is [MIT](mit.md), but he also makes fucking **[PROPRIETARY](proprietary.md) PAID software** (e.g. Verreciel), then he somehow tries to brainwash the readers to believe he is "against capitalism" or what? :'D (Or is he not? I dunno. Definitely seems to be riding the [eco](eco.md) wave.) The guy also seems **[egoistic](egoism.md) as fuck**, invents weird hipster names and "personal pronouns", has some ugly "body modifications", wears cringe rabbit costumes and tries to write in a super cringe pompous/cryptic/poetic tryhard style probably in an attempt to appear smart while just making a fool of himself and, in addition, making it shithard to make any sense of his texts -- truly his tech writings are literal torture to read. The only thing he's missing is a fedora.
 
 There are also nice things though, a few of them being: