Update

altruism.md

@@ -1,3 +1,7 @@
 # Altruism
 
 *Not to be confused with [autism](autism.md).*
+
+TODO
+
+Rightists often make an extremely funny reasoning error (probably on purpose) to justify their own [fascist](fascism.md) behavior; they claim that "altruism doesn't exist" because "altruism still seeks to satisfy one's ego and is therefore self interest". Well, firstly this is either wrong, as [selflessness](selflessness.md) isn't defined by obtaining no reward but rather by acting in the interest of others without exploiting them, and secondly even if you define self interest conveniently in a way that makes your claim technically correct, it still completely misses the point! You can behave in a good or evil way, your definitions don't matter. No matter what words you use, you are just trying to excuse fascist behavior in a situation when you can choose to not behave like a fascist -- imagine someone shooting a child and justifying it like "well, I had to do it because I wanted that child's lollipop and I can't behave without self interest because I can't define selflessness".

bazaar.md

@@ -6,4 +6,4 @@ Watch out: Raymond used to be an oldschool [hacker](hacking.md) who however, lik
 
 { The online version is not very long, the writing style is good and there are nice, catchy observations about software development, however it's still quite shitty, towards the end I was falling asleep, only the capitalist trigger words kept me awake eventually. But there are some nice things, like "plan to throw one away", i.e. when you want to write something, you'll probably have to write it once badly, by which you really understand the issue, then you throw it away and implement it again, this time well. ~drummyfish }
 
-Here is a small **summary**: ESR used to believe software beyond some complexity threshold (e.g. [operating system](os.md) kernel or a big text editor) has to be developed mainly by a small team that closely communicates, carefully fixes bugs that users report and releases stable versions once in relatively long time -- yes, even if the software is [FOSS](foss.md) and development is transparent. This is called the *Cathedral* method as the development is similar to the careful, highly centrally planned building of a cathedral -- one example was e.g. [gcc](gcc.md) (and any proprietary software, as they basically have no other option). However after seeing [Linux](linux.md) (a very complex project) being developed by great many people in a very decentralized manner, with the central coordinator doing relatively little work, and having very short release cycles (even of buggy, unstable versions), he concluded it can work differently -- he called this the *Bazaar* method, i.e. one that looks a bit [chaotic](chaos.md) at first, but which statistically still converges to establishing good design in the end. He says the biggest invention of [Linus Torvalds](torvalds.md) isn't Linux but its development model. He examines how and why it works because he sees it as the superior method, and he also tests the method on his own project ([fetchmail](fetchmail.md)) with which he immediately sees a great success. He notes several things, e.g. the following. Users being at the same time programmers (codevelopers) and vice versa is key because firstly programmers really care about what they write (because they use it) and secondly we get nice bug reports (in programmer terms). "Given enough eyeballs, all bugs are shallow" says that with many users/programmers basically all bugs get spotted and fixed quickly, which is helped by the rapid release cycles -- if someone fixes it quickly, others see it's fixed and stop working on their more complicated fixes. This kind of parallelizes [debugging](debugging.md) (and also other things such as design change exploration). Quick releases reward contributors, they see their fixes immediately, contributors get motivated ("Treat your testers as your most valuable resource and they will respond by becoming your most valuable resource."), even the "work no one wants to do" gets done. Bazaar project needs several things. Firstly good Internet (that's why Linux coincided with cheap access to Internet). Secondly it can't be started from scratch, someone has to make some basic project basically alone, and it should be some truly honest project (not something that just aims for profit), usually starting with a programmer "scratching his [own itch](own_itch.md)" -- it's enough to make a project that shows promise so that people start jumping in. The ["leader"](bdfl.md) doesn't have to be genius but he has to be able to recognize good design choices of contributors and he must be "good with people". Then he goes on to compare it to free market and other crap, he basically concludes managers are useless and they just pretend to be useful :D
+Here is a small **summary**: ESR used to believe software beyond some complexity threshold (e.g. [operating system](os.md) kernel or a big text editor) has to be developed mainly by a small team that closely communicates, carefully fixes bugs that users report and releases stable versions once in relatively long time -- yes, even if the software is [FOSS](foss.md) and development is transparent. This is called the *Cathedral* method as the development is similar to the careful, highly centrally planned building of a cathedral -- one example was e.g. [gcc](gcc.md) (and any proprietary software, as they basically have no other option). However after seeing [Linux](linux.md) (a very complex project) being developed by great many people in a very decentralized manner, with the central coordinator doing relatively little work, and having very short release cycles (even of buggy, unstable versions), he concluded it can work differently -- he called this the *Bazaar* method, i.e. one that looks a bit [chaotic](chaos.md) at first, but which statistically still converges to establishing good design in the end. He says the biggest invention of [Linus Torvalds](torvalds.md) isn't Linux but its development model. He examines how and why it works because he sees it as the superior method, and he also tests the method on his own project ([fetchmail](fetchmail.md)) with which he immediately sees a great success. He notes several things, e.g. the following. Users being at the same time programmers (codevelopers) and vice versa is key because firstly programmers really care about what they write (because they use it) and secondly we get nice bug reports (in programmer terms). "Given enough eyeballs, all bugs are shallow" (*Linus's law*) says that with many users/programmers basically all bugs get spotted and fixed quickly, which is helped by the rapid release cycles -- if someone fixes it quickly, others see it's fixed and stop working on their more complicated fixes. This kind of parallelizes [debugging](debugging.md) (and also other things such as design change exploration). Quick releases reward contributors, they see their fixes immediately, contributors get motivated ("Treat your testers as your most valuable resource and they will respond by becoming your most valuable resource."), even the "work no one wants to do" gets done. Bazaar project needs several things. Firstly good Internet (that's why Linux coincided with cheap access to Internet). Secondly it can't be started from scratch, someone has to make some basic project basically alone, and it should be some truly honest project (not something that just aims for profit), usually starting with a programmer "scratching his [own itch](own_itch.md)" -- it's enough to make a project that shows promise so that people start jumping in. The ["leader"](bdfl.md) doesn't have to be genius but he has to be able to recognize good design choices of contributors and he must be "good with people". Then he goes on to compare it to free market and other crap, he basically concludes managers are useless and they just pretend to be useful :D

binary.md

@@ -1,10 +1,64 @@
 # Binary
 
-The word binary in general refers to having [two](two.md) choices; in [computer science](compsci.md) binary refers to the base 2 numeral system, i.e. a system of writing numbers with only two symbols, usually [1](one.md)s and [0](zero.md)s. We can write any number in binary just as we can with our everyday [decimal](decimal.md) system, but binary is more convenient for computers because this system is easy to implement in [electronics](electronics.md) (a switch can be on or off, i.e. 1 or 0; systems with more digits were tried but unsuccessful, they failed miserably in reliability -- see e.g. [ternary](ternary.md) computers). The word *binary* is also by extension used for non-textual computer [files](file.md) such as native [executable](executable.md) programs or asset files for games.
+The word binary in general refers to having [two](two.md) choices or "two of a thing"; in [computer science](compsci.md) binary refers to the base 2 numeral system, i.e. a system of writing numbers with only two symbols, usually [1](one.md)s and [0](zero.md)s, which are commonly interpreted *true* vs *false*. We can write any [number](number.md) in binary just as we can with our everyday [decimal](decimal.md) system (which uses ten digits, as opposed to two), but binary is more convenient for [computers](computer.md) because this system is easy to implement in [electronics](electronics.md) (a switch can be on or off, i.e. 1 or 0; systems with more digits were tried but unsuccessful, they failed miserably in reliability -- see e.g. [ternary](ternary.md) computers). The word *binary* is also by extension used for non-textual computer [files](file.md) such as native [executable](executable.md) programs or asset files for games.
 
-Operations with binary values are very often handled with so called **[Boolean](bool.md) algebra**, which is originally a type of algebra that works with [sets](set.md) and their operations such as conjunction, disjunction etc. It's just a kind of abstract algebra, i.e. a set of values, operations and rules that are consistent and can be used in many situations; a Boolean algebra can generally operate with more than just two values, however as programmers only deal with 1s and 0s, they adopted the binary Boolean algebra, so in context of computers we understand Boolean algebra to be the one working with 1s and 0s and we interpret the operations of the algebra as [logic](logic.md) operations ([AND](and.md), [OR](or.md), NOT, ...). Boolean operations are so widely used that the word "boolean" is oftentimes used synonymously with "binary", i.e. many programming languages have e.g. a [data type](data_type.md) called `bool` that allows two values (*true* and *false*).
+One binary digit (a "place" for binary value in computer memory) can be used to store exactly 1 [bit](bit.md) of [information](information.md). We mostly use binary digits in two ways:
 
-One binary digit can be used to store exactly 1 [bit](bit.md) of [information](information.md). So the number of places we have for writing a binary number (e.g. in computer memory) is called a number of bits or bit width. A bit width *N* allows for storing 2^N values (e.g. with 2 bits we can store 4 values: 0, 1, 2 and 3, in binary 00, 01, 10 and 11).
+1. With single bits we represent basic **[logic](logic.md)** values, i.e. *true* and *false*, and perform logic operations (e.g. [AND](and.md), [OR](or.md) etc.) with so called **[Boolean](bool.md) algebra**.
+2. By grouping multiple bits together we create a **base-2 numeral system** that behaves in the same way as our decimal system and can be used to record numbers. We can build this numeral system with the above mentioned Boolean algebra, i.e. we extend our simple one bit system to multi bit system allowing to work not just with two values (*true* and *false*) but with many distinct values (whole numbers, from which we may later construct fractions etc.). Thanks to this we can implement algebraic operations such as addition, multiplication, square roots etc.
+
+## Boolean Algebra ("True/False Logic")
+
+In binary we start by working with single [bits](bit.md) -- each bit can hold two values, 1 and 0. We may see bits now like "simple numbers", we'll want to do operations with them, but they can only ever be one of the two values. Though we can interpret these values in any way -- e.g. in electronics we see them as high vs low [voltage](voltage.md) -- in mathematics we traditionally turn to using [logic](logic.md) and interpret them as meaning *true* (1) and *false* (0). This will further allow us to apply all the knowledge and theory we have gathered about logic, such as formulas that allow us to simplify binary expressions etc.
+
+Next we want to define "operations" we can perform on single bits -- for this we use so called **[Boolean](bool.md) algebra**, which is originally a type of abstract algebra that works with [sets](set.md) and their operations such as conjunction, disjunction etc. Boolean algebra can be seen as a sort of simplified version of what we do in "normal" elementary school algebra -- just as we can add or multiply numbers, we can do similar things with individual bits, we just have a bit different operations such as logic [AND](and.md), logic [OR](or.md) and so on. Generally Boolean algebra can operate with more than just two values, however that's more interesting to mathematicians; for us all we need now is a binary Boolean algebra -- that's what programmers have adopted for their field. It is the case that in context of computers and programming we implicitly understand Boolean algebra to be the one working with 1s and 0s, i.e. the binary version, so the word **"boolean"** is essentially used synonymously with "binary" around computers. Many [programming languages](programming_language.md) have a [data type](data_type.md) called `boolean` or `bool` that allows represents just two values (*true* and *false*).
+
+The very basic operations, or logic [functions](function.md), of Boolean algebra are:
+
+- **NOT** (negation, `!`): Done with single bit, turns 1 into 0 and vice versa.
+- **[AND](and.md)** (conjunction, `/\`): Done with two bits, yields 1 only if both input bits are 1, otherwise yields 0. This is similar to multiplication (1 * 1 = 1, 1 * 0 = 0, 0 * 1 = 0, 0 * 0 = 0) .
+- **[OR](or.md)** (disjunction, `\/`): Done with two bits, yields 1 if at least one of the input bits is 1, otherwise yields 0. This is similar to addition (1 + 1 = 1, 1 + 0 = 1, 0 + 1 = 1, 0 + 0 = 0).
+
+There are also other function such as [XOR](xor.md) (exclusive OR, is 1 exactly when the inputs differ) and negated versions of AND and OR (NAND and NOR, give opposite outputs of the respective non-negated function). The functions are summed up in the following table (we all these kinds of tables **truth tables**):
+
+| x   | y   | NOT x | x AND y | x OR y | x XOR y | x NAND y | x NOR y | x NXOR y |
+| --- | --- | ----- | ------- | ------ | ------- | -------- | ------- | -------- |
+| 0   | 0   | 1     | 0       | 0      | 0       | 1        | 1       | 1        |
+| 0   | 1   | 1     | 0       | 1      | 1       | 1        | 0       | 0        |
+| 1   | 0   | 0     | 0       | 1      | 1       | 1        | 0       | 0        |
+| 1   | 1   | 0     | 1       | 1      | 0       | 0        | 0       | 1        |
+
+In fact there exists more functions with two inputs and one output (16 in total, computing this is left as exercise :]). However not all are named -- we only use special names for the commonly used ones, mostly the ones in the table above.
+
+An interesting thing is that we may only need one or two of these functions to be able to create all other function (this is called *functional completeness*); for example it is enough to only have *AND* and *NOT* functions together to be able to construct all other functions. Functions *NAND* and *NOR* are each enough by themselves to make all the other functions! For example *NOT x = x NAND x*, *x AND y = NOT (x NAND y) = (x NAND y) NAND (x NAND y)*, *x OR y = (x NAND x) NAND (y NAND y)* etc.
+
+Boolean algebra further tells us some basic laws we can use to simplify our expressions with these functions, for example:
+
+- trivial laws:
+  - *x AND 0 = 0*
+  - *x OR 1 = 1*
+  - *x AND 1 = x*
+  - *x OR 0 = x*
+  - *x AND x = x*
+  - *x OR x = x*
+  - commutativity of OR: *x OR y = y OR x*
+  - commutativity of OR: *x AND y = y AND x*
+  - associativity of AND: *x OR (x OR x) = (x OR x) OR x*
+  - associativity of AND: *x AND (x AND x) = (x AND x) AND x*
+  - ...
+- distributive laws:
+  - *x AND (y OR z) = (x AND y) OR (x AND z)*
+  - *x OR (y AND z) = (x OR y) AND (x OR z)*
+- De Morgan's laws:
+  - NOT (x AND y) = NOT(x) OR NOT(y)
+  - NOT (x OR y) = NOT(x) AND NOT(y)
+- ...
+
+By combining all of these simple functions it is possible to construct not only operations with whole numbers and traditional algebra, but also a whole computer that renders 3D graphics and sends multimedia over the Internet. For more details see **[logic circuits](logic_circuit.md)**.
+
+## Base-2 Numeral System
+
+While we may use a single bit to represent two values, we can group more bits together and become able to represent more values; the more bits we group together, the more values we'll be able to represent as possible combinations of the values of individual bits. The number of bits, or "places" we have for writing a binary number is called a number of bits or **bit width**. A bit width *N* allows for storing 2^*N* values -- e.g. with 2 bits we can store 2^2 = 4 values: 0, 1, 2 and 3, in binary 00, 01, 10 and 11. With 3 bits we can store 2^3 = 8 values: 0 to 7, in binary 000, 001, 010, 011, 100, 101, 110, 111. And so on.
 
 At the basic level binary works just like the [decimal](decimal.md) (base 10) system we're used to. While the decimal system uses powers of 10, binary uses powers of 2. Here is a table showing a few numbers in decimal and binary:
 
@@ -36,7 +90,21 @@ At the basic level binary works just like the [decimal](decimal.md) (base 10) sy
 
 To **convert from decimal** to binary we can use a simple [algorithm](algorithm.md) that's again derived from the above. Let's say we have a number *X* we want to write in binary. We will write digits from right to left. The first (rightmost) digit is the remainder after integer division of *X* by 2. Then we divide the number by 2. The second digit is again the remainder after division by 2. Then we divide the number by 2 again. This continues until the number is 0. For example let's convert the number 22 to binary: first digit = 22 % 2 = **0**; 22 / 2 = 11, second digit = 11 % 2 = **1**; 11 / 2 = 5; third digit = 5 % 2 = **1**; 5 / 2 = 2; 2 % 2 = **0**; 2 / 2 = 1; 1 % 2 = **1**; 1 / 2 = 0. The result is **10110**.
 
-TODO: operations in binary
+NOTE: once we start grouping bits to create numbers, we typically still also keep the possibility to apply the basic Boolean operations to these bits. You will sometimes encounter the term **bitwise** operation which signifies an operation that works on the level of single bits by applying given function to bits that correspond by their position; for example a bitwise AND of values `1010` and `1100` will give `1000`.
+
+**Operations with binary numbers**: again, just as we can do arithmetic with decimal numbers, we can do the same with binary numbers, even the [algorithms](algorithm.md) we use to perform these operations with pen and paper work basically the same. For example the following shows multiplication of `110` (6) by `11` (3) to get `10010` (18):
+
+```
+  110 *
+   11
+  ___
+  110
+ 110
+ ____
+10010
+```
+
+All of these operations can be implemented just using the basic boolean functions -- see [logic circuits](logic_circuit.md) and [CPUs](cpu.md).
 
 In binary it is very simple and fast to divide and multiply by powers of 2 (1, 2, 4, 8, 16, ...), just as it is simply to divide and multiple by powers of 10 (1, 10, 100, 1000, ...) in decimal (we just shift the radix point, e.g. the binary number 1011 multiplied by 4 is 101100, we just added two zeros at the end). This is why as a programmer **you should prefer working with powers of two** (your programs can be faster if the computer can perform basic operations faster).
 
@@ -59,6 +127,7 @@ As anything can be represented with numbers, binary can be used to store any kin
 
 - [unary](unary.md)
 - [ternary](ternary.md)
+- [logic circuit](logic_circuit.md)
 - [bit](bit.md)
 - [hexadecimal](hexadeciaml.md)
 - [De Morgan's laws](de_morgans_laws.md)

math.md

@@ -1,9 +1,11 @@
 # Mathematics
 
-Mathematics (also math or maths, from Greek *mathematicos*, *learned*) is the best [science](science.md) (yes, it is a formal science), which deductively deals with [numbers](number.md) and other [abstract](abstraction.md) structures with the use of pure [logic](logic.md), in as rigorous and objective way as possible. In fact it's the only true science that can actually prove things thanks to its tool of mathematical [proof](proof.md) (other sciences may only disprove or show something to be very likely). It is immensely important in [programming](programming.md) and [computer science](compsci.md). Mathematics is possibly the intellectually most difficult field to study in depth, meant for the smartest people; the difficulty, as some mathematicians themselves say, comes especially from the extremely deep abstraction (pure mathematics often examines subjects that have no known connection to reality and only exist as a quirk of logic itself). It is said that mathematics is the only **universal [language](language.md)** in our universe -- if we ever get in contact with an intelligent alien civilization, mathematics is likely to be used for communication.
+Mathematics (also math or maths, from Greek *mathematicos*, *learned*) is the best [science](science.md) (yes, it is a formal science), which deductively deals with [numbers](number.md) and other [abstract](abstraction.md) structures with the use of pure [logic](logic.md), in as rigorous and objective way as possible. In fact it's the only true science that can actually prove things thanks to its tool of mathematical [proof](proof.md) (other sciences may only disprove or show something to be very likely). It is immensely important in [programming](programming.md) and [computer science](compsci.md). Mathematics is possibly the intellectually most difficult field to study in depth, meant for the smartest people; the difficulty, as some mathematicians themselves say, comes especially from the extremely deep abstraction (pure mathematics often examines subjects that have no known connection to reality and only exist as a quirk of logic itself). It is said that mathematics is the only **universal [language](language.md)** in our universe -- if we ever get in contact with an intelligent alien civilization, mathematics is likely to be used for communication. While most people only ever learn basic algebra and some other mechanical operations that are necessary for mathematics, true mathematics is not about blindly performing calculations, it is a creative discipline that constructs [proofs](proof.md) from basic [axioms](axiom.md), something that can frequently be extremely hard to do.
 
 Some see math not as a science but rather a discipline that develops formal tools for "true sciences". The reasoning is usually that a science has to use [scientific method](scientific_method.md), but that's a limited view as scientific method is not the only way of obtaining reliable knowledge. Besides that math can and does use the principles of scientific method -- mathematicians first perform "experiments" with numbers and generalize into [conjectures](conjecture.md) and later "strong beliefs", however this is not considered [good enough](good_enough.md) in math as it actually has the superior tool of [proof](proof.md) that is considered the ultimate goal of math. I.e. math relies on [deductive](deduction.md) reasoning (proof) rather than less reliable [inductive](induction.md) reasoning (scientific method) -- in this sense mathematics is more than a science.
 
+Mathematics as a whole is constructed with [logic](logic.md) from some basic system -- historically it was based e.g. on [geometry](geometry.md), however modern mathematics has since about 19th century been built on top of **[set theory](set_theory.md)**, i.e. all thing such as [numbers](number.md), [algebra](algebra.md) and [functions](function.md) are all derived from just the existence of [sets](set.md) and [classes](class.md) and some basic operations with them. Specifically *Zermelo–Fraenkel set theory with [axiom of choice](axiom_of_choice.md)* (ZFC, made in the beginning of 20th century) is mostly used nowadays -- it's a theory with 9 [axioms](axiom.md) that we can consider kind of ["assembly"](assembly.md) of mathematics.
+
 [Soydevs](soydev.md), coding monkeys (such as webdevs) and just retards in general hate math because they can't understand it. They think they can do programming without math, which is just ridiculous. This delusion stems mostly from these people being highly incompetent and without proper education -- all they've ever seen was a shallow if-then-else [python](python.md) "[coding](coding.md)" of baby programs or point-and-click "coding" in gigantic [GUI](gui.md) frameworks such as [Unity](unity.md) where everything is already preprogrammed for them. Of course this is not completely their fault (only partially), the [shitty system](capitalism.md) just produces robot slaves who can't really think, just do some task to blindly produce goods for the economy etcetc. By Dunning–Kruger they can't even see how incompetent they are and what real programming is about. In reality, this is like thinking that being able to operate a calculator makes you a capable mathematician or being able to drive a car makes you a capable car engineer. Such people will be able to get jobs and do some repetitive tasks such as web development, [Unity](unity.md) game development or system administration, but they will never create anything innovative and all they will ever make will be ugly, [bloated](bloat.md) [spaghetti](spaghetti.md) solution that will likely do more harm than good.
 
 On the other hand, one does not have to be a math [PhD](phd.md) in order to be a good programmer in most fields. Sure, knowledge and overview of advanced mathematics is needed to excel, to be able to spot and sense elegant solutions and to innovate in big ways, but beyond these essentials that anyone can learn with a bit of will it's really more about just not being afraid of math, accepting and embracing the fact that it permeates what we do and studying it when the study of a new topic is needed.
@@ -22,7 +24,7 @@ Following are some math areas and topics which a programmer should be familiar w
 - **[calculus](calculus.md) and [differential equations](differential_equation.md)**: just essential for advanced math and many fields (graphics, machine learning, [electronics](electronics.md), physics, any optimization, ...).
 - **theoretical [computer science](compsci.md)**: [computational complexity](computational_complexity.md) (very important), [computability](computability.md), [formal languages](formal_language.md), computational models ([automata](automaton.md), [Turing machines](turing_machine.md), ...), ...
 - **[graph theory](graph.md)**: generally useful tools, especially important e.g. in networks or indexing structures in [databases](database.md).
-- **[number](number.md) and [set](set.md) theory**: sets of numbers ([natural](natural_number.md), [rational](rational_number.md), [real](real_number.md), [complex](complex_number.md), ...), [prime numbers](prime.md) (important e.g. for [cryptography](cryptography.md), [quantum computing](quantum.md), ...), ...
+- **[number](number.md) and [set](set.md) theory**: [sets](set.md) and operations with them (basis of all mathematics), [classes](class.md), sets of numbers ([natural](natural_number.md), [rational](rational_number.md), [real](real_number.md), [complex](complex_number.md), ...), [prime numbers](prime.md) (important e.g. for [cryptography](cryptography.md), [quantum computing](quantum.md), ...), ...
 - **discrete math**: basic structures such as [groups](group.md) and [fields](field.md), [abstract algebras](abstract_algebra.md) and the properties of these structures.
 - **[signal processing](signal_processing.md)**: [Fourier transform](fourier_transform.md) and other integral transforms (important e.g. for [compression](compression.md) and analysis of signals), [aliasing](aliasing.md), filter theory, ...
 - **[numerical methods](numerical.md)**: for simulations and [approximations](approximation.md) of solutions to problems we can't solve exactly.

open_console.md

@@ -42,7 +42,7 @@ Some notable open consoles (which fit the definition at least loosely) are liste
 - `-` = discontinued
 
 | name                            | CPU       |RAM (K)| ROM (K)| display      | year | notes                           |
-| ------------------------------- | --------- | ----- | ------ | ------------ | ---- | ------------------- |
+| ------------------------------- | --------- | ----- | ------ | ------------ | ---- | ------------------------------- |
 |[Arduboy](arduboy.md)            |8b 16 MHz  | 2.5   | 32     | 64x32 1b     | 2015 | * A C +, tiny                   |
 |[Gamebuino](gamebuino.md)        |8b 16 MHz  | 2     | 32     | 84x48 1b     | 2014 | + A -, SD                       |
 |[Pokitto](pokitto.md)            |32b 48 MHz | 36    | 256    | 220x176      | 2018 |* C +, ext. hats, SD             |
@@ -51,7 +51,7 @@ Some notable open consoles (which fit the definition at least loosely) are liste
 |[Nibble](nibble.md)              |32b 160 MHz| 80    | 4000   | 128x128      | 2021 |A, AAA bat.                      |
 |[UzeBox](uzebox.md)              |8b 28 MHz  | 4     | 64     | 360x240      | 2008 |C, +                             |
 |[Tiny Arcade](tiny_arcade.md)    |32b        |       |        |              |      |A                                |
-|[Thumby](thumby.md)              |32b 133 MHz| 264   | 2000   | 72x40 1b     | 2022 |RPI (RP2040)         |
+|[Thumby](thumby.md)              |32b 133 MHz| 264   | 2000   | 72x40 1b     | 2022 |RPI (RP2040), web code editor :( |
 |[Pocket Arcade](pocket_arcase.md)|           |       |        |              |      |                                 |
 |Ringo/[MakerPhone](makerphone.md)|32b 160 MHz| 520   | 4000   | 160x128      | 2018 | A -, phone, SD                  |
 |[Agon](agon.md)                  |8b 18 MHz  | 512   |        | 640x480      |      |                                 |

rms.md

@@ -17,6 +17,8 @@ The great doctor Richard Matthew Stallman (RMS, also [GNU](gnu.md)/Stallman and
 
 Stallman's life along with free software's history is documented by a free-licensed book named *Free as in Freedom: Richard Stallman's Crusade for Free Software* on which he collaborated. You can get it gratis e.g. at [Project Gutenberg](https://www.gutenberg.org/ebooks/5768). You should read this!
 
+Richard Stallman is also famous for having foreseen and foretold virtually all the atrocities that [corporations](corporation.md) would do with computer technology, such as all the spying through cell phones, trade of personal data and abusing secrecy and "intellectual ownership" of source code for bullying others, though to be honest it doesn't take a genius to foresee that corporations will want to rape people as much as possible, it's more of a surprise he was one of very few who did. The important thing is he acted immediately he spotted this -- though corporations indeed did go on to rape people anyway, Richard Stallman made some very important steps early on to make the impact much less catastrophic nowadays. We should be all grateful.
+
 [tl;dr](tldr.md): At 27 as an employee at [MIT](mit.md) [AI](ai.md) labs Stallman had a bad experience when trying to fix a Xerox printer who's [proprietary](proprietary.md) software source code was made inaccessible; he also started spotting the betrayal of hacker principles by others who decided to write proprietary software -- he realized proprietary software was inherently wrong as it prevented studying, improvement and sharing of software and enable abuse of users. From 1982 he was involved in a "fight" against the Symbolics company that pushed aggressive proprietary software; he was rewriting their software from scratch to allow Lisp Machine users more freedom -- here he proved his superior programming skills as he was keeping up with the whole team of Symbolics programmers. By 1983 his frustration reached its peak and he announced his [GNU](gnu.md) project on the [Usenet](usenet.md) -- this was a project to create a completely [free as in freedom](free_software.md) [operating system](os.md), an alternative to the proprietary [Unix](unix.md) system that would offer its users freedom to use, study, modify and share the whole software, in the hacker spirit. He followed by publishing a manifesto and establishing the [Free Software Foundation](fsf.md). GNU and FSF popularized and standardized the term [free (as in freedom) software](free_software.md), [copyleft](copyleft.md) and free licensing, mainly with the [GPL](gpl.md) license. In the 90s GNU adopted the [Linux](linux.md) operating system kernel and released a complete version of the GNU operating system -- these are nowadays known mostly as "Linux" [distros](distro.md). As a head of FSF and GNU Stallman more or less stopped programming and started traveling around the world to give talks about free software and has earned his status of one of the most important people in software history.
 
 Regarding [software](software.md) Stallman has for his whole life strongly and tirelessly promoted free software and [copyleft](copyleft.md) and has himself only used free software; he has always practiced what he preached and led the best example of how to live without [proprietary](proprietary.md) software. This in itself is extremely amazing and rare, regardless of whether he ever slipped (which we aren't aware of) or to what degree we agree with his ideas; his moral strength and integrity is really what makes him special among basically all other great people of recent centuries, it's really as if he comes from a different time when people TRULY internally believed something so much they would die for it, that they wouldn't sell even a small part of that belief for any kind of personal benefit; this is something that really puts him alongside the greatest philosophers such as [Plato](plato.md) or [Socrates](socrates.md) (who followed his own principles so much that he voluntarily died for them).
@@ -33,4 +35,4 @@ Stallman has been critical of [capitalism](capitalism.md) though he probably isn
 
 In the book *Free As In Freedom* it is also mentioned that **Stallman had aversion to passwords and secrecy in general** -- at MIT he used the username RMS with the same password so that other people could easily log in through his account and access [ARPANET](arpanet.md) (the predecessor of [Internet](internet.md)). Indeed, we applaud this, the "[sucurity](security.md)" hysteria is killing the computing world.
 
-As [anarchists](anarchism.md) we of course despise the idea of worshiping people, creating [heroes](hero_culture.md) and cults of personalities, but the enormous [historical](history.md) significance of Stallman has to be stressed as a plain and simple fact. Even though in our days his name is overshadowed in the mainstream by rich businessman and creators of commercially successful technology and even though we ourselves disagree with Stallman on some points, in the future history may well see Stallman as perhaps the greatest man of the software era, and rightfully so. Stallman isn't a mere creator of a commercially successful software product or a successful politician, he is an extremely morally strong philosopher, a great example to others, a prophet, someone who sees the truth and shows it to people -- he brilliantly foresaw the course of history and quickly defined ethics needed for the new era of mass available programmable computers at the right time, before the hammer hit. And not only that, he also basically alone established this ethics as a standard IN SPITE of all the world's [corporations](corporation.md) fighting back, in a field that back then was relatively obscure, unpopular in mainstream and hence not much supported by any mass media. He is also extremely unique in not pursuing self interest, in TRULY living his own philosophy, dedicating his whole life to his cause and refusing to give in even partially. All of this is at much higher level than simply becoming successful and famous within the contemporary capitalist system, his life effort is pure, true and timeless, unlike things achieved by pieces of shit such as [Steve Jobs](steve_jobs.md).
+As [anarchists](anarchism.md) we of course despise the idea of worshiping people, creating [heroes](hero_culture.md) and cults of personalities, but the enormous [historical](history.md) significance of Stallman has to be stressed as a plain and simple fact and though we may disagree with some of his methods and even opinions, it's as clear as it can be that he acted [selflessly](selflessness.md), in favor of all people -- something that can be said about very few, if anyone at all. Most other old time hackers, such as [Eric S. Ramyond](esr.md) and [Rob Pike](rob_pike.md) immediately abandoned all ideals of ethics and jumped the capitalist train with the first sight of money, Stallman stayed opposed to it, and for this he has our uttermost respect. Even though in our days his name is overshadowed in the mainstream by rich businessman and creators of commercially successful technology and even though we ourselves disagree with Stallman on some points, in the future [history](history.md) may well see Stallman as perhaps the greatest man of the software era, and rightfully so. Stallman isn't a mere creator of a commercially successful software product or a successful politician, he is an extremely morally strong philosopher, a great example to others, a prophet, someone who sees the truth and shows it to people -- he brilliantly foresaw the course of history and quickly defined ethics needed for the new era of mass available programmable computers at the right time, before the hammer hit. And not only that, he also basically alone established this ethics as a standard IN SPITE of all the world's [corporations](corporation.md) [fighting](fight_culture.md) back, in a field that back then was relatively obscure, unpopular in mainstream and hence not much supported by any mass media. He is also extremely unique in not pursuing self interest, in TRULY living his own philosophy, dedicating his whole life to his cause and refusing to give in even partially. All of this is at much higher level than simply becoming successful and famous within the contemporary capitalist system, his life effort is pure, true and timeless, unlike things achieved by pieces of shit such as [Steve Jobs](steve_jobs.md).

wiki_stats.md

@@ -3,8 +3,8 @@
 This is an autogenerated article holding stats about this wiki.
 
 - number of articles: 560
-- number of commits: 702
+- number of commits: 703
-- total size of all texts in bytes: 3072987
+- total size of all texts in bytes: 3075024
 
 longest articles:
 
@@ -24,6 +24,16 @@ longest articles:
 latest changes:
 
 ```
+Date:   Wed Feb 21 20:13:01 2024 +0100
+bazaar.md
+computer.md
+cpu.md
+how_to.md
+iq.md
+people.md
+random_page.md
+wiki_pages.md
+wiki_stats.md
 Date:   Wed Feb 21 11:59:01 2024 +0100
 bazaar.md
 faq.md
@@ -41,17 +51,6 @@ wiki_pages.md
 wiki_stats.md
 Date:   Tue Feb 20 16:24:28 2024 +0100
 books.md
-c.md
-cpp.md
-hacking.md
-iq.md
-less_retarded_society.md
-lrs_dictionary.md
-marketing.md
-random_page.md
-wiki_pages.md
-wiki_stats.md
-Date:   Mon Feb 19 23:59:22 2024 +0100
 ```
 
 most wanted pages:
@@ -66,16 +65,16 @@ gpl.md
 quake.md
 lisp.md
 irl.md
+gpu.md
 drm.md
 cryptography.md
 waiver.md
 syntax.md
 rpi.md
 pointer.md
+mcu.md
 html.md
-gpu.md
 compiler.md
 cli.md
-trademark.md
 ```