Update

4chan.md

@@ -4,6 +4,8 @@
 
 4chan (https://4chan.org/, also 4cuck) is the most famous [image board](image_board.md), a website causing controversies by its low [censorship](censorship.md) and a place of great [fun](fun.md), [trolling](troll.md), [toxicity](toxic.md) and [memes](meme.md). It was started in 2003 by [moot](moot.md) (Christopher Poole, born 1988). As most image boards, 4chan has a nice, oldschool minimalist look, even though it contains shitty [captchas](captcha.md) for posting and the site's code is [proprietary](proprietary.md). The site tolerates a great amount of [free speech](free_speech.md) up to the point of being regularly labeled "right-wing extremist site", though it actually censors a lot of stuff and bans for stupid reasons such as harmless [pedo](pedophilia.md) [jokes](jokes.md) are very common (speaking from experience) -- 4chan global rules for example PROHIBIT CRITICISING 4chan (LMAO, rule no. 8), doxxing and call for raids. Being a "rightist paradise" it is commonly seen as a rival to [reddit](reddit.md), aka the [pseudoleftist](pseudoleft.md) paradise -- both forums hate each other to death. The discussion style is pretty nice, there are many nice stories and memes (e.g. the famous [greentexts](greentext.md)) coming from 4chan but it can also be a hugely depressing place just due to the shear number of retards with incorrect opinions.
 
+{ Pre 2010 there used to be a cool 4chan wiki called Wikichan, now can be read at the Internet Archive: https://web.archive.org/web/20070218235405/http://wikichan.org/wiki/Main_Page. ~drummyfish }
+
 Just as reddit consists of subcommunities known as subreddits, 4chan consists of different boards (just as other image boards), each with given discussion topic and rules. The most (in)famous boards are likely *politically incorrect* AKA /pol/, where most of the american school shooters hang around, and *random* AKA /b/, the most active board, which is just a shitton of [meme](meme.md) shitposting, [porn](porn.md), [toxicity](toxic.md), [fun](fun.md), [trolling](troll.md) and retardedness.
 
 For us the most important part of 4chan is the technology board known as /g/ (for technoloGEE). Browsing /g/ can bring all kinds of emotion, it's a place of relative freedom and somewhat beautiful chaos where all people from absolute retards to geniuses argue about important and unimportant things, brands, tech news and memes, and constantly advise each other to kill themselves. Sometimes the place is pretty toxic and not good for mental health, actually it is more of a rule than an exception.

c.md

@@ -4,7 +4,7 @@
 
 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.
 
-{ Look up *The Ten Commandments for C Programmers* by Henry Spencer. Also the *Write in C* song (parody of *Let it Be*). ~drummyfish }
+{ 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 }
 
 It is usually **not considered an easy language to learn** because of its low level nature: it requires good understanding of how a [computer](computer.md) actually works and doesn't prevent the programmer from shooting himself in the foot. Programmer is given full control (and therefore responsibility). There are things considered "tricky" which one must be aware of, such as undefined behavior of certain operators and raw pointers. This is what can discourage a lot of modern "coding monkeys" from choosing C, but it's also what inevitably allows such great performance -- undefined behavior allows the compiler to choose the most efficient implementation. On the other hand, C as a language is pretty simple without [modern](modern.md) bullshit concepts such as [OOP](oop.md), it is not as much hard to learn but rather hard to master, as any other true art. In any case **you have to learn C** even if you don't plan to program in it regularly, it's the most important language in history and lingua franca of programming, you will meet C in many places and have to at least understand it: programmers very often use C instead of [pseudocode](pseudocode.md) to explain algorithms, C is used for optimizing critical parts even in non-C projects, many languages compile to C, it is just all around and you have to understand it like you have to understand [English](english.md).
 

compression.md

@@ -78,7 +78,7 @@ For **images** we usually exploit the fact that human sight is less sensitive to
 
 In **video** compression we may reuse the ideas from image compression and further employ exploiting temporal redundancy, i.e. the fact that consecutive video frames look similar, so we may only encode some kind of delta (change) against the previous (or even next) frame. The most common way is to fully record only one key frame in some time span (so called I-frame, further compressed with image compression methods), then divide it to small blocks and estimate the movement of those blocks so that they approximately make up the following frames -- we then record only the motion vectors of the blocks. This is why videos look "blocky". In the past [interlacing](interlacing.md) was also used -- only half of each frame was recorded, every other row was dropped; when playing, the frame was interlaced with the previous frame. Another cool idea is keyframe [superresolution](superresolution.md): you store only some keyframes in full resolutions and store the rest of them in smaller size; during decoding you can use the nearby full scale keyframes to upscale the low res keyframes (search for matching subblocks in the low res image and match them to those in the big res image).
 
-In **audio** we usually straight remove frequencies that humans can't hear (usually said to be above 20 kHz), for this we again convert the audio from spatial to frequency domain (using e.g. [Fourier transform](fourier_transform.md)). Furthermore it is very inefficient to store sample values directly -- we rather use so called *differential PCM*, a lossless compression that e.g. stores each sample as a difference against the previous sample (which is usually small and doesn't use up many bits). This can be improved by a predictor, which tries to predict the next values from previous values and then we only save the difference against this prediction. *Joint stereo coding* exploits the fact that human hearing is not so sensitive to the direction of the sound and so e.g. instead of recording both left and right stereo channels in full quality rather records the sum of both and a ratio between them (which can get away with fewer bits). *Psychoacoustics* studies how humans perceive sound, for example so called *masking*: certain frequencies may for example mask nearby (both in frequency and time) frequencies (make them unhearable for humans) so we can drop them. See also [vocoders](vocoder.md).
+In **audio** we usually straight remove frequencies that humans can't hear (usually said to be above 20 kHz), for this we again convert the audio from spatial to frequency domain (using e.g. [Fourier transform](fourier_transform.md)). Furthermore it is very inefficient to store sample values directly -- we rather use so called *differential PCM*, a lossless compression that e.g. stores each sample as a difference against the previous sample (which is usually small and doesn't use up many bits). This can be improved by a predictor, which tries to predict the next values from previous values and then we only save the difference against this prediction. *Joint stereo coding* exploits the fact that human hearing is not so sensitive to the direction of the sound and so e.g. instead of recording both left and right stereo channels in full quality rather records the sum of both and a ratio between them (which can get away with fewer bits). *Psychoacoustics* studies how humans perceive sound, for example so called *masking*: certain frequencies may for example mask nearby (both in frequency and time) frequencies (make them unhearable for humans) so we can drop them. See also [vocoders](vocoder.md). For specific kinds of audio we may further employ more detailed knowledge, for example with instrumental [music](music.md) we can just store the notes that are being played plus instruments that play them, for example with [MIDI](midi.md) -- this format was not made for compression per se, but it does allow us to store music in much smaller size than directly storing audio.
 
 TODO: LZW, DEFLATE etc.
 

consumerism.md

@@ -2,6 +2,8 @@
 
 TODO: actual normal article possibly
 
+If you don't want to consume, you made a very big mistake by being born.
+
 ## Rant
 
 { Here I'll leave the rant I've written when I was kinda stressed. ~drummyfish }

less_retarded_society.md

@@ -26,6 +26,8 @@ Our society is **[anarcho pacifist](anpac.md) and [communist](communism.md)**, m
 
 **People don't have to [work](work.md)**, basically everything is [automated](automation.md) and extremely [simplified](minimalism.md) so that the amount of work needed to be done is minimized by eliminating unnecessary [bullshit jobs](bullshit_job.md) such as marketing, lawyers, insurance, politicians, state bureaucracy, creation of consumer entertainment and goods etc. One of the basic principles of our society is that any individual can simply live, without having to deserve this right by proving worth, usefulness, obedience etc. The little remaining human work that's necessary is done voluntarily. There is no life path ("elementary school, high school, college, marriage, work, retirement, death") lined up for anyone , no [fight](fight_culture.md) awaiting, only one lifetime given to the hands of every new born individual to dedicate to whatever he finds best.
 
+As people don't have to work, very few people need to make daily travels, therefore there are very few roads and cars, making more space for nature, farming, leading to cleaner air, and almost completely eliminating noise and light pollution (and other things such as traffic accidents), furthermore also greatly reducing work needed to be done in connection to maintaining roads, sidewalks, directing traffic, manufacturing and repairing cars and so on. As no business exists anymore, there is no [marketing](marketing.md), there are no ads, no billboards, no workplaces connected to marketing are needed anymore, further eliminating jobs, increasing space for living, for nature, mental health is increasing and so on. Disappearing industries further on eliminate other industries living off of them, such as law firms, transport companies, security agencies, cleaning firms, patent offices, state bureaucracy and so on and so forth. More people can now study medicine as opposed to investing in bitcoin or making bullshit startups, leading to greater number of doctors who can dedicate more time to patients, which together with free healthcare and the great stress relief increases health of people -- people are happier, full of life and can do anything they feel is best with full focus, without distractions and bullying. Increased mental health and abundance leading to decrease in conflicts and crime lead to eliminating police and army, more jobs and bullshit are being rid of, well being of people is skyrocketing, nature is recovering, society is flourishing.
+
 **Society is NOT based on [competition](competition.md), but rather on [collaboration](collaboration.md).** Making people compete for basic life resources is seen as highly cruel and unethical. The natural need for competition is still satisfied with [games](game.md) and sports, but people know competition is kind of a poison and know they have to practice self control to not allow competitive tendencies in real life.
 
 **There is abundance of resources for everyone, poverty is non existent**, [artificial scarcity](artificial_scarcity.md) is no longer sustained by capitalism. There is enough food and accommodation for everyone, of course for free, as well as health care, access to information, entertainment, tools and so on. Where there used to be shopping centers, parking lots, government buildings and skyscrapers, there are now fields and food banks and people voluntarily collaborate on automating production of food on them.

lrs_dictionary.md

@@ -51,6 +51,7 @@ WORK IN PROGRESS
 | job                                        | slavery                                              |
 | "left"                                     | [pseudoleft](pseudoleft.md), SJW                     |
 | [LGBT](lgbt.md)                            | FGTS, TTTT                                           |
+| [liberal](liberal.md)                      | libtard                                              |                            
 | "[Linux](linux.md)"                        | [GNU](gnu.md), lunix, loonix                         |
 | [logic gate](logic_gate.md)                | logic gayte                                          |
 | Macintosh                                  | Macintoy, Macintrash, Maggotbox                      |
@@ -80,7 +81,7 @@ WORK IN PROGRESS
 | [Steve Jobs](steve_jobs.md)                | Steve Jewbs                                          |
 | subscription                               | [microrape](microrape.md)                            |
 | [systemd](systemd.md)                      | shitstemd, soystemd                                  |
-| [Twitter](twitter.md)                      | titter                                               |
+| [Twitter](twitter.md)                      | titter, twatter                                      |
 | United States of America                   | United Shitholes of America, burgerland              |
 | user (of a proprietary system)             | used, lusr                                           |
 | voice assistant                            | personal spy agent                                   |

pseudorandomness.md

@@ -2,6 +2,8 @@
 
 Pseudorandom data is [data](data.md) that appears (for example by its statistical properties) to have been generated by a [random](random.md) process despite in fact having been generated by a [deterministic](determinism.md) (i.e. non-random) process. I.e. it's a kind of "fake" but mostly [good enough](good_enough.md) randomness that arises from [chaotic](chaos.md) systems -- systems that behave without randomness, by strict rules, but which scramble, shuffle, twist and transform the numbers in such a complicated way that they eliminate obvious patterns and leave the data looking very "random", though the numbers would be scrambled exactly the same way if the process was repeated with the same conditions, i.e. it is possible (if we know how the generator works) to exactly predict which numbers will fall out of a pseudorandom generator. This is in contrast to "true randomness" that (at least to what most physicists probably think) appears in some processes in nature (most notably in [quantum physics](quantum.md)) and which are absolutely unpredictable, even in theory. Pseudorandomness is typically used to emulate true randomness in [computers](computer.md) because for many things ([games](game.md), [graphics](graphics.md), audio,  random sampling, ...) it is absolutely sufficient, it is easy to do AND the repeatability of a pseudorandom sequence is actually an advantage to engineers, e.g. in [debugging](debugging.md) in which we have to replicate bugs we find, or in programs that simply have to behave deterministic (e.g. many network games). True randomness is basically only ever needed for [cryptography](cryptography.md)/[security](security.md) (or possibly for rare applications where we absolutely NEED to ensure lack of any patterns in the data), it is a bit harder to achieve because we need some unbiased source of real-world random data. Pseudorandom generators are so common that in most contexts in programming the word "random" silently actually means just "pseudorandom".
 
+A saying about psedorandom numbers states that "randomness is a task too important to be left to chance".
+
 ## How It Works
 
 Firstly let's mention that we can use [look up tables](lut.md), i.e. embed some high quality random data right into our program and then use that as our random numbers, taking one after another and getting back to start once we run out of them. This is for example how [Doom](doom.md)'s pseudorandom generator worked. This is easy to do and extremely fast, but will take up some memory and will offer only a quite limited sized sequence (your generator will have a short period), so ponder on the pros and cons for your specific needs. From now on we'll leave this behind and will focus on really GENERATING the pseudorandom values with some [algorithm](algorithm.md), but look up tables may still be kept in mind (they might even perhaps be somehow combined with the true generators).
@@ -16,7 +18,7 @@ The number of bits that the generator takes from its internal number and gives y
 
 Now let's realize another important thing -- if the generator has some internal number, which is the only thing that determines the next number, and if its internal number has some limited size -- let's say for example 32 bits -- then the sequence HAS TO start repeating sometimes because there is a limited number of values the internal number can be in and once we get to the same number, it will have to evolve the same way it evolved before (because we have a deterministic generator and the number is the whole generator's state). Imagine this as a [graph](graph.md): numbers are nodes, the seed is the node we start in, there are finitely many nodes and each one leads to exactly one other node -- going through this graph you inevitably have to end up running in some loop. For this reason we talk about the **period** of a pseudorandom generator -- this period says after how many values the sequence will start to repeat. In fact it is possible that only last *N* values of the initial sequence will start to repeat -- again, if you imagine the graph, it is possible that an initial path leads us to some smaller loop in which we then keep cycling. This may depend on the seed, so the whole situation can get a bit messy, but we can resolve this, just hold on.
 
-It's not hard to see that the period of the generator can be at most 2 to the power of the number of bits of the generator's internal value (i.e. the number of possible distinct values the number can be, or the nodes in the graph). **We want to achieve this maximum period** -- indeed, it is ideal if we can make it as long as possible, but achieving the maximum period will also mean the period won't depend on seed. If you imagine the graph, having a big loop over all the values means that there are no other loops, there's just one long repeating sequence in which each internal value appears exactly once, so no matter where we start (which seed we set), we'll always end up being in the same big loop.
+It's not hard to see that the period of the generator can be at most 2 to the power of the number of bits of the generator's internal value (i.e. the number of possible distinct values the number can be, or the nodes in the graph). **We want to achieve this maximum period** -- indeed, it is ideal if we can make it as long as possible, but achieving the maximum period will also mean the period won't depend on the initial seed! If you imagine the graph, having a big loop over all the values means that there are no other loops, there's just one long repeating sequence in which each internal value appears exactly once, so no matter where we start (which seed we set), we'll always end up being in the same big loop. In addition to this we ALSO get another awesome thing: the histogram (the count) of all values over the whole period will be absolutely uniform, i.e. every value generated during one period will appear exactly the same number of times (which is what we expect from a completely random, uniform generator) -- this can be seen from the fact that we are returning *N* bits of some bigger internal number of *N + M* bits, which will come through each possible value exactly once, so each possible value of *N* will have to appear and each of these values will have to appear with all possible values of the remaining *M* bits, which will be the same for all values.
 
 Now let's take a look at specific generators, i.e. types of algorithms to generate the numbers. There are many different kinds, for example [Mersenne Twister](mersenne_twister.md), middle square etc., however probably the **most common type** is the **[linear congruential generator](lcg.md)** (LCG) -- though for many decades now it's been known this type of generator has some issues (for example less significant bits have shorter and shorter periods, for which we usually want to use a very big internal value and return its highest bits as the result), it will likely suffice for most of your needs, but you have to be careful about choosing the generator's parameters correctly. It works like this: given a current (internal) number *x[n]* (which is initially set to the seed number), the next number in the sequence is computed as
 
@@ -56,8 +58,55 @@ Here `T` is the data type of the internal number (implying the *M* constant) --
 
 { I pulled the above numbers from various sources I found, mentioned in the note, tried to select the ones that were allegedly good, I also quickly tested them myself, checked the period was at maximum at least for the 32 bit generators and lower. ~drummyfish }
 
+Let's also quickly mention **another kind of generator** as an alternative -- the *middle square plus Weyl sequence* generator. Middle square generator was one of the first and is very simple, it simply starts with a number (seed), squares it, takes its middle digits as the next number, squares it, takes its middle digits and so on. The issue with this was mainly getting a number 0, at which we get stuck. A 2022 paper by *Wydinski* seems to have solved this issue by employing so called *Weyl* sequence -- basically just adding some odd number in each step, though the theory is a bit more complex, the paper goes on to prove a high period of this generator. An issue seems to be with seeding the sequence -- the generator has three internal numbers and they can't just be blindly set to "anything" (the paper gives some hints on how to do this). Here is a 32 bit variant of such generator (the paper gives a 64 bit one):
+
+{ I tried to make a 32 bit version of the generator, tried to choose the `_rand3` constant well -- after quickly testing this the values of the generator looked alright, though I just eyeballed the numbers, each bit separately, checked the mean of some 4000 values and the histogram of 1 million values. I'm not claiming this version to be statistically good, but it may be a start for implementing something nice, use at own risk. ~drummyfish }
+
+```
+#include <stdint.h>
+
+uint32_t _rand1, _rand2, _rand3 = 0x5e19dbae;
+
+uint16_t random()
+{
+  _rand2 += _rand3;
+  _rand1 = _rand1 * _rand1 + _rand2;
+  _rand1 = (_rand1 >> 16) | (_rand1 << 16);
+
+  return _rand1;
+}
+```
+
+NOTE on the code: the `(_rand1 >> 16) | (_rand1 << 16)` operation effectively makes the function return lower 16 bits of the squared number's middle digits, as multiplying `_rand1` (32 bit) by itself results in the lower half of a 64 bit result.
+
+Yet another idea might be to use some good [hash](hash.md) just on numbers 1, 2, 3, 4 ... The difference here is we are not computing the pseudorandom number from the previous one, but we're computing *N*th pseudorandom number directly from *N*. This will probably be slower. For example: { Again, no big guarantees. ~drummyfish }
+
+```
+#include <stdint.h>
+
+uint32_t _rand = 0;
+
+uint32_t random()
+{
+  uint32_t x = _rand;
+  _rand++;
+  
+  x = 303484085 * (x ^ (x >> 15));
+  x = 985455785 * (x ^ (x >> 15));
+  return x ^ (x >> 15);
+}
+
+void randomSeed(uint32_t seed)
+{
+  _rand = seed;    // this alone just offsets the sequence
+  seed = random(); // this is an attempt at fix
+}
+```
+
 **How to generate a number in certain desired range?** As said your generator will be giving you numbers of certain fixed number of bits, usually something like 16 or 32, which means you'll be getting numbers in range 0 to 2^bits - 1. But what if you want to get numbers in some specific range *A* to *B* (including both)? To do this you just need to generate a number in range 0 to *B - A* and then add *A* to it (e.g. to generate number from 20 to 30 you generate a number from 0 to 10 and add 20). So let's just suppose we want a number in range 0 to *N* (where *N* can be *B - A*). Let's now suppose *N* is lower than the upper range of our generator, i.e. that we want to get the number into a small range (if this is not the case, we can arbitrarily increase the range of our generator simply by generating more random bits with it, i.e we can join two 16 bit numbers to get a 32 bit number etc.). Now the most common way to get the number in the desired range is by using *modulo (N + 1)* operation, i.e. in [C](c.md) we simply do something like `int random0to100 = random() % 101;`. This easily forces the number we get into the range we want. HOWEVER beware, there is one statistical trap about this called the **modulo bias** that makes some numbers slightly more likely to be generated than others, i.e. it biases our distribution a little bit. For example imagine our generator gives us numbers from 0 to 15 and we want to turn it into range 0 to 10 using the modulo operator, i.e. we'll be doing *mod 11* operation -- there are two ways to get 0 (*0 mod 11* and *11 mod 11*) but only one way to get 9 (*9 mod 11*), so number 0 is twice as likely here. In practice this effect isn't so strong and in many situations we don't really mind it, but we have to be aware of this effects for the sake of cases where it may matter. If necessary, the effect can be reduced -- we may for example realize that modulo bias will be eliminated if the upper range of our generator is a multiple of the range into which we'll be converting, so we can just repeatedly generate numbers until it falls under a limit that's a highest multiple of our desired range lower than the true range of the generator.
 
+**What if we want [floating point](float.md)/[fixed point](fixed_point.md) numbers?** Just convert the integer result to that format somehow, for example `((float) random()) / ((float) RANDOM_MAX_VALUE)` will produce a floating point number in range 0 to 1.
+
 **How to generate other probability distributions?** Up until now we supposed a uniform probability distribution, i.e. the most random kind of generator that has an equal probability of generating any number. But sometimes we want a different distribution, i.e. we may want some numbers to be more likely to be generated than others. For this we normally start with the uniform generator and then convert the number into the new distribution. For that we may make use of the following:
 
 - **Averaging many uniform distributions converges to normal distribution** -- this is called *central limit theorem* and in fact works even more generally (the averaged distribution doesn't have to be uniform), but to us it's enough to know that if we want normally distributed random numbers, we can just average many uniformly distributed variables. Intuitively this makes sense -- averaging many numbers will likely be close to the mean value, it's very unlikely to be close to either end as to get an extreme average we would have to roll only numbers close to that one extreme.
@@ -78,22 +127,21 @@ However the core of a pseudorandom generator is the quality of the sequence itse
 - **Check the sequence period**: You want the longest possible period of your generator, i.e. if your generator has an *N* bit internal number and you start with number *A*, you get back to *A* after *2^N* steps and no sooner -- this will ensure not only the maximum period length, but also that the period length will be the same for every starting seed! That's because in this ideal case you simply have a single cycle over all the possible internal number values.
 - **Try to [compress](compression.md) the sequence**: Truly random data should be basically impossible to compress -- you can exploit this fact and try to compress your sequence with some compression programs. It is ideal if the compression programs end up enlarging the file.
 - **Statistical tests**: Here you use objective mathematical tests -- there exist many very advanced tests, we'll only mention the very simple ones.
-  - **[Histogram](histogram.md)**: Generate many numbers (but not more than the generator's period) and make a histogram (i.e. for every number count how many times it appeared) -- all numbers should appear roughly with the same frequency. Also count 1 and 0 bits in the whole sequence -- there should be almost the same number of them. But keep in mind this only checks if you have correct frequencies of numbers, it says nothing about their distribution. Even a sequence 1, 2, 3, 4, 5, .... will pass this.
+  - **[Histogram](histogram.md)**: Generate many numbers (but not more than the generator's period) and make a histogram (i.e. for every number count how many times it appeared) -- all numbers should appear roughly with the same frequency. If you make a nice generator, you should even see exactly the same count for every value generated -- this is explained above. Also count 1 and 0 bits in the whole sequence -- again there should be about the same number of them (exactly the same if you do it correctly). But keep in mind this only checks if you have correct frequencies of numbers, it says nothing about their distribution. Even a sequence 1, 2, 3, 4, 5, .... will pass this.
   - **Averaging any non-short interval should be close to middle value**: In a random sequence it should hold that if you take any interval that's not too short -- let's say at leas 100 numbers in a row -- the average value should very likely be close to the middle value (the longer the interval, the closer it should be). You can test your sequence like this. This already takes into account even the distribution of the numbers.
   - **[Fourier transform](fourier_transform.md)** (and similar methods that give you the spectrum) -- the spectrum of the data should have equal amount of all frequencies, just like white noise.
-  - **[Correlation](correlation.md) coefficients**: You can try to compute some correlation coefficients, for example try to compute how much correlation there is between consecutive numbers (it's similar to plotting the data as coordinates and seeing if they form a line or not) -- you should ideally find no significant correlations.
+  - **[Correlation](correlation.md) coefficients**: This is kind of the real proof of randomness, ideally no values should be correlated in your data, so you can try to compute some correlation coefficients, for example try to compute how much correlation there is between consecutive numbers (it's similar to plotting the data as coordinates and seeing if they form a line or not) -- you should ideally find no significant correlations.
   - **Chi square test**: Very common test for this kind of thing, see also *poker test*.
-  - **[Monte Carlo](monte_carlo.md) tests**: Monte Carlo algorithms use random sampling to compute a certain desired value -- for example the value of [pi](pi.md). These suppose that we can sample certain space randomly, so we can exploit this -- if we know what result we want to get (for example we already know the value of pi) we can test the algorithm with our generator and see if we get the desired result -- if we come close to the desired result, we can be a bit more confident that our sampling was random (however we cannot be certain of it -- like with any testing we can only ever be certain about the presence of an error, not about the lack of it).
+  - **[Monte Carlo](monte_carlo.md) tests**: Monte Carlo algorithms use random sampling to compute a certain desired value -- for example the value of [pi](pi.md). These suppose that we can sample certain space randomly, so we can exploit this -- if we know what result we want to get (for example we already know the value of pi) we can test the algorithm with our generator and see if we get the desired result -- if we come close to the desired result, we can be a bit more confident that our sampling was random, however we cannot be certain of it -- like with any testing we can only ever be certain about the presence of an error, not about the lack of it. Even a very dense, regular grid of points would probably pass this.
   - **The cool uber randomness test** described in article on [randomness](randomness.md) ;) Basically every number (and by extension any sequence of numbers) should be equally likely to be followed by any other number.
   - For the linear congruential generators there's a so called spectral test, it seems to be the one true test for that kind of generators, make sure to do it if you're aiming for the top generator.
   - ...
 - **Test programs**: There exist programs that do the automatic tests for you, for example [ent](ent.md).
 - ...
 
-TODO: add some advanced generator code, e.g. the mersene twister or the middle square + Weyl
-
 ## See Also
 
 - [pseudo](pseudo.md)
 - [randomness](randomness.md)
 - [noise](noise.md)
+- [bytebeat](bytebeat.md)

wiki_stats.md

@@ -3,9 +3,9 @@
 This is an autogenerated article holding stats about this wiki.
 
 - number of articles: 580
-- number of commits: 808
+- number of commits: 809
-- total size of all texts in bytes: 3816598
+- total size of all texts in bytes: 3846278
-- total number of lines of article texts: 29236
+- total number of lines of article texts: 29369
 - number of script lines: 262
 - occurences of the word "person": 7
 - occurences of the word "nigger": 86
@@ -35,60 +35,83 @@ longest articles:
 
 top 50 5+ letter words:
 
-- which (2185)
+- which (2202)
-- there (1649)
+- there (1670)
-- people (1461)
+- people (1463)
-- example (1198)
+- example (1225)
-- other (1187)
+- other (1193)
+- number (1102)
 - software (1073)
-- number (1038)
+- about (998)
-- about (989)
+- program (876)
-- program (871)
+- their (823)
-- their (816)
+- because (791)
-- because (780)
+- would (777)
-- would (769)
+- called (758)
-- called (753)
 - language (740)
 - computer (732)
-- being (721)
+- numbers (731)
-- things (699)
+- being (726)
-- simple (697)
+- simple (702)
-- numbers (688)
+- things (701)
-- something (677)
+- something (685)
-- without (661)
+- without (663)
-- programming (649)
+- programming (652)
-- function (645)
+- function (652)
-- these (613)
+- however (620)
-- different (612)
+- these (618)
-- however (610)
+- different (617)
-- world (576)
+- world (577)
-- system (561)
+- system (562)
-- should (546)
+- should (560)
-- doesn (544)
+- doesn (549)
-- games (540)
+- games (541)
+- point (537)
 - society (535)
-- point (534)
+- though (509)
-- though (506)
+- while (506)
-- while (504)
+- drummyfish (500)
-- drummyfish (498)
+- using (498)
-- memory (497)
+- memory (498)
-- using (495)
+- still (485)
-- still (484)
 - technology (479)
-- similar (476)
+- similar (478)
-- course (475)
+- course (477)
-- possible (463)
+- possible (474)
-- simply (461)
+- simply (467)
-- https (451)
+- https (453)
-- really (424)
+- really (431)
-- extremely (419)
+- value (423)
-- computers (418)
+- extremely (423)
-- always (415)
+- always (421)
-- actually (414)
+- actually (420)
 
 latest changes:
 
 ```
+Date:   Sat May 25 21:44:26 2024 +0200
+  duke3d.md
+  entrepreneur.md
+  exercises.md
+  fsf.md
+  gay.md
+  interesting.md
+  jokes.md
+  love.md
+  main.md
+  needed.md
+  often_confused.md
+  pseudorandomness.md
+  random_page.md
+  randomness.md
+  shit.md
+  trolling.md
+  usa.md
+  wiki_pages.md
+  wiki_stats.md
+  woman.md
+  work.md
+  world_broadcast.md
 Date:   Wed May 22 17:49:39 2024 +0200
   duskos.md
   egoism.md
@@ -102,25 +125,6 @@ Date:   Wed May 22 17:49:39 2024 +0200
   wiki_stats.md
   wikipedia.md
   work.md
-Date:   Tue May 21 21:34:38 2024 +0200
-  faq.md
-  pedophilia.md
-  random_page.md
-  trolling.md
-  wiki_pages.md
-  wiki_stats.md
-Date:   Mon May 20 21:37:56 2024 +0200
-  capitalism.md
-  exercises.md
-  furry.md
-  game.md
-  lrs_dictionary.md
-  lrs_wiki.md
-  pedophilia.md
-  people.md
-  random_page.md
-  wiki_pages.md
-  wiki_stats.md
 ```
 
 most wanted pages:
@@ -149,19 +153,19 @@ most wanted pages:
 most popular and lonely pages:
 
 - [lrs](lrs.md) (281) 
-- [capitalism](capitalism.md) (213) 
+- [capitalism](capitalism.md) (214) 
-- [c](c.md) (211) 
+- [c](c.md) (213) 
 - [bloat](bloat.md) (201) 
 - [free_software](free_software.md) (165) 
-- [game](game.md) (139) 
+- [game](game.md) (140) 
-- [suckless](suckless.md) (134) 
+- [suckless](suckless.md) (135) 
 - [proprietary](proprietary.md) (117) 
+- [computer](computer.md) (94) 
 - [kiss](kiss.md) (93) 
-- [computer](computer.md) (93) 
 - [modern](modern.md) (89) 
 - [minimalism](minimalism.md) (88) 
 - [linux](linux.md) (88) 
-- [gnu](gnu.md) (81) 
+- [gnu](gnu.md) (82) 
 - [programming](programming.md) (80) 
 - [free_culture](free_culture.md) (80) 
 - [fun](fun.md) (78) 

woman.md

@@ -114,3 +114,4 @@ Here is a list of almost all historically notable women:
 - [man](man.md)
 - [t-girl](tgirl.md)
 - [waifu](waifu.md)
+- Encyclopedia Dramatica's take on the topic: https://encyclopediadramatica.top/Woman

youtube.md

@@ -4,7 +4,7 @@ YouTube (also JewTube { Lol jewtube.com actually exists. ~drummyfish} or just YT
 
 Just one of countless damages YouTube has done to society is establishing videos as standard medium of any form of communication and information storage -- back in the day Internet was mostly text-based, sometimes there was an image or video of course, but only when needed. Since YouTube's rise to fame a lot of information has just moved to videos, even that which suffer by this format, e.g. books, announcements, notes, presentations, tutorials, pure audio and so on. All of this [bloat](bloat.md) of course makes the information hard to index and search, store, process, view on weak devices, it wastes enormous amounts of bandwidth, computing power and so forth. Thanks YouTube.
 
-{ https://www.vidlii.com seems alright though, at least as a curiosity. Anyway if you need to watch YouTube, do not use their website, it's shitty as hell and you will die of ad cancer, rather use something like invidious or youtube-dl. Here is an **awesome hack I discovered to search only old videos on youtube**! The new shit is just unwatchable, there's clickbait, sponsors, propaganda, SJW shit everywhere, thankfully you can just exclude any year from the search with with "-year" (at least for now), for example: https://yewtu.be/search?q=free+software+-2023+-2022+-2021+-2020+-2019+-2018+-2017+-2016+-2015+-2014+-2013+-2012+-2011+-2010+-2009&page=1&date=none&type=video&duration=none&sort=relevance. Enjoy. ~drummyfish }
+{ https://www.vidlii.com seems alright though, at least as a curiosity. Anyway if you need to watch YouTube, do not use their website, it's shitty as hell and you will die of ad cancer, rather use something like invidious or youtube-dl. Here is an **awesome hack I discovered to search only old videos on youtube**! The new shit is just unwatchable, there's clickbait, sponsors, propaganda, SJW shit everywhere, thankfully you can just exclude any year from the search with with "-year" (at least for now), for example: https://yewtu.be/search?q=free+software+-2023+-2022+-2021+-2020+-2019+-2018+-2017+-2016+-2015+-2014+-2013+-2012+-2011+-2010+-2009&page=1&date=none&type=video&duration=none&sort=relevance. UPDATE: actually you can even just use `before:YEAR` in the search, TIL. Enjoy. ~drummyfish }
 
 **What are the alternatives to YouTube?** We'll only leave a brief paragraph here for wannabe YouTube alternatives come and go faster than a [zoomer](zoomer.md) changes genders. Best alternative to watching videos is reading [books](books.md) or watching clouds in the sky, but we'll stick to "watching videos on the Internet" here. Also bear in mind that if you have to watch YouTube, use alternative YouTube [frontends](frontend.md), which are normally [FOSS](foss.md) -- e.g. Invidious, piped, HookTube or FreeTube -- these let you access YouTube's videos via less [bloated](bloat.md) and more "privacy-friendly" interface, also filtering out ads and so on, more hardcore people use [CLI](cli.md) tools such as [youtube-dl](youtube_dl.md) to directy download the videos and watch them in native players. Likely the most notable [FOSS](foss.md) alternative to YouTube is **[PeerTube](peertube.md)**, a [federated](federation.md) [P2P](p2p.md) video platform, however for intended use it requires [JavaScript](javascript.md) (there is a way to download videos without JS but it's discouraged) and there are other issues that make it unusable ([SJW](sjw.md) censorship, videos load extremely slowly, ...). If you use PeerTube, don't use the lesbian instances, look up the uncensored ones. Mainstream proprietary alternative to YouTube is Vimeo, Bitchute is the "rightist" YouTube alternative (quite shitty TBH). [Internet Archive](internet_archive.md) has many video, especially old ones -- this is quite nice alternative. Vidlii is proprietary but oldschool site that tries to replicate old YouTube for the nostalgia, it has its own videos and small, dedicated community and very low censorship, it is pretty nice, with 360p videos and all; a site very similar to Vidlii it Bitview.