Update

beauty.md

@@ -9,11 +9,12 @@ Beauty can perhaps be seen as a [heuristic](heuristic.md), a touch of intuition
 What is beautiful then? As stated, there is a lot of subjectivity, but generally the following attributes are correlated with beauty:
 
 - **[simplicity](minimalism.md)/[minimalism](minimalism.md)**, typically finding simplicity in complexity, e.g. a very short formula or algorithm that describes an infinitely complex [fractal](fractal.md) shape, a simple but valuable equation in physics (*e = m * c^2*), a short computer program that yields rich results ([demoscene](demoscene.md), [code golfing](golf.md), [suckless](suckless.md), [minimal viable program](minimal_viable_program.md), ...).
-- **deepness** -- if something starting very simple, e.g. a single small equation, leads to consequences that may be studied for millennia, for example [prime numbers](prime.md).
+- **deepness** -- if something very simple, let's say a single small equation, has consequences and implications that may be studied into great depth, for example [prime numbers](prime.md).
 - **generality**, i.e. if a simple equation can describe many problems, not just a specific case.
 - **lack of exceptions**, i.e. when our equation works without having to deal with special cases (in programming represented by `if-then` branches).
 - **[symmetry](symmetry.md)**, i.e. when we can e.g. swap variables in the equation and get some kind of opposite result.
-- **unification**, i.e. if multiple nice things meet, for example the [Euler's identity](eulers_identity.md) brings together into one equation the most important numbers in mathematics: *i*, *pi*, 1 and 0.
+- **unification**, or when multiple other beautiful things meet, for example the [Euler's identity](eulers_identity.md) brings together into one equation the most important numbers in mathematics: *i*, *pi*, 1 and 0.
+- **[self containment](self_hosting.md)**, describing itself, applying to itself, not depending on other things
 - **aesthetics**, either of the equation itself (or for example the source code) or the generated object ([fractals](fractal.md), attractors, ...).
 - TODO
 

bootstrap.md

@@ -1,24 +1,26 @@
 # Bootstrap/Boot
 
-In general bootstrapping (from the idiom "pull yourself up by your bootstraps"), sometimes shortened to just *booting*, refers to a clever process of self-establishing some relatively complex system starting from something very small, without much external help. As an example imagine something like a "civilization bootstrapping kit" that contains only few primitive tools along with instructions on how to use those tools to mine ore, turn it into metal out of which one makes more tools which will be used to obtain more material and so on up until having basically all modern technology and factories set up in relatively short time ([civboot](civboot.md) is a project like this). The term *bootstrapping* is however especially relevant in relation to [computer](computer.md) technology -- here it has two main meanings:
+In general bootstrapping (from the idiom "pull yourself up by your bootstraps"), sometimes shortened to just *booting*, refers to a clever process of self-establishing a relatively complex system starting from something very small, without much external help. A nice example comes from the nature: a big plant that can do complex things such as reproduce itself initially grows ("bootstraps") from just a very tiny seed. As another example imagine something like a "civilization bootstrapping kit" that contains only a few primitive tools along with instructions on how to use those tools to mine ore, turn it into metal out of which one makes more tools which will be used to obtain more material and so on up until having basically all modern technology and factories set up in relatively short time ([civboot](civboot.md) is a project like this). The term *bootstrapping* is however especially relevant in relation to [computer](computer.md) technology -- here it has two main meanings:
 
 - The process by which a computer starts and sets up the [operating system](operating_system.md) after power on, which often involves several stages of loading various modules, running several bootloaders etc. This is traditionally called **booting** (*rebooting* means restarting the computer).
 - Utilizing the principle of bootstrapping for making greatly independent [software](software.md), i.e. software that doesn't [depend](depend.md) on other software as it can set itself up. This is usually what **bootstrapping** (the longer term) means. This is also greatly related to **[self hosting](self_hosting.md)**, another principle whose idea is to "implement technology using itself".
 
 ## Bootstrapping: Making Dependency-Free Software
 
-Bootstrapping as a general principle can aid us in creation of extremely free technology by greatly minimizing all its [dependencies](dependency.md), we are able to create a small amount of code that will self-establish our whole computing environment with only very small effort during the process. The topic mostly revolves around designing [programming language](programming_language.md) [compilers](compiler.md), but in general we may be talking about bootstrapping whole computing environments, operating systems etc.
+Bootstrapping -- as the general concept of letting a big thing grow out of a small seed -- may aid us in building extremely [free](free_software.md) (as in freedom), [portable](portability.md), self-contained (and also [secure](security.md)) technology by reducing all its [dependencies](dependency.md) to a minimum. If we are building a big computing environment (such as an operating system), we should make sure that all the big things it contains are made only with the smaller things that are further on built using yet smaller things and so on until some very tiny piece of code, i.e. we shall make sure there is always a way to set this whole system from the ground up, from a very small amount of initial code/tools. Being able to do this means our system is *bootstrappable* and it will allow us for example to set our whole system up on a completely new computing platform (e.g. a new CPU architecture) as long as we can set up that tiny initial prerequisite code. This furthermore removes the danger of dependencies that might kill our system and also allows security freaks to inspect the whole process of the system set up so that they can trust it (because even free software that sometime in the past touched a proprietary compiler can't generally be trusted -- see [trusting trust](trusting_trust.md)). I.e. bootstrapping means creating a very small amount of code that will self-establish our whole computing environment by first compiling small compilers that will then compile more complex compilers which will compile all the tools and programs etc. This topic is discussed for example in designing [programming language](programming_language.md) [compilers](compiler.md) and [operating systems](os.md). For examples of bootstrapping see e.g. [DuskOS](duskos.md) ([collapse](collapse.md)-ready operating system that bootstraps itself from a tiny amount of code), [GNU](gnu.md) [mes](mes.md) (bootstrapping system of the GNU operating system) or [comun](comun.md) (LRS programming language, now self hosted and bootstrappable e.g. from a few hundred lines of [C](c.md)).
 
-**Why be concerned with bootstrapping when we already have our systems set up?** There are many reasons, one of the notable ones is that we may lose our current technology due to societal [collapse](collapse.md), which is not improbable, it keeps happening throughout history over and over, so many people fear (rightfully so) that if by whatever disaster we lose our current computers, Internet etc., we will also lose with it all modern art, data, software we so painfully developed, digitized books, inventions and so on; not talking about the horrors that will follow if we're unable to quickly reestablish our computer networks we are so dependent on. Setting up what we currently have completely from scratch would be extremely difficult, a task for centuries -- just take a while to consider all the activity and knowledge that's required around the globe to create a single computer with all its billions of lines of code worth of software that makes it work. Knowledge of old technology gets lost -- to make modern computers we first needed older, primitive computers, but now that we only have modern computers no one remembers anymore how to make the older computers -- if we lose the current ones, we won't be able to make them, we will lack the tools. Another reason for bootstrapping is independence of technology which brings e.g. [freedom](freedom.md) (your operating system being able to be set up anywhere without some corporation's proprietary driver or hardware unit is pursued by many), robustness, simplicity, ability to bring existing software to new platforms and so on, i.e. things that are practical even in current world.
+**Why be concerned with bootstrapping when we already have our systems set up?** Besides the obvious elegance of this whole approach there are many other practical reasons -- as mentioned, some are concerned about "security", some want portability, control and independence -- one of other notable justifications is that we may lose our current technology due to societal [collapse](collapse.md), which is not improbable as it keeps happening throughout history over and over, so many people fear (rightfully so) that if by whatever disaster we lose our current computers, Internet etc., we will also lose with it all modern art, data, software we so painfully developed, digitized books and so on; not talking about the horrors that will follow if we're unable to quickly reestablish our computer networks we are so dependent on. Setting up what we currently have completely from scratch would be extremely difficult, a task for centuries -- just take a while to consider all the activity and knowledge that's required around the globe to create a single computer with all its billions of lines of code worth of software that makes it work. Knowledge of old technology gets lost -- to make modern computers we first needed older, primitive computers, but now that we only have modern computers no one remembers anymore how to make the older computers -- modern computers are sustaining themselves but once they're gone, we won't know how to make them again, i.e. if we lose computers, we will also lose tools for making computers. This applies on many levels (hardware, operating systems, programming languages and so on).
 
-**[Forth](forth.md) 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) will probably work too.
+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).
 
 **How to do this then?** To make a computing environment that can bootstrap itself you can do it like this:
 
-1. **Make a [simple](kiss.md) [programming language](programming_language.md) L**. You can choose e.g. the mentioned [Forth](forth.md) but you can even make your own, just remember to keep it extremely simple -- simplicity of the base language is the key feature here. The language will serve as tool for writing software for your platform, i.e. it will provide some comfort in programming (so that you don't have to write in assembly) but mainly it will be an **[abstraction](abstraction.md) layer** for the programs, it will allow them to run on any hardware/platform. The language therefore has to be **[portable](portability.md)**; it should probably abstracts things like [endianness](byte_sex.md), native integer size, control structures etc., so as to work nicely on all [CPUs](cpu.md), but it also mustn't have too much abstraction (such as [OOP](oop.md)) otherwise it will quickly get complicated. The language can compile e.g. to some kind of very simple [bytecode](bytecode.md) that will be easy to translate to any [assembly](assembly.md). At first you'll have to temporarily implement L in some already existing language, e.g. [C](c.md). NOTE: in theory you could just make bytecode, without making L, and just write your software in that bytecode, but the bytecode has to focus on being simple to translate, i.e. it will e.g. likely have few opcodes, which will be in conflict with making it at least somewhat comfortable to program on your platform. However one can try to make some compromise and it will save the complexity of translating language to bytecode, so it can be considered ([uxn](uxn.md) seems to be doing this).
-2. **Write L in itself, i.e. [self host](self_hosting.md) it**. This means you'll use L to write a [compiler](compiler.md) of L that outputs L's bytecode. Once you do this, you have a completely independent language and can throw away the original compiler of L written in another language. Now compile L with itself -- you'll get the bytecode of L compiler. At this point you can bootstrap L on any platform as long as you can execute the L bytecode on it -- this is why it was crucial to make L and its bytecode very simple. In theory it's enough to just interpret the bytecode but it's better to translate it to the platform's native machine code so that you get maximum efficiency (the nature of bytecode should make it so that it isn't really more diffiult to translate it than to interpret it). If for example you want to bootstrap on an [x86](x86.md) CPU, you'll have to write a program that translates the bytecode to x86 assembly; if we suppose that at the time of bootstrapping you will only have this x86 computer, you will have to write the translator in x86 assembly manually. If your bytecode really is simple and well made, it shouldn't be hard though (you will mostly be replacing your bytecode opcodes with given platform's machine code opcodes).
-3. **Further help make L bootstrapable**. This means making it even easier to execute the L bytecode on any given platform -- you may for example write the bytecode translators for common platforms like x86, ARM, RISC-V and so on. At this point you have L bootstrappable without any [work](work.md) on the platform you have translators for and on others it will just take a tiny bit of work to write its own translator.
-4. **Write everything else in L**. This means writing the platform itself and software such as various tools and libraries. You can potentially even use L to write a higher level language for yet more comfort in programming. Since everything here is written in L and L can be bootstrapped, everything here can be bootstrapped as well.
+1. **Make a [simple](kiss.md) [programming language](programming_language.md) L**. You can choose e.g. the mentioned [Forth](forth.md) but you can even make your own, just remember to keep it extremely simple -- simplicity of the base language is the key feature here. If you also need a more complex language, write it in L. The language L will serve as tool for writing software for your platform, i.e. it will provide some comfort in programming (so that you don't have to write in assembly) but mainly it will be an **[abstraction](abstraction.md) layer** for the programs, it will allow them to run on any hardware/platform. The language therefore has to be **[portable](portability.md)**; it should probably abstracts things like [endianness](byte_sex.md), native integer size, control structures etc., so as to work nicely on all [CPUs](cpu.md), but it also mustn't have too much abstraction (such as [OOP](oop.md)) otherwise it will quickly get complicated. The language can compile e.g. to some kind of very simple [bytecode](bytecode.md) that will be easy to translate to any [assembly](assembly.md). Make the bytecode very simple (and document it well) as its complexity will later on determine the complexity of the bootstrap binary seed. At first you'll have to temporarily implement L in some already existing language, e.g. [C](c.md). NOTE: in theory you could just make bytecode, without making L, and just write your software in that bytecode, but the bytecode has to focus on being simple to translate, i.e. it will probably have few opcodes for example, which will be in conflict with making it at least somewhat comfortable to program on your platform. However one can try to make some compromise and it will save the complexity of translating language to bytecode, so it can be considered ([uxn](uxn.md) seems to be doing this).
+2. **Write L in itself, i.e. [self host](self_hosting.md) it**. This means you'll use L to write a [compiler](compiler.md) of L that outputs L's bytecode. Once you do this, you have a completely independent language and can start using it instead of the original compiler of L written in another language. Now compile L with itself -- you'll get the bytecode of L compiler. At this point you can bootstrap L on any platform as long as you can execute the L bytecode on it -- this is why it was crucial to make L and its bytecode very simple. In theory it's enough to just interpret the bytecode but it's better to translate it to the platform's native machine code so that you get maximum efficiency (the nature of bytecode should make it so that it isn't really more diffiult to translate it than to interpret it). If for example you want to bootstrap on an [x86](x86.md) CPU, you'll have to write a program (L compiler [backend](backend.md)) that translates the bytecode to x86 assembly; if we suppose that at the time of bootstrapping you will only have this x86 computer, you will have to write the translator in x86 assembly manually. If your bytecode really is simple and well made, it shouldn't be hard though (you will mostly be replacing your bytecode opcodes with given platform's machine code opcodes). Once you have the x86 backend, you can completely bootstrap L's compiler on any x86 computer.
+3. **Further help make L bootstrapable**. This means making it even easier to execute the L bytecode on any given platform -- you may for example write backends (the bytecode translators) for common platforms like x86, ARM, RISC-V, C, Lisp and so on. At this point you have L bootstrappable without any [work](work.md) on the platforms for which you provide backends and on others it will just take a tiny bit of work to write its own translator.
+4. **Write everything else in L**. This means writing the platform itself and software such as various tools and libraries. You can potentially even use L to write a higher level language (e.g. C) for yet more comfort in programming. Since everything here is written in L and L can be bootstrapped, everything here can be bootstrapped as well.
 
 ## Booting: Computer Starting Up
 

c.md

@@ -59,6 +59,7 @@ C is extreme well established, standardized and implemented so there is a great
 - Borland Turbo C: old proprietary compiler with [IDE](ide.md).
 - [sdcc](sdcc.md) (small device C compiler): For small 8 bit [microcontrollers](mcu.md).
 - msvc ([Micro$oft](microsoft.md) visual C++): Badly bloated proprietary C/C++ compiler by a shitty [corporation](corporation.md). Avoid.
+- [M2-Planet](m2_planet.md): Simple compiler of C subset used for bootstrapping the [GNU](gnu.md) operating system.
 - ...
 
 ## Standard Library

consumerism.md

@@ -1,10 +1,10 @@
 # Consumerism
 
-TODO: actual normal article possibly
+Consumerism is [cancer](cancer.md) of society created by [capitalism](capitalism.md), it is the societal tendency towards and force established [culture](culture.md) of making members of society into mere slaves that have to constantly keep consuming products and services just for the sake of keeping bullshit businesses running. Consumers have to stand with open mouths at the end of [producer](productivity_cult.md) asses that are constantly shitting out new and new excrement, and this process must never stop. This soon degenerates into such things as [artificial scarcity](artificial_scarcity.md) and [planned obsolescence](planned_obsolescence.md), things that could last long must be made so that they will NOT last long, they must break soon so that the user has to consume a new one periodically, just like he consumes food, because that's what makes the [corporation](corporation.md) most money. So people are consuming computers, cars, swimming pools, cell phones, doctors, political drama, healthcare, things that make them sick, thing that make them healthy again, and so on and so forth. Even things that could be made to last long, such as buildings, or even forever, such as discovered [information](information.md) -- e.g. old books -- are artificially killed (for example using [copyright](copyright.md)), so that new ones have to be made so that people can keep having [jobs](work.md) and be miserable and don't have to lie on the beach and be happy. Businesses that would want to create non-consumerist products cannot exist -- a business that sells a thing that lasts 100 years will have to wait 100 years to sell another one, so naturally there is no chance for it to survive among those that make it so that they're selling the same thing each half a year, that's why consumerism in capitalism is unavoidable: it simply pays off, it makes the company rich and the richer company survives. Of course this is all pure [bullshit](bullshit.md) that wastes lives of people, makes them miserable consuming machines that get depressed and commit suicides, while also creating enormous amounts of waste that are destroying the environment, just capitalism as usual. Under consumerism your life is expected to go like this: be born, consume, die.
 
-If you don't want to consume, you made a very big mistake by being born.
+If you don't want to consume, you made a very big mistake by being born in [21st century](21st_century.md).
 
-## Rant
+## Rant (Left For Historical Significance)
 
 { Here I'll leave the rant I've written when I was kinda stressed. ~drummyfish }
 

deferred_shading.md

@@ -2,7 +2,7 @@
 
 In computer [graphics](graphics.md) programming deferred shading is a technique for speeding up the rendering of (mainly) [shaded](shading.md) 3D graphics (i.e. graphics with textures, materials, [normal maps](normal_mapping.md) etc.). It is nowadays used in many advanced 3D engines. In principle of course the idea may also be used in 2D graphics and outside graphics.
 
-The principle is following: in normal forward shading (non-deferred) the shading computation is applied immediately to any rendered pixel (fragment) as they are rendered. However, as objects can overlap, many of these expensively computed pixels may be overwritten by pixels of other objects, so many pixels end up being expensively computed but invisible. This is of course wasted computation. Deferred shading only computes shading of the pixels that will end up actually being visible -- this is achieved by **two rendering passes**:
+The principle is following: in normal forward shading (non-deferred) the shading computation is applied immediately to any rendered pixel (fragment) as they are rendered. However, as objects can overlap, many of these expensively computed pixels may be overwritten by pixels of other objects, so many pixels end up being expensively computed but invisible (this is called *overdraw*). This is of course wasted computation. Deferred shading only computes shading of the pixels that will end up actually being visible -- this is achieved by **two rendering passes**:
 
 1. At first geometry is rendered without shading, only with information that is needed for shading (for example [normals](normal.md), material IDs, texture IDs etc.). The rendered image is stored in so called G-buffer which is basically an image in which every pixel stores the above mentioned shading information.
 2. The second pass applies the shading effects by applying the pixel/fragment [shader](shader.md) on each pixel of the G-buffer.

gnu.md

@@ -1,6 +1,6 @@
 # GNU
 
-GNU (*"GNU is Not Unix"*, a [recursive](recursion.md) acronym) is a large software project started by [Richard Stallman](rms.md), the inventor of [free (as in freedom) software](free_software.md), running since 1983 with the goal of creating, maintaining and improving a completely free (as in freedom) [operating system](os.md), along with other free [software](software.md) that computer users might need. The project doesn't tolerate any [proprietary](proprietary.md) software (though it sadly tolerates proprietary data). GNU achieved its goal of creating their free operating system when a [kernel](kernel.md) named [Linux](linux.md) became part of it in the 90s as the last piece of the puzzle -- the system should be called just GNU but is now rather known as GNU/Linux (watch out: most so called "Linux systems" nowadays aren't embraced by GNU as they diverge from GNU's strict policies on what the system should look like, only a handful of operating systems are recommended by GNU). However, the GNU project didn't end and continues to further develop the operating system, or rather a myriad of user software that runs under the operating system -- GNU develops a few of its projects itself and also offers hosting and support (such as free legal defense) for GNU projects developed by volunteers who dedicate their work to them. GNU gave rise to the [Free Software Foundation](fsf.md) and is one of the most important software projects in history of computing.
+GNU (*"GNU is Not Unix"*, a [recursive](recursion.md) acronym) is a large software project established by [Richard Stallman](rms.md), the inventor of [free (as in freedom) software](free_software.md), running since 1983 with the goal of creating, maintaining and improving a completely free (as in freedom) [operating system](os.md), along with other free [software](software.md) that computer users might need. The project doesn't tolerate any [proprietary](proprietary.md) software (though it unfortunately tolerates other proprietary [data](data.md)). GNU achieved its goal of creating their free operating system when a [kernel](kernel.md) named [Linux](linux.md) became part of it in the 90s as the last piece of the puzzle -- the system should be called just GNU but is now rather known as GNU/Linux (watch out: most so called "Linux systems" nowadays aren't embraced by GNU as they diverge from GNU's strict policies on what the system should look like, only a handful of operating systems are recommended by GNU). However, the GNU project didn't end and continues to further develop the operating system, or rather a myriad of user software that runs under the operating system -- GNU develops a few of its projects itself and also offers hosting and support (such as free legal defense) for GNU projects developed by volunteers who dedicate their work to them. GNU gave rise to the [Free Software Foundation](fsf.md) and is one of the most important software projects in history of computing.
 
 The mascot of GNU is literally gnu (wildebeest), it is available under a copyleft license. WARNING: ironically GNU is extremely protective of their brand's "intellectual property" and will rape you if you use the name GNU without permission (see the case of GNU boot). It's quite funny and undermines the whole project a bit.
 
@@ -8,11 +8,13 @@ The GNU/Linux operating system has several variants in a form of a few GNU appro
 
 **GNU greatly prefers [GPL](gpl.md) [licenses](license.md)**, i.e. it strives for [copyleft](copyleft.md) and largely recommends it, even though it will also accept projects under permissive licenses as those are still free. GNU also helps with enforcing these licenses legally and advises developers to transfer their [copyright](copyright.md) to GNU so that they can "defend" the software for them.
 
-**If we still have a bit of freedom in computing nowadays, it is largely to GNU** -- this can't be stressed enough. But although GNU is great and has been one of the best things to happen in software ever, it also has many flaws, for example:
+**If we still have a bit of freedom in computing nowadays, it is largely to GNU** -- this can't be stressed enough. But although GNU is great and has been one of the best things to happen in software ever, it also has **many flaws**, for example:
 
 - **GNU programs are typically [bloated](bloat.md)** -- although compared to [Windows](windows.md) GNU programs are really light as a feather and though GNU programs are also in many cases (but not always) quite optimized, their source code, judged from strictly [suckless](suckless.md) perspective, is mostly huge, which many view as a big issue (it's a common theme, there are [jokes](joke.md) such as GNU actually meaning *Gigantic and Nasty but Unavoidable* and so on). This is likely because GNU chooses to [battle](fight_culture.md) proprietary programs, often by trying to beat them at their own game, so features are preferred over [minimalism](minimalism.md) to stay competitive.
 - **GNU also doesn't mind proprietary non-functional data** (e.g. assets in video games). This goes against [free culture](free_culture.md) and many other free software groups, notably e.g. [Debian](debian.md). Justifications for this range from "data itself can't be harmful" (false), through "we just focus on software" to "we need GNU to be more popular" (i.e. compatible with proprietary games and so on). GNU is also generally **NOT supportive of [free culture](free_culture.md) and even uses copyright to prohibit modifications of their propaganda texts**: the [GFDL](gfdl.md) license they use for texts may contain sections that are prohibited from being modified and so are non-free by definition. They also try to "protect" their names, you can't use the name "GNU" without their permission and so on. This sucks big time and shows some of the movement's darker side.
 - **GNU greatly pushes [copyleft](copyleft.md)**, which we, as well as many others, oppose.
+- **GNU embraces complexity, plays the corporate game and rejects the true way of freedom through [minimalism](minimalism.md)**. GNU basically just makes a mantra of "license with 4 freedoms on every software" and will mostly ignore everything else, they'll just do whatever it takes to stick with the mantra, i.e. GNU tries to achieve popularity, it tries to [fight](fight_culture.md) corporations, gets into activism, it will abuse copyright -- basically GNU wants to become a "superpower of freedom", it doesn't mind hierarchy, state, control, it wants to replace corporations in holding the power over technology, naively believing that it will be using the power for good. That's why they embrace complexity and harmful ways of [capitalist software](capitalist_software.md) (e.g. "GUI in everything", "fuck Unix", ...), that is why they simply copy proprietary software 1 to 1, just with a free license, it helps them be popular (people can drop in replace their proprietary software with GNU software), it also helps them get a [monopoly](bloat_monopoly.md) they don't mind (remember, they even ask people to transfer their copyright to them) as they DO want to become a centralized superpower. Where corporations push JavaScript on websites, GNU will just try to make sure the JavaScript has a free license, instead of rejecting the idea of JavaScript on websites. Where a corporation makes a "smart home", GNU will try to do the same, just with free software, instead of rejecting such a dumb idea in the first place. Anyone who ever saw anything from [history](history.md) knows it's not possible for a good superpower to exist -- no matter how pure it starts, with power WILL come corruption no matter what, any superpower will ALWAYS become evil. The TRUE way of freedom is simply abolishing all superpowers, embracing minimalism and giving power to the people instead of trying to fix maximalism and believe a monopoly will somehow be good. Just take a look at [Wikipedia](wikipedia.md) as a recent example of how these things end. This philosophy is what helps GNU be big in short term but it's also what will kill it in the long term.
+- ...
 
 ## History
 

history.md

@@ -12,7 +12,7 @@ The earliest known appearance of technology related to humans may likely be the
 
 In Greek many city states, such as Athens, Delphi and Sparta formed -- Ancient Greek culture would be seen as the golden age of civilization that would lay foundations to everything we now take for granted; Greeks to some extent advanced technology (e.g. architecture) but especially cultivated [art](art.md), philosophy and [politics](politics.md) -- Athens are credited for inventing [democracy](democracy.md) (though an "early" version, they still had slaves and many classes of citizens without voting power). In 8th century BC Homer created the epic poems Iliad and Odyssey. In 6th century BC Pythagoras describes the [Pythagorean theorem](pythagorean_theorem.md). After 600 BC the Greek [philosophy](philosophy.md) starts to develop which would lead to strengthening of rational, [scientific](science.md) thinking and advancement of [logic](logic.md) and [mathematics](math.md). Some of the most famous Greek philosophers were [Socrates](socrates.md), [Plato](plato.md), [Aristotle](aristotle.md) and [Diogenes](diogenes.md). Around 400 BC **[camera obscura](camera_obscura.md)** was already described in a written text from China where **[gears](gear.md)** also seem to have been invented soon after. Around 300 BC Euklid wrote his famous *Elements*, a mathematical work that proves theorems from basic [axioms](axiom.md). Ancient Greeks could communicate over great distances using **Phryctoria**, chains of fire towers placed on mountains that forwarded messages to one another using light. 234 BC Archimedes described the famous [Archimedes screw](archimedes_screw.md) and created an **[algorithm](algorithm.md) for computing the number [pi](pi.md)**. In 2nd century BC the **Antikythera mechanism, the first known [analog](analog.md) [computer](computer.md)** is made to predict movement of heavenly bodies. Romans are known to have been great builders, they built many roads and such structures as the Pantheon (126 AD) and aqueducts with the use of their own type of **concrete** and advanced understanding of physics.
 
-44 BC Julius Caesar, most famous leader of Ancient Rome, is killed. Rome has to be mentioned as at its time it was the biggest world superpower -- though it was a greatly corrupt, imperialist empire heavily based on work of slaves, Rome advanced technology in many ways, e.g. by inventing concrete, building roads and very long lasting aqueducts. They build monuments that would last for thousands of years, e.g. the famous Colosseum.
+44 BC Julius Caesar, the most famous leader of Ancient Rome, is killed. Rome has to be mentioned as at its time it was the biggest world superpower -- though it was a greatly corrupt, imperialist empire heavily based on work of slaves, Rome advanced technology in many ways, e.g. by inventing concrete, building roads and very long lasting aqueducts. They built monuments that would last for thousands of years, for instance the famous Colosseum.
 
 Around 50 AD Heron of Alexandria, an Egyptian mathematician, created a number of highly sophisticated inventions such as a **vending machine** that accepted coins and gave out holy water, and a cart that could be "programmed" with strings to drive on its own.
 

minimalism.md

@@ -6,16 +6,20 @@ In context of [technology](tech.md) minimalism is a design philosophy which puts
 
 Antoine de Saint-Exupéry 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.*
 
-The concept of minimalism is also immensely important in [art](art.md), for example in architecture and design, and in addition there also exists the generalized concept of **life minimalism** which applies said 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.
+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.
 
 **Minimalism is necessary for [freedom](freedom.md)** as a free technology can only be that over which no one has a [monopoly](bloat_monopoly.md), i.e. which many people and small parties can utilize, study and modify with affordable effort, without needing armies of technicians just for the maintenance of such technology. Minimalism goes against the creeping overcomplexity of technology which always brings huge costs and dangers, e.g. the cost of [maintenance](maintenance.md) and further development, obscurity, inefficiency ("[bloat](bloat.md)", wasting resources), consumerism, the increased risk of bugs, errors and failure.
 
+{ Apparently some people "disagree" with the above and say that "complexity is OK" in free software. I don't think it is possible to disagree on this, it is only possible to not see the issue because of lack of experience. Someone "disagreeing" here means one of two things: he only pretends to care about freedom while actually pursuing other interests (for example creating a "community" around some highly bloated project), OR he has fewer than one brain cell. ~drummyfish }
+
 **It is a beginner mistake to think that minimalism complicates things**: a man not experienced with technology only sees short-term benefits and so he believes that bloated technology is a better choice as it lets him immediately [produce](productivity_cult.md) things faster. Indeed this is mind of a child that wants everything and now without doing any thinking of the future -- of course, writing software in a minimalist programming language will be more difficult and will take more time, but that's simply investing in building good foundations, ones that will last for a very long time, just like building a house of solid stone will be more difficult than quickly building it out of drywall -- a building made of stone will last many centuries, it pays off many times in the future. Of course there is also [capitalism](capitalism.md) playing a huge part as a system hostile to anything permanent, a dystopia that needs to constantly rebuild things anew so it needs things that never last too long. Peasants play along with the system and just [do what it wants them to](just_doing_my_job.md) as again that gives them immediate benefits in form of salary, however it still holds that this technology is bad, it's just that dystopias require and support bad technology. [We](lrs.md) however don't.
 
 There is a so called *[airplane rule](airplane_rule.md)* that states a plane with two engines has twice as many engine problems than a plane with a single engine.
 
+[Alan Kay](alan_kay.md), a famous [hacker](hacking.md), let himself be heard that he experienced a revelation upon reading manual to the [Lisp](lisp.md) programming language once he saw that the whole programming language's code was written on half a page in the manual itself. "These are Maxwell’s Equations of software!" he exclaimed -- this is the essence of true programming. Not huge codebases maintained by hundreds of programmer, but mathematics, seeking minimal equations and [beauty](beauty.md) are the interest of a true programmer.
+
 Up until recently in [history](history.md) every engineer would tell you that *the better machine is that with fewer moving parts*. This still seems to hold e.g. in [mathematics](math.md), a field not yet so spoiled by huge commercialization and mostly inhabited by the smartest people -- there is a tendency to look for the most minimal equations -- such equations are considered [beautiful](beauty.md). Science also knows this rule as the [Occam's razor](occams_razor.md). In technology invaded by aggressive commercialization the situation is different, minimalism lives only in the underground and is ridiculed by the mainstream propaganda. Some of the minimalist movements, terms and concepts at least somewhat connected to minimalism include (watch out for [SJW](sjw.md)s, [pseudominimalism](pseudominimalism.md), Nazis etc., we don't automatically fully embrace all things on this list):
 
 - [suckless](suckless.md)

wiki_stats.md

@@ -3,9 +3,9 @@
 This is an autogenerated article holding stats about this wiki.
 
 - number of articles: 586
-- number of commits: 839
-- total size of all texts in bytes: 4075164
-- total number of lines of article texts: 30788
+- number of commits: 840
+- total size of all texts in bytes: 4078553
+- total number of lines of article texts: 30792
 - number of script lines: 262
 - occurences of the word "person": 7
 - occurences of the word "nigger": 89
@@ -35,8 +35,8 @@ longest articles:
 
 top 50 5+ letter words:
 
-- which (2318)
-- there (1763)
+- which (2320)
+- there (1773)
 - people (1567)
 - example (1346)
 - other (1275)
@@ -44,51 +44,71 @@ top 50 5+ letter words:
 - software (1131)
 - about (1096)
 - program (921)
-- their (865)
-- because (852)
-- would (839)
+- their (866)
+- because (853)
+- would (840)
 - being (792)
 - called (790)
 - things (764)
 - language (760)
 - something (759)
 - numbers (747)
-- computer (743)
+- computer (744)
 - simple (731)
 - without (694)
 - programming (678)
-- function (673)
+- function (674)
 - these (655)
 - different (647)
 - however (639)
 - system (599)
 - world (598)
-- should (591)
+- should (593)
 - doesn (579)
 - games (573)
 - point (567)
 - society (563)
 - while (548)
-- drummyfish (535)
+- drummyfish (536)
 - though (534)
 - still (523)
-- using (518)
-- simply (509)
-- possible (508)
+- using (517)
+- possible (515)
+- simply (508)
 - memory (508)
 - similar (502)
 - course (497)
 - technology (496)
 - https (486)
-- always (469)
+- always (471)
 - really (464)
 - basically (452)
-- extremely (450)
+- extremely (449)
 - value (448)
 
 latest changes:
 
 ```
+Date:   Wed Jul 17 20:31:45 2024 +0200
+  3d_model.md
+  adam_smith.md
+  debugging.md
+  diogenes.md
+  exercises.md
+  future.md
+  history.md
+  julia_set.md
+  kwangmyong.md
+  main.md
+  optimization.md
+  political_correctness.md
+  python.md
+  random_page.md
+  sorting.md
+  wavelet_transform.md
+  wiki_pages.md
+  wiki_stats.md
+  wikidata.md
 Date:   Tue Jul 16 16:21:52 2024 +0200
   21st_century.md
   adam_smith.md
@@ -105,23 +125,6 @@ Date:   Tue Jul 16 16:21:52 2024 +0200
   wiki_stats.md
   woman.md
 Date:   Sun Jul 14 22:12:15 2024 +0200
-  adam_smith.md
-  censorship.md
-  how_to.md
-  iq.md
-  lgbt.md
-  main.md
-  random_page.md
-  wiki_pages.md
-  wiki_stats.md
-Date:   Sun Jul 14 16:50:21 2024 +0200
-  adam_smith.md
-  cheating.md
-  drummyfish.md
-  encyclopedia.md
-  faq.md
-  jokes.md
-  main.md
 ```
 
 most wanted pages:
@@ -166,7 +169,7 @@ most popular and lonely pages:
 - [programming](programming.md) (84) 
 - [fun](fun.md) (83) 
 - [free_culture](free_culture.md) (81) 
-- [censorship](censorship.md) (80) 
+- [censorship](censorship.md) (81) 
 - [less_retarded_society](less_retarded_society.md) (78) 
 - [fight_culture](fight_culture.md) (78) 
 - [math](math.md) (77) 
@@ -177,8 +180,8 @@ most popular and lonely pages:
 - [shit](shit.md) (74) 
 - [art](art.md) (73) 
 - [programming_language](programming_language.md) (72) 
+- [chess](chess.md) (69) 
 - [internet](internet.md) (68) 
-- [float](float.md) (68) 
 - ...
 - [wiki_pages](wiki_pages.md) (4) 
 - [whale](whale.md) (4)