Update

ai.md

@@ -1,6 +1,6 @@
 # Artificial Intelligence
 
-Artificial intelligence (AI) is an area of [computer science](compsci.md) whose effort lies in making computers simulate thinking of humans and possibly other biologically living beings. This may include making computers play [games](game.md) such as [chess](chess.md), compose music, paint pictures, understand and processing audio, images and text on high level of [abstraction](abstraction.md) (e.g. translation between natural languages), making predictions about complex systems such as stock market or weather or even exhibit a general human-like behavior. Even though today's focus in AI is on [machine learning](machine_learning.md) and especially [neural networks](neural_network.md), there are many other usable approaches and models such as "hand crafted" state tree searching algorithms that can simulate and even outperform the behavior of humans in certain specialized areas.
+Artificial intelligence (AI) is an area of [computer science](compsci.md) whose effort lies in making [computers](computer.md) simulate thinking of humans and possibly other biologically living beings. This may include making computers play [games](game.md) such as [chess](chess.md), compose music, paint pictures, understand and processing audio, images and text on high level of [abstraction](abstraction.md) (e.g. translation between natural languages), making predictions about complex systems such as stock market or weather or even exhibit a general human-like behavior. Even though today's focus in AI is on [machine learning](machine_learning.md) and especially [neural networks](neural_network.md), there are many other usable approaches and models such as "hand crafted" state tree searching algorithms that can simulate and even outperform the behavior of humans in certain specialized areas.
 
 There's a concern that's still a matter of discussion about the dangers of developing a powerful AI, as that could possibly lead to a [technological singularity](tech_singularity.md) in which a super intelligent AI might take control over the whole world without humans being able to seize the control back. Even though it's still likely a far future and many people say the danger is not real, the question seems to be about *when* rather than *if*.
 

c.md

@@ -22,11 +22,9 @@ Mainstream consensus acknowledges that C is among the best languages for writing
 
 ## History and Context
 
-C was developed in 1972 at [Bell Labs](bell_labs.md) alongside the [Unix](unix.md) operating system by [Dennis Ritchie](dennis_ritchie.md) and [Brian Kerninghan](brian_kerninghan.md), as a successor to the [B](b.md) language ([portable](portability.md) language with [recursion](recursion.md)) written by Denis Ritchie and [Ken Thompson](ken_thompson.md), which was in turn inspired by the the [ALGOL](algol.md) language (code blocks, lexical [scope](scope.md), ...).
+C was developed in 1972 at [Bell Labs](bell_labs.md) alongside the [Unix](unix.md) operating system by [Dennis Ritchie](dennis_ritchie.md) and [Brian Kerninghan](brian_kerninghan.md), as a successor to the [B](b.md) language ([portable](portability.md) language with [recursion](recursion.md)) written by Denis Ritchie and [Ken Thompson](ken_thompson.md), which was in turn inspired by the the [ALGOL](algol.md) language (code blocks, lexical [scope](scope.md), ...). C was for a while called NB for "new B".
 
-In 1973 Unix was rewritten in C. In 1978 Keninghan and Ritchie published a book called *The C Programming Language*, known as *K&R*, which became something akin the C specification. In 1989, the [ANSI C](ansi_c.md) standard, also known as C89, was released by the American ANSI. The same standard was also adopted a year later by the international ISO, so C90 refers to the same language. In 1999 ISO issues a new standard that's known as C99.
+In 1973 Unix was rewritten in C. In 1978 Keninghan and Ritchie published a book called *The C Programming Language*, known as *K&R*, which became something akin the C specification. In 1989, the [ANSI C](ansi_c.md) standard, also known as C89, was released by the American ANSI -- this is a very well supported and overall good standard. The same standard was also adopted a year later by the international ISO, so C90 refers to the same language. In 1999 ISO issues a new standard that's known as C99, still a very good standard embraced by [LRS](lrs.md). Later in 2011 and 2017 the standard was revised again to C11 and C17, which are however no longer considered good.
-
-TODO
 
 ## Standards
 
@@ -48,12 +46,20 @@ The standards of C99 and older are considered pretty [future-proof](future_proof
 
 ## Compilers
 
+C is extreme well established, standardized and implemented so there is a great number of C compilers around. Let us list only some of the more notable ones.
+
 - [gcc](gcc.md): The main "big name" that can compile all kinds of languages including C, used by default in many places, very [bloated](bloat.md) and can take long to compile big programs, but is pretty good at [optimizing](optimization.md) the code and generating fast code. Also has number of frontends and can compile for many platforms. Uses GENERIC/GIMPLE [intermediate representation](intermediate_representation.md).
 - [clang](clang.md): Another big bloated compiler, kind of competes with gcc, is similarly good at optimization etc. Uses [LLVM](llvm.md) intermediate representation.
 - [tcc](tcc.md): Tiny C compiler, [suckless](suckless.md), orders of magnitude smaller (currently around 25 KLOC) and simpler than gcc and clang, cannot optimize nearly as well as the big compilers so the generated executables can be a bit slower and bigger, however besides its internal simplicity there are many advantages, mainly e.g. fast compilation (claims to be 9 times faster than gcc) and small tcc executable (about 100 kB). Seems to only support x86.
 - [scc](scc.md): Another small/suckless C compiler, currently about 30 KLOC.
 - [DuskCC](duskcc.md): [Dusk OS](duskos.md) C compiler written in [Forth](forth.md), focused on extreme simplicity, probably won't adhere to standards completely.
-- [8c](8c.md), [8cc](8cc.md)
+- [8c](8c.md), [8cc](8cc.md), [chibicc](chibicc.md): Some other small compilers.
+- [c2bf](c2bf.md): Partially implemented C to [brainfuck](brainfuck.md) compiler.
+- [lcc](lcc.md): Proprietary, source available small C compiler, about 20 KLOC.
+- [pcc](pcc.md): A very early C compiler that was later developed further to support even the C99 standard.
+- 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. Avoid.
 - ...
 
 ## Standard Library
@@ -108,26 +114,52 @@ You can simply paste this code into a file which you name e.g. `program.c`, then
 
 Then if you run the program from command line (`./program` on Unix like systems) you should see the message.
 
-## Cheatsheet
+## Cheatsheet/Overview
 
-It's pretty important you learn C, so here's a little cheat sheet for you.
+Here is a quick reference cheatsheet of some of the important things in C, also a possible overview of the language.
 
 **data types** (just some):
 
-- **int**: signed integer, at least 16 bits (-32767 to 32767) but usually more
+| data type                 | values (size)                                          | printf     |notes                                               |
-- **unsigned int**: unsigned integer, at least 16 bit (0 to 65535) but usually more
+| ------------------------- | ------------------------------------------------------ | ---------- | -------------------------------------------------- |
-- **char**: smallest integer of at least 8 bits (1 byte, 256 values), besides others used for containing [ASCII](ascii.md) characters
+| `int` (`signed int`, ...) | integer, at least -32767 to 32767 (16 bit), often more | `%d`       | native integer, **fast** (prefer for speed)        |
-- **unsigned char**: like char but unsigned (0 to 255)
+| `unsigned int`            | integer, non-negative, at least 0 to 65535, often more | `%u`       | same as `int` but no negative values               |
-- **float**: [floating point](float.md) number (usually 32 bit)
+| `signed char`             | integer, at least -127 to 127, mostly -128 to 127      |`%c`, `%hhi`| `char` forced to be signed                         |
-- **double**: like float but higher precision (usually 64 bit)
+| `unsigned char`           | integer, at least 0 to 255 (almost always the case)    |`%c`, `%hhu`| smallest memory chunk, **[byte](byte.md)**         |
-- **short**: smaller signed integer, at least 16 bits (−32767 to 32767)
+| `char`                    | integer, at least 256 values                           | `%c`       | signed or unsigned, used for string characters     |
-- **long**: bigger signed integer, at least 32 bits (-2147483647 to 2147483647)
+| `short`                   | integer, at least -32767 to 32767 (16 bit)             | `%hd`      | like `int` but supposed to be smaller              |
-- **pointer**: memory address (size depends on platform), always tied to a specific type, e.g. a pointer to integer: `*int`, pointer to double: `*double` etc.
+| `unsigned short`          | integer, non-negative, at least 0 to 65535             | `%hu`      | like `short` but unsigned                          |
-- **array**: a sequence of values of some type, e.g. an array of 10 integers: `int[10]`
+| `long`                    | integer, at least -2147483647 to 2147483647 (32 bit)   | `%ld`      | for big signed values                              |
-- **struct**: structure of values of different types, e.g. `struct myStruct { int myInt; chat myChar; }`
+| `unsigned long`           | integer, at least 0 to 4294967295 (32 bit)             | `%lu`      | for big unsigned values                            |
-- note: header *stdint.h* contains fixed-width data types such as *uint32_t* etc.
+| `long long`               | integer, at least some -9 * 10^18 to 9 * 10^18 (64 bit)| `%lld`     | for very big signed values                         |
-- note: there is no **string**, a string is an array of *char*s which must end with a value 0 (string terminator)
+| `unsigned long long`      | integer, at least 0 to 18446744073709551615 (64 bit)   | `%llu`     | for very big unsigned values                       |
-- note: there is no real **bool** (actually it is in header *stdbool*), integers are used instead (0 = false, 1 = true)
+| `float`                   | floating point, some -3 * 10^38 to 3 * 10^38           | `%f`       |[float](float.md), tricky, bloat, can be slow, avoid|
+| `double`                  | floating point, some -1 * 10^308 to 10^308             | `%lf`      | like `float` but bigger                            |
+| `T [N]`                   | array of `N` values of type `T`                        |            | **array**, if `T` is `char` then **string**        |
+| `T *`                     | memory address                                         | `%p`       | pointer to type `T`, (if `char` then **string**)   |
+| `uint8_t`                 | 0 to 255 (8 bit)                                       |`PRIu8`     |exact width, two's compl., must include `<stdint.h>`|
+| `int8_t`                  | -128 to 127 (8 bit)                                    |`PRId8`     | like `uint8_t` but signed                          |
+| `uint16_t`                | 0 to 65535 (16 bit)                                    |`PRIu16`    | like `uint8_t` but 16 bit                          |
+| `int16_t`                 | -32768 to 32767 (16 bit)                               |`PRId16`    | like `uint16_t` but signed                         |
+| `uint32_t`                | -2147483648 to 2147483647 (32 bit)                     |`PRIu32`    | like `uint8_t` but 32 bit                          |
+| `int32_t`                 | 0 to 4294967295 (32 bit)                               |`PRId32`    | like `uint32_t` but signed                         |
+| `int_least8_t`            | at least -128 to 127                                   |`PRIdLEAST8`| signed integer with at least 8 bits, `<stdint.h>`  |
+| `int_fast8_t`             | at least -128 to 127                                   |`PRIdFAST8` | fast signed int. with at least 8 bits, `<stdint.h>`|
+| struct                    |                                                        |            | structured data type                               |
+
+There is no **bool** (true, false), use any integer type, 0 is false, everything else is true (there may be some bool type in the stdlib, don't use that). A **string** is just array of chars, it has to end with value 0 (NOT ASCII character for "0" but literally integer value 0)!
+
+**main program structure**:
+
+```
+#include <stdio.h>
+
+int main(void)
+{
+  // code here
+  return 0;
+}
+```
 
 **branching aka if-then-else**:
 
@@ -160,7 +192,7 @@ while (CONDITION)
 }
 ```
 
-**do while loop** (same as *while* but CONDITION at the end):
+**do while loop** (same as *while* but CONDITION at the end), not used that much:
 
 ```
 do
@@ -176,8 +208,74 @@ RETURN_TYPE myFunction (TYPE1 param1, TYPE2 param2, ...)
 { // return type can be void
   // do something here
 }
-
 ```
+**compilation** (you can replace `gcc` with another compiler):
+
+- quickly compile and run: `gcc myprogram.c && ./a.out`.
+- compile more properly: `gcc -std=c99 -Wall -Wextra -pedantic -O3 -o myprogram myprogram.c`.
+
+To **[link](linking.md)** a library use `-llibrary`, e.g. `-lm` (when using `<math.h>`), `-lSDL2` etc.
+
+The following are some symbols ([functions](function.md), [macros](macro.md), ...) from the **standard library**:
+
+| symbol                    |  library        | description                                                        | example                                  |
+| ------------------------- | --------------- | ------------------------------------------------------------------ | ---------------------------------------- |
+| *putchar(c)*              | *stdio.h*       | Writes a single character to output.                               | `putchar('a');`                          |
+| *getchar()*               | *stdio.h*       | Reads a single character from input.                               | `int inputChar = getchar();`             |
+| *puts(s)*                 | *stdio.h*       | Writes string to output (adds newline at the end).                 | `puts("hello");`                         |
+| *printf(s, a, b, ...)*    | *stdio.h*       | Complex print func., allow printing numbers, their formatting etc. | `printf("value is %d\n",var);`           |
+| *scanf(s, a, b, ...)*     | *stdio.h*       | Complex reading func., allows reading numbers etc.                 | `scanf("%d",&var);`                      |
+| *fopen(f,mode)*           | *stdio.h*       | Opens file with given name in specific mode, returns pointer.      | `FILE *myFile = fopen("myfile.txt","r");`|
+| *fclose(f)*               | *stdio.h*       | Closes previously opened file.                                     | `fclose(myFile);`                        |
+| *fputc(c,f)*              | *stdio.h*       | Writes a single character to file.                                 | `fputc('a',myFile);`                     |
+| *fgetc(f)*                | *stdio.h*       | Reads a single character from file.                                | `int fileChar = fgetc(myFile);`          |
+| *fputs(s,f)*              | *stdio.h*       | Writes string to file (without newline at end).                    | `fputs("hello",myFile);`                 |
+| *fprintf(s, a, b, ...)*   | *stdio.h*       | Like `printf` but outputs to a file.                               | `fprintf(myFile,"value is %d\n",var);`   |
+| *fscanf(f, s, a, b, ...)* | *stdio.h*       | Like `scanf` but reads from a file.                                | `fscanf(myFile,"%d",&var);`              |
+| *fread(data,size,n,f)*    | *stdio.h*       | Reads *n* elems to *data* from *file*, returns no. of elems read.  | `fread(myArray,sizeof(item),1,myFile);`  |
+| *fwrite(data,size,n,f)*   | *stdio.h*       | Writes *n* elems from *data* to *file*, returns no. of elems writ. | `fwrite(myArray,sizeof(item),1,myFile);` |
+| *EOF*                     | *stdio.h*       | [End of file](eof.md) value.                                       | `int c = getchar(); if (c == EOF) break;`|
+| *rand()*                  | *stdlib.h*      | Returns pseudorandom number.                                       | `char randomLetter = 'a' + rand() % 26;` |
+| *srand(n)*                | *stdlib.h*      | Seeds pseudorandom number generator.                               | `srand(time(NULL));`                     |
+| *NULL*                    | *stdlib.h*, ... | Value assigned to pointers that point "nowhere".                   | `int *myPointer = NULL;`                 |
+| *malloc(size)*            | *stdlib.h*      | Dynamically allocates memory, returns pointer to it (or NULL).     | `int *myArr = malloc(sizeof(int) * 10);` |
+| *realloc(mem,size)*       | *stdlib.h*      | Resizes dynamically allocates memory, returns pointer (or NULL).   |`myArr = realloc(myArr,sizeof(int) * 20);`|
+| *free(mem)*               | *stdlib.h*      | Frees dynamically allocated memory.                                | `free(myArr);`                           |
+| *atof(str)*               | *stdlib.h*      | Converts string to floating point number.                          | `double val = atof(answerStr);`          |
+| *atoi(str)*               | *stdlib.h*      | Converts string to integer number.                                 | `int val = atof(answerStr);`             |
+| *EXIT_SUCCESS*            | *stdlib.h*      | Value the program should return on successful exit.                | `return EXIT_SUCCESS;`                   |
+| *EXIT_FAILURE*            | *stdlib.h*      | Value the program should return on exit with error.                | `return EXIT_FAILURE;`                   |
+| *sin(x)*                  | *math.h*        | Returns [sine](sin.md) of angle in [RADIANS](rad.md).              | `float angleSin = sin(angle);`           |
+| *cos(x)*                  | *math.h*        | Like `sin` but returns cosine.                                     | `float angleCos = cos(angle);`           |
+| *tan(x)*                  | *math.h*        | Returns [tangent](tan.md) of angle in RADIANS.                     | `float angleTan = tan(angle);`           |
+| *asin(x)*                 | *math.h*        | Returns arcus sine of angle, in RADIANS.                           | `float angle = asin(angleSine);`         |
+| *ceil(x)*                 | *math.h*        | Rounds a floating point value up.                                  | `double x = ceil(y);`                    |
+| *floor(x)*                | *math.h*        | Rounds a floating point value down.                                | `double x = floor(y);`                   |
+| *fmod(a,b)*               | *math.h*        | Returns floating point reminded after division.                    | `double rem = modf(x,3.5);`              |
+| *isnan(x)*                | *math.h*        | Checks if given float value is NaN.                                | `if (!isnan(x))`                         |
+| *NAN*                     | *math.h*        | Float quiet [NaN](nan.md) (not a number) value, don't compare!     | `if (y == 0) return NAN;`                |
+| *log(x)*                  | *math.h*        | Computes natural [logarithm](log.md) (base [e](e.md)).             | `double x = log(y);`                     |
+| *log10(x)*                | *math.h*        | Computes decadic [logarithm](log.md) (base 10).                    | `double x = log10(y);`                   |
+| *log2(x)*                 | *math.h*        | Computes binary [logarithm](log.md) (base 2).                      | `double x = log2(y);`                    |
+| *exp(x)*                  | *math.h*        | Computes exponential function (*e^x*).                             | `double x = exp(y);`                     |
+| *sqrt(x)*                 | *math.h*        | Computes floating point [square root](sqrt.md).                    | `double dist = sqrt(dx * dx + dy * dy);` |
+| *pow(a,b)*                | *math.h*        | Power, raises *a* to *b* (both floating point).                    | `double cubeRoot = pow(var,1.0/3.0);`    |
+| *abs(x)*                  | *math.h*        | Computes [absolute value](abs.md).                                 | `double varAbs = abs(var);`              |
+| *INT_MAX*                 | *limits.h*      | Maximum value that can be stored in `int` type.                    | `printf("int max: %d\n",INT_MAX);`       |
+| *memset(mem,val,size)*    | *string.h*      | Fills block of memory with given values.                           | `memset(myArr,0,sizeof(myArr));`         |
+| *memcpy(dest,src,size)*   | *string.h*      | Copies bytes of memory from one place to another, returns dest.    | `memcpy(destArr,srcArr,sizeof(srcArr);`  |
+| *strcpy(dest,src)*        | *string.h*      | Copies string (zero terminated) to dest, unsafe.                   | `char myStr[16]; strcpy(myStr,"hello");` |
+| *strncpy(dest,src,n)*     | *string.h*      | Like `strcpy` but limits max number of bytes to copy, safer.       |`strncpy(destStr,srcStr,sizeof(destStr));`|
+| *strcmp(s1,s2)*           | *string.h*      | Compares two strings, returns 0 if equal.                          | `if (!strcmp(str1,"something"))`         |
+| *strlen(str)*             | *string.h*      | Returns length of given string.                                    | `int l = strlen(myStr);`                 |
+| *strstr(str,substr)*      | *string.h*      | Finds substring in string, returns pointer to it (or NULL).        | `if (strstr(cmdStr,"quit") != NULL)`     |
+| *time(t)*                 | *time.h*        |Stores calendar time (often Unix t.) in t (can be NULL), returns it.|`printf("tstamp: %d\n",(int) time(NULL));`|
+| *clock()*                 | *time.h*        | Returns approx. CPU cycle count since program start.               |`printf("CPU ticks: %d\n",(int) clock());`|
+| *CLOCKS_PER_SEC*          | *time.h*        | Number of CPU ticks per second.                                    |`int sElapsed = clock() / CLOCKS_PER_SEC;`|
+
+## Some Programs In C
+
+TODO
 
 ## See Also
 

cpu.md

@@ -20,7 +20,7 @@ Let's take a look at how a typical CPU works. Remember that anything may differ
 
 The CPU has some internal state (we can see it as a [state machine](finite_state_machine.md)), i.e. it has a few internal variables, called **[registers](register.md)**; these are NOT variables in RAM but rather in the CPU itself, there is only a few of them (there may be let's say 32) but they are extremely fast. What exactly these registers are, what they are called, how many [bits](bit.md) they can hold and what their purpose is depends again on the instruction set architecture. However there are usually a few special registers, notably the **program counter** which holds the address of the currently executed instruction. After executing an instruction program counter is incremented so that in the nest step the next instruction will be executed, AND we can also modify program counter (sometimes directly, sometimes by specialized instructions) to jump between instruction to implement branching, loops, function calls etc.
 
-So at the beginning (when powered on) the CPU is set to some initial state, most notably it sets its program counter to some initial value (depending on each CPU, it may be e.g. 0) so that it points to the first instruction of the program. Then it performs so called **fetch, decode, execute** cycle, i.e. it reads the instruction, decodes what it means and does what it says. In simpler CPUs this functionality is hard wired, however more complex CPUs are programmed in so called [microcode](microcode.md), a code yet at the lower level than machine code, machine code execution is programmed in microcode -- microcode is something like "[firmware](firmware.md) for the CPU" (or a "CPU [shader](shader.md)"?), it basically allows later updates and reprogramming of how the CPU internally works. However this is pretty [overcomplicated](bloat.md) and you shouldn't make CPUs like this.
+So at the beginning (when powered on) the CPU is set to some initial state, most notably it sets its program counter to some initial value (depending on each CPU, it may be e.g. 0) so that it points to the first instruction of the program. Then it performs so called **fetch, decode, execute** cycle, i.e. it reads the instruction, decodes what it means and does what it says. In simpler CPUs this functionality is hard wired, however more complex CPUs (especially [CISC](cisc.md)) are programmed in so called [microcode](microcode.md), a code yet at the lower level than machine code, machine code execution is programmed in microcode -- microcode is something like "[firmware](firmware.md) for the CPU" (or a "CPU [shader](shader.md)"?), it basically allows later updates and reprogramming of how the CPU internally works. However this is pretty [overcomplicated](bloat.md) and you shouldn't make CPUs like this.
 
 A CPU works in **clock cycles**, i.e. it is a sequential circuit which has so called *clock* input; on this input voltage periodically switches between high and low (1 and 0) and each change makes the CPU perform another operation cycle. How fast the clock changes is determined by the clock **frequency** (nowadays usually around 3 GHz) -- the faster the frequency, the faster the CPU will compute, but the more it will also heat up (so we can't just set it up arbitrarily high, but we can [overclock](overclocking.md) it a bit if we are cooling it down). WATCH OUT: **one clock cycle doesn't necessarily equal one executed instruction**, i.e. frequency of 1 Hz doesn't have to mean the CPU will execute 1 instruction per second because executing an instruction may take several cycles (how many depends on each instruction and also other factors). The number saying how many cycles an instruction takes is called CPI (cycles per instruction) -- CPUs try to aim for CPI 1, i.e. they try to execute 1 instruction per cycle, but they can't always do it.
 
@@ -38,7 +38,7 @@ Mainstream consoomer CPUs nowadays have multiple **[cores](core.md)** so that ea
 
 **[Interrupts](interrput.md)** are an important concept for the CPU and for low level programming, they play a role e.g. in saving power -- high level programmers often don't know what interrupts are, to those interrupts can be likened to "event [callbacks](callback.md)". An interrupt happens on some kind of even, for example when a key is pressed, when timer ticks, when error occurred etc. (An interrupt can also be raised by the CPU itself, this is how operating system [syscalls](syscall.md) are often implemented). What kinds of interrupts there are depends on each CPU architecture (consult your datasheet) and one can usually configure which interrupts to enable and which "callbacks" to use for them -- this is often done through so called **[vector](vector.md) table**, a special area in memory that records addresses ("vectors") of routines (functions/subprograms) to be called on specified interrupts. When interrupt happens, the current program execution is paused and the CPU automatically jumps to the subroutine for handling the interrupt -- after returning from the subroutine the main program execution continues. Interrupts are contrasted with **[polling](polling.md)**, i.e. manually checking some state and handling things as part of the main program, e.g. executing an infinite loop in which we repeatedly check keyboard state until some key is pressed. However polling is inefficient, it wastes power by constantly performing computation just by waiting -- interrupts on the other hand are a hard wired functionality that just performs a task when it happens without any overhead of polling. Furthermore interrupts can make programming easier (you save many condition checks and memory reads) and mainly **interrupts allow CPU to go into sleep mode** and so save a lot of power. When a CPU doesn't have any computation to do, it can stop itself and go into waiting state, not executing any instructions -- however interrupts still work and when something happens, the CPU jumps back in to work. This is typically what the `sleep`/`wait` function in your programming language does -- it puts the CPU to sleep and sets a timer interrupt to wake up after given amount of time. As a programmer you should know that you should call this sleep/wait function in your main program loop to relieve the CPU -- if you don't, you will notice the **CPU utilization** (amount of time it is performing computations) will go to 100%, it will heat up, your computer starts spinning the fans and be noisy because you don't let it rest.
 
-There are often several **modes** of operation in a CPU which is typically meant for operating systems -- there will usually be some kind of privileged mode in which the CPU can do whatever it wants (this is the mode for the OS kernel) and a restricted mode in which there are restrictions, e.g. on which areas of memory can be accessed or which instructions can be used (this will be used for user program). Thanks to this a user program won't be able to crash the operating system, it will at worst crash itself. See also *real mode* and *protected mode*.
+Frequently there are several **modes** of operation in a CPU which is typically meant for operating systems -- there will usually be some kind of privileged mode in which the CPU can do whatever it wants (this is the mode for the OS kernel) and a restricted mode in which there are restrictions, e.g. on which areas of memory can be accessed or which instructions can be used (this will be used for user program). Thanks to this a user program won't be able to crash the operating system, it will at worst crash itself. Most notably x86 CPUs have the *real mode* (addresses correspond to real, physical addresses) and *protected mode* (memory is [virtualized](virtual_memory.md), protected, addresses don't generally correspond to physical addresses).
 
 A CPU may also have integrated some **[coprocessors](coprocessor.md)**, though sometimes coprocessors are really a separate chip. Coprocessors that may be inside the CPU include e.g. the FPU ([floating point](float.md) unit) or encryption coprocessor. Again, this will make the CPU a lot more expensive.
 

hacking.md

@@ -8,11 +8,13 @@ Hacking (also hackerdom) in the widest sense means exploiting usually (but not n
 
 The original hacker culture is a culture of the earliest computer programmers, usually smart but socially rather isolated nerds -- at the time mostly physicists, mathematicians and engineers -- who shared deep love for programming and pure joy of coming up with clever computer tricks, exploration of computers and freely sharing their knowledge and computer programs with each other. The culture started to develop rapidly at [MIT](mit.md) in about the second half of 1960s, though other hacker communities existed earlier and in other places as well (still mostly at universities).
 
+Nowadays this original culture is very sadly becoming almost completely extinct, owing to the [modern](modern.md) world whose values -- such as self interest, consumerism, secrecy, praise of censorship, "inclusivity" of the incompetent, materialism etc. -- are mostly polar opposites of the original hacker values: a newly born man would have to reject 99% of the culture he grew up in to be able to adopt the hacker mindset. The culture seems to live on mostly in individuals, mostly the old hackers themselves, and partially in some extremely underground communities such as that of the [demoscene](demoscene.md), but even there it's degenerating greatly.
+
 The word *hack* itself seems to have come from a model train club at MIT in whose slang the word referred to something like a project of passion without a specific goal; before this the word was used around MIT for a specific kind of clever but harmless pranks. Members of the model train club came to contact with early computers at MIT and brought their slang along. These early punch-card computers were expensive and sacred, hackers treated them as almost supernatural entities; in the book *Hackers* it is mentioned that those who were allowed to operate the machines were called *Priests* -- Priests would often carry out a little prayer to please the machine so that it would bless them with computation. During 60s and 70s so called [phreaking](phreaking.md) -- hacking the phone network -- was popular among hackers.
 
-Many ideas -- such as the beauty of [minimalism](minimalism.md) -- that became part of hacker culture later came from the development of [Unix](unix.md) and establishment of its [programming philosophy](unix_philosophy.md). Many hackers came from the communities revolving around [PDP 10](pdp_10.md) and [ARPANET](arpanet.md), and later around networks such as [Usenet](usenet.md). At the time when computers started to be abused by corporations, [Richard Stallman's](rms.md) definition of [free software](free_software.md) and his [GNU](gnu.md) project embodied the strong hacker belief in information freedom and their opposition of [intellectual property](intellectual_property.md).
+Many ideas -- such as the beauty of [minimalism](minimalism.md) -- that became part of hacker culture later came from the development of [Unix](unix.md) and establishment of its [programming philosophy](unix_philosophy.md). Many hackers came from the communities revolving around [PDP 10](pdp_10.md) and [ARPANET](arpanet.md), and later around networks such as [Usenet](usenet.md). At the time when computers started to be abused by corporations, [Richard Stallman's](rms.md) definition of [free software](free_software.md) and his [GNU](gnu.md) project embodied the strong hacker belief in information freedom and their opposition of [intellectual property](intellectual_property.md). When computer technology became invaded and raped by [capitalism](capitalism.md), hackers separated themselves from the influx of coding monkeys and managers not only culturally, but also by retaining their programming philosophy -- programming of a hacker is very different from the ugly "software development" of a [corporation](corporation.md), a hacker writes [beautiful](beauty.md), [minimal](minimalism.md) code. He doesn't merely aim to "get the job done", he creates art, a code that works well while being a beauty of engineering on the inside, he isn't afraid to throw away code and rewrite it from scratch just to make it a little better (as opposed to patching it up, [bloating](bloat.md) and extending it, as a corporation would do).
 
-The culture has a deep lore and its own literature consisting of books that hackers usually like (e.g. The Hitchhiker's Guide to the Galaxy) and books by hackers themselves. Bits of the lore are in forms of short stories circulated as folklore, very popular form are so called Koans. Perhaps the most iconic hacker story is the [Story of Mel](story_of_mel.md) which tells a true story of a master hacker keeping to his personal ethical beliefs under the pressure of his corporate employers -- a conflict between manager employers ("suits") and hacker employees is a common theme in the stories. Other famous stories include the *TV typewriter* and *Magic Switch*. One of the most famous hacker books is the **[Jargon File](jargon_file.md)**, a collectively written dictionary documenting hacker culture in detail. A 1987 book *[The Tao of Programming](tao_of_programming.md)* captures the hacker wisdom with Taoist-like texts that show how spiritual hacking can get -- this reflects the above mentioned sacred nature of the early computers. The *textfiles* website features many text files on hacking at https://textfiles.vistech.net/hacking/. See also *Ten Commandments for C Programmers* etc. A lot about hackers can be learned from books about them, e.g. the [free](free_culture.md) book *Free as in Freedom* about [Richard Stallman](rms.md) (available e.g. [here](https://www.gutenberg.org/ebooks/5768)). A prominent hacker writer is [Eric S. Raymond](esr.md) who produced a very famous essay *The Cathedral and the Bazaar*, edited the Jargon File and has written a large guide called *How To Become A Hacker* -- these are all good resources on hackerdom, even though Raymond himself is kind of shitty, he for example prefers the "[open source](open_source.md)" movement to [free software](free_software.md).
+The culture has a deep lore and its own literature consisting of books that hackers usually like (e.g. The Hitchhiker's Guide to the Galaxy) and books by hackers themselves. Bits of the lore are in forms of short stories circulated as folklore, very popular form are so called Koans. Perhaps the most iconic hacker story is the [Story of Mel](story_of_mel.md) which tells a true story of a master hacker keeping to his personal ethical beliefs under the pressure of his corporate employers -- a conflict between manager employers ("suits") and hacker employees is a common theme in the stories. Other famous stories include the *TV typewriter* and *Magic Switch*. One of the most famous hacker books is the **[Jargon File](jargon_file.md)**, a collectively written dictionary documenting hacker culture in detail. A 1987 book *[The Tao of Programming](tao_of_programming.md)* captures the hacker wisdom with Taoist-like texts that show how spiritual hacking can get -- this reflects the above mentioned sacred nature of the early computers. Hacker culture very frequently mimics eastern religions and philosophies such as Taoism, Buddhism or various martial arts. The *textfiles* website features many text files on hacking at https://textfiles.vistech.net/hacking/. See also *Ten Commandments for C Programmers* etc. A lot about hackers can be learned from books about them, e.g. the [free](free_culture.md) book *Free as in Freedom* about [Richard Stallman](rms.md) (available e.g. [here](https://www.gutenberg.org/ebooks/5768)). A prominent hacker writer is [Eric S. Raymond](esr.md) who produced a very famous essay *The Cathedral and the Bazaar*, edited the Jargon File and has written guides such as *How To Become A Hacker* and *How To Learn Hacking* -- these are all good resources on hackerdom, even though Raymond himself is kind of shitty, he for example prefers the "[open source](open_source.md)" movement to [free software](free_software.md).
 
 As a symbol of hackerdom the glider symbol from [game of life](game_of_life.md) is sometimes used, it looks like this:
 
@@ -31,13 +33,14 @@ Let us now attempt to briefly summarize what it means to be a hacker:
 - **Hacker values [fun](fun.md) and playfulness** -- despite his serious dedication to the art, he hates seriousness of the business guys and "suits", as well as the self-centered, egoistic attitude of "modern hackers" who might see or present themselves as kind of [superheroes](hero_culture.md). A hacker will give his programs funny names rather than names that would make for a good business product, a hacker will insert jokes in his source code (e.g. [hex](hexadecimal.md) values such as 0xBEEFFACE), documentation and speech ([Jargon File](jargon_file.md) has a whole section on how hackers construct and use words).
 - **Hacker aims for ingenuity, cleverness, elegance, [minimalism](minimalism.md), thinking out of the box** etc. As such he loves [math](math.md), puzzles, intellectual challenges (such as [code golfing](code_golf.md)) and despises ugly commercial ways of mainstream technology, i.e. that which is [bloated](bloat.md), hastily made to impress by visuals or cheap "killer features" while hiding ugly internals etc.
 - **Hacker loves hacking and tinkering in itself -- hacking is the goal, not the means. Hacking is [art](art.md) and carries deep intellectual and even spiritual value.** To a hacker it is a joy to program computers and he aims for nothing more than enjoy endless hours of programming, programming is NOT a tool to achieve low goals such as monetary profit or mainstream fame. Many hackers claim that hacking is better than [sex](sex.md) (though it is questionable whether many of them have experience with the latter).
+- **Hacker is an elitist, attitude is not enough for being a hacker**, skill is of essential importance. Correct attitude and mindset are important and necessary but not sufficient (as ESR writes: "attitude is no substitute for competence") -- if you don't excel at hacking, you are not a hacker. This is in contrast e.g. with music genre fans where you can consider yourself to be "punk" or "metal" even if you can't play any musical instrument or with the [modern](modern.md) "inclusive" "[coder](coding.md)" culture in which you can easily be called a game developer even if you cannot [program](programming.md) etc. Part of hackerdom is also an aim for good reputation among others, to be called a hacker by OTHERS, HOWEVER this has to be achieved without asking or self promotion, merely through doing good hacking, you must not beg others to "please call you a hacker" or promote your programs with marketing to achieve cheap popularity -- no, reputation or the title of hacker is NOT the goal in itself, the goal is good hacking and reputation is an indication you achieved it.
 - **Hacker has strong opinions about technology**, for example about what the best [text editor](text_editor.md) or best [programming language](programming_language.md) is. However hackers may also sometimes disagree which results in **[holy wars](holy_war.md)**.
 
 Let's mention a few [people](people.md) who were at their time regarded by at least some as true hackers, however note that many of them betrayed some of the hacker ways either later in life or even in their young years -- people aren't perfect and no single individual is a perfect example of a whole culture. With that said, those regarded hackers included Melvin Kaye aka [Mel](mel.md), [Richard Stallman](rms.md), [Linus Torvalds](linus_torvalds.md), [Eric S. Raymond](esr.md), [Ken Thompson](ken_thompson.md), [Dennis Ritchie](dennis_ritchie.md), [Richard Greenblatt](greenblatt.md), [Bill Gosper](bill_gosper.md), [Steve Wozniak](wozniak.md) or [Larry Wall](larry_wall.md).
 
 ## "[Modern](modern.md)" "Hackers"
 
-Many modern [zoomer](zoomer.md) [soydevs](soydev.md) call themselved "hackers" but there are basically none that would stay true to the original ethics and culture and be worthy of being called a true hacker, they just abuse the word as a cool term or a brand (see e.g. ["hacker" news](hacker_news.md)). It's pretty sad the word has become a laughable parody of its original meaning by being associated with groups such as [Anonymous](anonymous.md) who are just a bunch of 14 year old children trying to look like "movie hackers". The hacker culture has been spoiled basically in the same ways the rest of society, and the difference between classic hacker culture and the "modern" one is similar to the difference between [free software](free_software.md) and [open source](open_source.md), though perhaps more amplified -- the original culture of strong ethics has become twisted by [capitalist](capitalism.md) trends such as self-interest, commercialization, [fashion](fashion.md), mainstreamization, even shitty movie adaptations etc. The modern "hackers" are idiots who have never seen [assembly](assembly.md), can't do [math](math.md), they're turds in suits who make [startups](startup.md) and work as [influencers](influencer.md), they are tech consumers who use and even create [bloat](bloat.md), and possibly even [proprietary](proprietary.md) software. For the love of god, do NOT mimic such caricatures or give them attention -- not only are they not real hackers, they are simply retarded attention whores.
+Many modern [zoomer](zoomer.md) [soydevs](soydev.md) call themselved "hackers" but there are basically none that would stay true to the original ethics and culture and be worthy of being called a true hacker, they just abuse the word as a cool term or a brand (see e.g. ["hacker" news](hacker_news.md), a capitalist circlejerk website where self proclaimed smartass "hackers" come to advertise their ugly bloated [rapeware](rapeware.md) and talk about how to best exploit the market). It's pretty sad the word has become a laughable parody of its original meaning by being associated with groups such as [Anonymous](anonymous.md) who are just a bunch of 14 year old children trying to look like "movie hackers". The hacker culture has been spoiled basically in the same ways the rest of society, and the difference between classic hacker culture and the "modern" one is similar to the difference between [free software](free_software.md) and [open source](open_source.md), though perhaps more amplified -- the original culture of strong ethics has become twisted by [capitalist](capitalism.md) trends such as self-interest, commercialization, [fashion](fashion.md), mainstreamization, even shitty movie adaptations etc. The modern "hackers" are idiots who have never seen [assembly](assembly.md), can't do [math](math.md), they're turds in suits who make [startups](startup.md), aren't afraid to suck corporation dicks and work as [influencers](influencer.md), they are tech consumers with who use and even create [bloat](bloat.md), and possibly even [proprietary](proprietary.md) software. For the love of god, do NOT mimic such caricatures or give them attention -- not only are they not real hackers, they are simply retarded attention whores.
 
 ## Security "Hackers"
 

history.md

@@ -2,7 +2,7 @@
 
 { Though history is usually written by the winners, this one was written by a loser :) Keep in mind there may appear errors, you can send me an email if you find some. ~drummyfish }
 
-This is a brief summary of history of [technology](technology.md) and [computers](computer.md) (and some other things).
+This is a brief summary of history of [technology](technology.md) and [computers](computer.md) (and some other things). For those who don't know history are doomed to repeated it.
 
 The earliest known appearance of technology related to humans is the use of **stone tools** of hominids in Africa some two and a half million years ago. Learning to start and control **[fire](fire.md)** was one of the most important advances of earliest humans; this probably happened hundreds of thousands to millions years ago, even before modern humans. Around 8000 BC the **[Agricultural Revolution](agricultural_revolution.md)** happened: this was a disaster -- as humans domesticated animals and plants, they had to abandon the comfortable life of hunters and gatherers and started to suffer greatly from the extremely hard [work](work.md) on their fields (this can be seen e.g. from their bones). This led to the establishment of first cities. Primitive **writing** can be traced to about 7000 BC to China. **[Wheel](wheel.md)** was another extremely useful technology humans invented, it is not known exactly when or where it appeared, but it might have been some time after 5000 BC -- in Ancient Egypt **The Great Pyramid** was built around 2570 BC still without the knowledge of wheel. Around 4000 BC **history starts with first written records**. Humans learned to smelt and use metals approximately 3300 BC (**Bronze Age**) and 1200 BC (**Iron Age**). **[Abacus](abacus.md)**, one of the simplest devices aiding with computation, was invented roughly around 2500 BC. However people used primitive computation helping tools, such as bone ribs, probably almost from the time they started trading. Babylonians in around 2000 BC were already able to solve some forms of **[quadratic equations](quadratic_equation.md)**.
 

how_to.md

@@ -81,7 +81,7 @@ Also please take a look at [gopher](gopher.md) (a much better alternative to web
 
 Here we will quickly sum up how to make a **[static](static.md), single page plain [HTML](html.md) website without TLS (https)**, which should suffice for most things (sharing opinions, contacts, files, multimedia, simple blogging, ...). Once you get more advanced you can do fancy stuff like this wiki (multi-page wiki written in [Markdown](markdown.md), compiled to HTML with a shell script etc.).
 
-**NOTE on TLS (https)**: most sites on the web nowadays use encryption for MUH SECURITY obsession and also web browsers kinda prefer such sites etc. (in the future it will probably be required but by then we'll already be elsewhere) -- such site addresses are prefixed with `https://`, as opposed to normal non-encrypted `http://`. Encryption is huge [bloat](bloat.md) and mess to set up, normally you need to pay extra money to get a [certificate](certificate.md) for it (though services like Let's Encrypt provide certificates for free) etc. -- basically you only need encryption if you have an interactive site where passwords or other sensitive info gets sent, a purely static site basically doesn't need encryption at all, however if your site doesn't support encryption it may get some penalty by search engines and browsers as they won't "trust it as much", it's just a form of internet bullying for not conforming to latest encryption hysteria. All in all if you can set up encryption easily (e.g. with a single button on your web hosting provider site), do it just for the sake of normies; if you are experienced and can set it up yourself easily, also do it, but if not, just don't care about it and run your site on `http://` only, at least for now until you get into this stuff.
+**NOTE on TLS (https)**: most sites on the web nowadays use encryption for MUH SECURITY obsession and also web browsers kinda prefer such sites etc. (in the future it will probably be required but by then we'll already be elsewhere) -- such site addresses are prefixed with `https://`, as opposed to normal non-encrypted `http://`. [Encryption](encryption.md) is huge [bloat](bloat.md) and mess to set up, normally you need to pay extra money to get a [certificate](certificate.md) for it (though services like Let's Encrypt provide certificates for free) etc. -- basically you only need encryption if you have an interactive site where passwords or other sensitive info gets sent, a purely static site basically doesn't need encryption at all, however if your site doesn't support encryption it may get some penalty by search engines and browsers as they won't "trust it as much", it's just a form of internet bullying for not conforming to latest encryption hysteria. All in all if you can set up encryption easily (e.g. with a single button on your web hosting provider site), do it just for the sake of normies; if you are experienced and can set it up yourself easily, also do it, but if not, just don't care about it and run your site on `http://` only, at least for now until you get into this stuff. Also very importantly **always support plain unencrypted http** even if you set up https, otherwise you're bullying simple browsers that don't implement encryption.
 
 Now **do NOT follow mainstream tutorials on making website** (Wordpress, PHP, static generators, ...) -- these are absolute horseshit and just follow ugly capitalist ways, you will just get brain cancer. Also do NOT use any frameworks; **do NOT even use static site generators** -- these are not needed at all! All you really need for making a small website is:
 

jokes.md

@@ -26,6 +26,7 @@ Also remember the worst thing you can do to a joke is put a [disclaimer](disclai
 - "Never test for a bug that you don't know how to fix." --manager; "If we cannot fix it, it isn't broken." --also manager
 - a joke for minimalists:
 - When is [Micro$oft](microsoft.md) finally gonna make a product that doesn't suck???! Probably when they start manufacturing vacuum cleaners.
+- Can [free software](free_software.md) lead to insanity? I don't know, but it can make you [GNU](gnu.md)ts.
 - Political activists walk into a bar. [Pseudoleftist](pseudoleft) tells his friends: "hey guys, how about we have oppressive rulers and call them a [government](government.md)?" Capitalist says: "well no, let's have oppressive rulers and call them [corporations](corporation.md)". [Liberal](liberal.md) replies: "Why not both?". Monarchist goes: "no, it's all wrong, let's have oppressive rulers and call them Kings." To this pseudo communist says: "that's just shit, let's have oppressive rulers and call them the [proletariat](proletariat.md)". Then [anarcho pacifist](anpac.md) turns to them and says: "Hmmm, how about we don't have any oppressive rulers?". They lynch him.
 - There are a lot of jokes at https://jcdverha.home.xs4all.nl/scijokes/. Also http://textfiles.com/humor/JOKES/.
 - Hello, is this anonymous [pedophile](pedophilia.md) help hotline? Yes. My 8yo daughter begs for sex, can we do penetration right away or should we start with anal?

lrs_dictionary.md

@@ -32,6 +32,7 @@ WORK IN PROGRESS
 | [global warming](global_warming.md)        | global heating                         |
 | [Google](google.md)                        | Goolag                                 |
 | Gmail                                      | Gfail                                  |
+| [GNU](gnu.md)                              | GNUts, freetards                       |
 | influencer                                 | manipulator                            |
 | [Intel](intel.md)                          | [Incel](incel.md)                      |
 | [Internet Explorer](internet_explorer.md)  | Internet Exploder, Internet Exploiter  |

nigger.md

@@ -14,6 +14,7 @@ The word is used in a number of projects and works, e.g.:
 - **[Gay Nigger Association of America](gnaa.md)** (GNAA): what the name says
 - **Ten Little Niggers**, a book by one of the most famous writers, Agatha Christie.
 - **On the Creation of Niggers** (https://en.m.wikisource.org/wiki/On_the_Creation_of_Niggers), a short poem by H. P. Lovecraft, one of the greatest authors of all time.
+- **Nigger in the Wonderland**, an old [game](game.md).
 - ...
 
 { LOL take a look at this https://encyclopediadramatica.online/Nigger, another take at https://wiki.soyjaks.party/Nigger. Another website: http://niggermania.com. Also https://www.chimpout.com. Another one: http://www.nigrapedia.com. ~drummyfish }

programming.md

@@ -23,7 +23,7 @@ OK, now the key thing to becoming a programmer is learning a [programming langua
 
 **Can you become a good programmer when you're old?** Well, as with everything to become a SERIOUSLY good programmer you should have probably started before the age of 20, the majority of the legend programmers started before 10, it's just like with sports or becoming an excellent musician. But with enough enthusiasm and endurance you can become a pretty good programmer at any age, just like you can learn to play an instrument or run marathon basically at any age, it will just take longer and a lot of energy. You don't even have to aim to become very good, becoming just average is enough to write simple gaymes and have a bit of fun in life :) Just don't try to learn programming because it seems cool, because you want to look like movie haxor, gain followers on youtube or because you need a job -- if you're not having genuine fun just thinking before sleep about how to swap two variables without using a temporary variable, programming is probably not for you. **Can you become a good programmer if you're black or [woman](woman.md)?** No. :D Ok, maybe you can, but all the above applies, don't do it for politics or money or followers -- if you become a seriously based programmer (from [LRS](lrs.md) point of view) of unlikely minority, we'll be more than happy to put an apology here, in ALL CAPS and bold letters :) Hopefully this will inspire someone...
 
-**Which programming language to start with?** This is the big question. Though languages such as [Python](python.md) or [JavaScript](javascript.md) are objectively really REALLY bad, they are nowadays possibly the easiest way to get into programming, so you may want to just pick one of these two, knowing you'll abandon it later to learn a true language such as [C](c.md) (and knowing the bad language will still serve you in the future in some ways, it's not a wasted time). Can you start with C right away? It's probably not impossible for a genius but it will be VERY hard and you'll most likely end up failing, overwhelmed, frustrated and never returning to programming again. Absolutely do NOT even consider [C#](c_sharp.md) (shit, unusable), [Java](java.md) (shit, slow, bloated, unusable), [C++](cpp.md) (like C but shit and more complicated), [Haskell](haskell.md) (non-traditional, hard), [Rust](rust.md) (shit, bad design, unusable), [Go](go.md) (prolly hard), [Lisp](lisp.md) (non-traditional), [Prolog](prolog.md) (lol) and similar languages -- you may explore these later. Whichever language you pick for the love of god **avoid [OOP](oop.md)** -- no matter what anyone tells you, when you see a tutorial that uses "classes"/"objects" just move on, learn normal [imperative](imperative.md) programming. OOP is a huge pile of shit meme that you will learn anyway later (because everyone writes it nowadays) so that you see why it's shit and why you shouldn't use it.
+**Which programming language to start with?** This is the big question. Though languages such as [Python](python.md) or [JavaScript](javascript.md) are objectively really REALLY bad, they are nowadays possibly the easiest way to get into programming, so you may want to just pick one of these two, knowing you'll abandon it later to learn a true language such as [C](c.md) (and knowing the bad language will still serve you in the future in some ways, it's not a wasted time). Can you start with C right away? It's probably not impossible for a genius but it will be VERY hard and you'll most likely end up failing, overwhelmed, frustrated and never returning to programming again. In *How To Become A Hacker* ESR actually recommends to learn C, Lisp or [Go](golang.md) as the first language, but that recommendation comes to aspiring hackers, i.e. the most talented and ambitious programmers, so think about whether you fit this category. Absolutely do NOT even consider [C#](c_sharp.md) (shit, unusable), [Java](java.md) (shit, slow, bloated, unusable), [C++](cpp.md) (like C but shit and more complicated), [Haskell](haskell.md) (non-traditional, hard), [Rust](rust.md) (shit, bad design, unusable), [Go](go.md) (prolly hard), [Lisp](lisp.md) (non-traditional), [Prolog](prolog.md) (lol) and similar languages -- you may explore these later. Whichever language you pick for the love of god **avoid [OOP](oop.md)** -- no matter what anyone tells you, when you see a tutorial that uses "classes"/"objects" just move on, learn normal [imperative](imperative.md) programming. OOP is a huge pile of shit meme that you will learn anyway later (because everyone writes it nowadays) so that you see why it's shit and why you shouldn't use it.
 
 { I really started programming in [Pascal](pascal.md) at school, it was actually a good language as it worked very similarly to C and the transition later wasn't that hard, but nowadays learning Pascal doesn't make much sense anymore. ~drummyfish }
 

programming_language.md

@@ -97,7 +97,7 @@ Here is a table of notable programming languages in chronological order (keep in
 | [Basic](basic.md)       | kind of?         | 1964  |                         |                        | mean both for beginners and professionals, probably efficient           |
 | [Forth](forth.md)       | **yes**          | 1970  |100 (judg. by milliforth)| 1                      | [stack](stack.md)-based, elegant, very KISS, interpreted and compiled   |
 | [Pascal](pascal.md)     | **kind of**      | 1970  |                         |                        | like "educational C", compiled, not so bad actually                     |
-| **[C](c.md)**           | **kind of**      | 1972  | 25K (tcc)               | 160, proprietary       | compiled, fastest, efficient, established, suckless, low-level, #1 lang.|
+| **[C](c.md)**           | **kind of**      | 1972  | 20K (lcc)               | 160, proprietary       | compiled, fastest, efficient, established, suckless, low-level, #1 lang.|
 | [Prolog](prolog.md)     | maybe?           | 1972  |                         |                        | [logic](logic.md) paradigm, hard to learn/use                           |
 |[Smalltalk](smalltalk.md)| looks like yes?  | 1972  |                         |                        | PURE [OOP](oop.md) language, probably not as corrupt as C++/Java/...    |
 | [C++](cpp.md)           | no, bearable     | 1982  |                         | 500, proprietary       | bastard child of C, only adds [bloat](bloat.md) ([OOP](oop.md)), "games"|

shit.md

@@ -8,5 +8,6 @@ Some **things that are shit** include [systemd](systemd.md), [capitalism](capita
 
 ## See Also
 
+- [crap](crap.md)
 - [cancer](cancer.md)
 - [harmful](harmful.md)

wiki_stats.md

@@ -3,8 +3,8 @@
 This is an autogenerated article holding stats about this wiki.
 
 - number of articles: 559
-- number of commits: 697
+- number of commits: 698
-- total size of all texts in bytes: 3031771
+- total size of all texts in bytes: 3054158
 
 longest articles:
 
@@ -15,15 +15,46 @@ longest articles:
  52K less_retarded_society.md
  48K chess.md
  36K faq.md
+ 32K c.md
  32K 3d_rendering.md
  32K game.md
  32K random_page.md
- 32K programming_language.md
 ```
 
 latest changes:
 
 ```
+Date:   Sun Feb 18 17:14:46 2024 +0100
+ai.md
+bbs.md
+binary.md
+brainfuck.md
+c.md
+computer.md
+cpu.md
+fixed_point.md
+float.md
+fractal.md
+history.md
+internet.md
+linux.md
+lrs_dictionary.md
+lrs_wiki.md
+mechanical.md
+often_confused.md
+operating_system.md
+pi.md
+programming.md
+programming_language.md
+public_domain.md
+quine.md
+random_page.md
+shit.md
+steve_jobs.md
+usenet.md
+wiki_pages.md
+wiki_stats.md
+woman.md
 Date:   Sun Feb 18 01:42:30 2024 +0100
 dog.md
 jokes.md
@@ -31,24 +62,6 @@ oop.md
 pseudorandomness.md
 random_page.md
 wiki_pages.md
-wiki_stats.md
-Date:   Sat Feb 17 23:25:58 2024 +0100
-avpd.md
-backgammon.md
-boat.md
-cyber.md
-distrohopping.md
-encyclopedia.md
-jokes.md
-random_page.md
-randomness.md
-wiki_pages.md
-wiki_stats.md
-Date:   Sat Feb 17 11:00:20 2024 +0100
-random_page.md
-wiki_pages.md
-wiki_stats.md
-Date:   Sat Feb 17 10:47:29 2024 +0100
 ```
 
 most wanted pages:
@@ -56,10 +69,10 @@ most wanted pages:
 ```
 embedded.md
 meme.md
+data_type.md
 buddhism.md
 array.md
 gpl.md
-data_type.md
 quake.md
 lisp.md
 irl.md
@@ -72,7 +85,7 @@ pointer.md
 html.md
 gpu.md
 compiler.md
+cli.md
 trademark.md
-sdl.md
 ```