From 45bd7c47c0c62ec7b7406fd42867932ac31669ee Mon Sep 17 00:00:00 2001 From: Miloslav Ciz Date: Mon, 14 Aug 2023 17:22:57 +0200 Subject: [PATCH] Update --- acronym.md | 1 + capitalism.md | 2 + computer.md | 2 +- graphics.md | 2 +- interpolation.md | 2 + logic_circuit.md | 2 +- logic_gate.md | 6 +- nord_vpn.md | 3 + normalization.md | 6 +- turing_machine.md | 202 ++++++++++++++++++++++++++++++++++++++++++++++ wikipedia.md | 2 +- zuckerberg.md | 3 + 12 files changed, 224 insertions(+), 9 deletions(-) create mode 100644 nord_vpn.md create mode 100644 turing_machine.md create mode 100644 zuckerberg.md diff --git a/acronym.md b/acronym.md index cc39022..1099def 100644 --- a/acronym.md +++ b/acronym.md @@ -127,6 +127,7 @@ Here is a list of some acronyms: - **[GLUT](glut.md)** (OpenGL utility toolkit) - **[GNOME](gnome.md)** (GNU network object model environment) - **[GNU](gnu.md)** (GNU's Not Unix) +- **[GOAT](goat.md)** (greatest of all time) - **[GPG](gpg.md)** (GNU privacy guard) - **[GPGPU](gpgpu.md)** (general purpose GPU) - **[GPL](gpl.md)** (GNU General Public License) diff --git a/capitalism.md b/capitalism.md index dbd1d1d..3067daa 100644 --- a/capitalism.md +++ b/capitalism.md @@ -20,6 +20,8 @@ From a certain point of view capitalism is not really a traditional socioeconomi Under capitalism you are not a human being, you are a resource, at best a machine that's useful for some time but becomes obsolete and undesired once it outlives its usefulness and potential to be exploited. Under capitalism you are a slave that's forced to live the life of 3 Cs: **conform, consume, compete**. Or, as [Encyclopedia dramatica](dramatica.md) puts it: work, buy, consume, die. +**Who invented capitalism?** Well, it largely developed on its own, society is just responsible for not stopping it. Capitalism as seen today has mostly evolved from the tradition of small [trade](trade.md), [slavery](work.md), markets, [competition](competition.md), [evil](evil.md), [war](war.md) and abuse due to societal hierarchy (e.g. peasants by noblemen, poor by rich etc.), combined with technological progress of [industrial revolution](industrial_revolution.md) (18th. - 19th century) which allowed mass production and mass abuse of workers, as well as the information revolution (20th - 21th century) which allowed mass surveillance, unlimited [corporate](corporation.md) control, acceleration of bullshit business and extreme mass [brainwashing](marketing.md), reaching [capitalist singularity](capitalist_singularity.md). [Adam Smith](adam_smith.md) (18th century), a mentally retarded egoist who tried to normalize and promote self-interest and torture of others for self-benefit, is often called the **"father of capitalism"** (which is about of the same honor as being called the [father of holocaust](hitler.md)) -- this man is to be also largely credited for the future extermination of all [life](life.md). + { See also the amazing 1988 movie *They Live* for some cool criticism of capitalism. ~drummyfish } ## Attributes Of Capitalism diff --git a/computer.md b/computer.md index d6b7725..6fcafce 100644 --- a/computer.md +++ b/computer.md @@ -27,7 +27,7 @@ Such a computer consists of some kind of [case](case.md) (chassis), internal [ha - **[motherboard](motherboard.md)**: The main electronic circuit of the computer into which other components are plugged and which creates the network and interfaces that interconnect them (a [chipset](chipset.md)). It contains slots for expansion cards as well as connectors for external devices, e.g. [USB](usb.md). In a small memory on the board there is the most basic software ([firmaware](firmware.md)), such as [BIOS](bios.md), to e.g. enable installation of other software. The board also carries the [clock](clock.md) generator for synchronization of all hardware, heat sensors etc. - **[CPU](cpu.md)** (central processing unit): Core of the computer, the chip plugged into motherboard that performs general calculations and which runs [programs](program.md), i.e. [software](sw.md). -- **[RAM](ram.md)/working memory**: Lower capacity volatile (temporary, erased when powered off) working memory of the computer, plugged into motherboard. It is used as a "pen and paper" by the CPU when performing calculations. +- **[RAM](ram.md)/working memory/main memory**: Lower capacity volatile (temporary, erased when powered off) working memory of the computer, plugged into motherboard. It is used as a "pen and paper" by the CPU when performing calculations. - **[disk](disk.md)**: [Non-volatile](volatile.md) (persisting when powered off) large capacity memory for storing [files](file.md) and other [data](data.md), connected to the motherboard via some kind of [bus](bus.md). Different types of disks exist, most commonly [hard disks](hdd.md) and [SSDs](ssd.md). - **expansion cards ([GPU](gpu.md), sound card, network card, ...)**: Additional hardware cards plugged into motherboard for either enabling or accelerating specific functionality (e.g. GPU for graphics etc.). - **[PSU](psu.md)** (power supply unit): Converts the input electrical power from the plug to the electrical power needed by the computer. diff --git a/graphics.md b/graphics.md index b2ae774..d1d2574 100644 --- a/graphics.md +++ b/graphics.md @@ -1,6 +1,6 @@ # Computer Graphics -Computer graphics (CG or just graphics) is a field of [computer science](compsci.md) that deals with visual information. The field doesn't have strict boundaries and can blend and overlap with other possibly separate topics such as physics simulations, multimedia and machine learning. It usually deals with creating or analyzing 2D and 3D images and as such CG is used in [data](data.md) visualization, [game](game.md) development, [virtual reality](vr.md), [optical character recognition](ocr.md) and even astrophysics or medicine. +Computer graphics (CG or just graphics) is a field of [computer science](compsci.md) that focuses on visual information. The field doesn't have strict boundaries and can blend and overlap with other possibly separate topics such as physics simulations, [multimedia](multimedia.md) and [machine learning](machine_learning.md). It usually deals with creating or analyzing 2D and 3D images and as such CG is used in [data](data.md) visualization, [game](game.md) development, [virtual reality](vr.md), [optical character recognition](ocr.md) and even astrophysics or medicine. We can divide computer graphics in different ways, traditionally e.g.: diff --git a/interpolation.md b/interpolation.md index 29c4bff..65adc22 100644 --- a/interpolation.md +++ b/interpolation.md @@ -37,6 +37,8 @@ Many times we apply our interpolation not just to two points but to many points, The above mentioned methods can be generalized to more dimensions (the number of dimensions are equal to the number of interpolation parameters) -- we encounter this a lot e.g. in [computer graphics](graphics.md) when upscaling [textures](texture.md) (sometimes called texture filtering). 2D nearest neighbor interpolation creates "blocky" images in which [pixels](pixel.md) simply "get bigger" but stay sharp squares if we upscale the texture. Linear interpolation in 2D is called [bilinear interpolation](bilinear.md) and is visually much better than nearest neighbor, [bicubic interpolation](bicubic.md) is a generalization of cubic interpolation to 2D and is yet smoother that bilinear interpolation. +TODO: simple C code pls, maybe linear interpolation without floats + ## See Also - [extrapolation](extrapolation.md) diff --git a/logic_circuit.md b/logic_circuit.md index 25ffe85..b2f4199 100644 --- a/logic_circuit.md +++ b/logic_circuit.md @@ -1,6 +1,6 @@ # Logic Circuit -Logic circuits are circuits made of [logic gates](logic_gate.md) that implement [Boolean functions](bool.md), i.e. they are "graphical schematics for processing 1s and 0s". They are used to design [computers](computer.md) on quite a low level. Logic circuits are a bit similar to [electronic](electronics.md) circuits but are a level of [abstraction](abstraction.md) higher: they don't work with continuous [voltages](voltage.md) but rather with [discrete](discrete.md) [binary](binary.md) logic values: 1s and 0s. This abstraction makes logic circuits kind of a "[portable](portable.md)" circuit descriptions independent of any specific [transistor](transistor.md) technology, or even of [electronics](electronics.md) itself (as logical circuit may in theory be realized even mechanically, with [fluids](fluidics.md) or in other similarly wild ways). Logical circuits can be designed, simulated and synthesized to actual hardware description with specialized software and languages such as [VHDL](vhdl.md). +Logic circuits are circuits made of [logic gates](logic_gate.md) that implement [Boolean functions](bool.md), i.e. they are "graphical schematics for processing 1s and 0s". They are used to design [computers](computer.md) on quite a low level. Logic circuits are a bit similar to [electronic](electronics.md) circuits but are a level of [abstraction](abstraction.md) higher: they don't work with continuous [voltages](voltage.md) but rather with [discrete](discrete.md) [binary](binary.md) logic values: 1s and 0s. This abstraction makes logic circuits kind of "[portable](portable.md)" circuit descriptions independent of any specific [transistor](transistor.md) technology, or even of [electronics](electronics.md) itself (as logical circuit may in theory be realized even mechanically, with [fluids](fluidics.md) or in other similarly wild ways). Logical circuits can be designed, simulated and synthesized to actual hardware description with specialized software and languages such as [VHDL](vhdl.md). ``` 0 ___ 1 ___ 1 diff --git a/logic_gate.md b/logic_gate.md index 717c0ca..47ac59e 100644 --- a/logic_gate.md +++ b/logic_gate.md @@ -36,9 +36,9 @@ The truth table of these gates is as follows: ---/__..-' ---/__..-' ---|_____.' ---|_____.' OR NOR AND NAND ___ ___ . . - --\\ ''-. --\\ ''-. ---|'. |'. - )) )--- )) )O-- | >--- ---| >O-- - --//__..-' --//__..-' ---|.' |.' + --\\ ''-. --\\ ''-. |'. |'. + )) )--- )) )O-- ---| >--- ---| >O-- + --//__..-' --//__..-' |.' |.' XOR XNOR ' BUFFER ' NOT alternatively: diff --git a/nord_vpn.md b/nord_vpn.md new file mode 100644 index 0000000..f14e57b --- /dev/null +++ b/nord_vpn.md @@ -0,0 +1,3 @@ +# NordVPN + +NordVPN is a [proprietary](proprietary.md) predatory [scam](scam.md) service that steals personal data while trying to [market](marketing.md) itself as a "[VPN](vpn.md) for [security](security.md) and [privacy](privacy.md)"; it is useless at best and highly harmful to society at worst. It's a business similar to that of e.g. [antiviruses](antivirus.md), it builds on [fear culture](fear_culture.md), privacy hysteria and lack of technological education, abusing people who have little to no knowledge of technology, stealing not just their money, but also their data, computing power etc. NordVPN furthermore utilizes all the unethical [capitalist](capitalism.md) practice to make society as bad as possible, notably aggressive advertising, [brainwashing](brainwashing.md) and promotion of fear culture -- [YouTube](youtube.md) is infamous to have NordVPN propaganda inserted into every single video. \ No newline at end of file diff --git a/normalization.md b/normalization.md index cfd4be8..31f9546 100644 --- a/normalization.md +++ b/normalization.md @@ -1,7 +1,9 @@ # Normalization -Normalization is a term that can mean slightly different things but generally it either refers to adjusting a set of values to some desired range by multiplying or dividing each of the values by some predetermined number, or to converting some data or expression into a unified format. The idea is to "tame" possibly very wildly differing values that we can encounter "in the wild" into something more "normal" that we can better work with. The following are some specific meanings of the term depending on context: +In the context of [mathematics](math.md) normalization is a term that can mean slightly different things but generally it either refers to adjusting a set of values to some desired range by multiplying or dividing each of the values by some predetermined number, or to converting some data or expression into a unified format. The idea is to "tame" possibly very wildly differing values that we can encounter "in the wild" into something more "normal" that we can better work with. The term has also another meaning in the context of society and its [culture](culture.md). The following are some specific meanings of the term depending on context: - **[vector](vector.md) normalization**: Making given vector into a unit vector by dividing all its components by the length of the vector, i.e. we keep the direction of the vector the same but force its length to be exactly 1. - **signal normalization**: Adjusting the range of the signal to a desired range, for example with audio or images in which samples can range from -1 to 1 we may want to divide all the samples by the maximum of absolute values of all the samples which will stretch the signal so that the peak exactly fits the range: this will fully utilize the range (e.g. increase contrast in images) without cutting the signal off. -- **[URI](uri.md) normalization**: Converting URI into a unified format (e.g. `HTTP://www.MYSITE.COM:80/index.html` to `http://www.mysite.com`). \ No newline at end of file +- **[URI](uri.md) normalization**: Converting URI into a unified format (e.g. `HTTP://www.MYSITE.COM:80/index.html` to `http://www.mysite.com`). +- **[cultural](culture.md) normalization**: Making something be generally accepted as normal, for example: to achieve a [better society](less_retarded_society.md) we have to normalize [pedophilia](pedophilia.md). +- ... \ No newline at end of file diff --git a/turing_machine.md b/turing_machine.md new file mode 100644 index 0000000..b61d962 --- /dev/null +++ b/turing_machine.md @@ -0,0 +1,202 @@ +# Turing Machine + +Turing machine is a mathematical model of a [computer](computer.md) which works in a quite simple way but has nevertheless the full computational power that's possible to be achieved. Turing machine is one of the most important tools of theoretical [computer science](compsci.md) as it presents a basic [model of computation](model_of_computation.md) (i.e. a mathematical system capable of performing general mathematical calculations) for studying computers and [algorithms](algorithm.md) -- in fact it stood at the beginning of theoretical computer science when [Alan Turing](alan_turing.md) invented it in 1936 and used it to mathematically [prove](proof.md) essential things about computers; for example that their computational power is inevitably limited (see [computability](computability.md)) -- he showed that even though Turing machine has the full computational power we can hope for, there exist problems it is incapable of solving (and so will be any other computer equivalent to Turing machine, even human [brain](brain.md)). Since then many other so called **[Turing complete](turing_completeness.md)** systems (systems with the exact same computational power as a Turing machine) have been invented and discovered, such as [lambda calculus](lambda_calculus.md) or [Petri nets](petri_net.md), however Turing machine still remains not just relevant, but probably of greatest importance, not only historically, but also because it is similar to physical computers in the way it works. + +The advantage of a Turing machine is that it's firstly very simple (it's basically a finite state automaton operating on a memory tape), so it can be mathematically grasped very easily, and secondly it is, unlike many other systems of computations, actually similar to real computers in principle, mainly by its sequential instruction execution and possession of an explicit memory tape it operates on (equivalent to [RAM](ram.md) in traditional computers). However note that a **pure Turing machine cannot exist in reality** because there can never exist a computer with infinite amount of memory which Turing machine possesses; computers that can physically exist are really equivalent to [finite state automata](finite_state_automaton.md), i.e. the "weakest" kind of systems of computation. However we can see our physical computers as [approximations](approximation.md) of a Turing machine that in most relevant cases behave the same, so we do tend to theoretically view computers as "Turing machines with limited memory". + +**Is there anything computationally more powerful than a Turing machine?** Well, yes, but it's just kind of "mathematical fantasy". See e.g. [oracle machine](oracle_machine.md) which adds a special "oracle" device to a Turing machine to make it [magically](magic.md) solve undecidable problems. + +## How It Works + +Turing machine has a few different versions (such as one with multiple memory tapes, memory tape unlimited in both directions, one with non-[determinism](determinism.md), ones with differently defined halting conditions etc.), which are however equivalent in computing power, so here we will describe just one of the most common variants. + +A Turing machine is composed of: + +- **memory tape**: Memory composed of infinitely many cells (numbered 0, 1, 2, ...), each cell can hold exactly one symbol from some given alphabet (can be e.g. just symbols 0 and 1) OR the special *blank* symbol. At the beginning all memory cells contain the *blank* symbol. +- **read/write head**: Head that is positioned above a memory cell, can be moved to left or right. At the beginning the head is at memory cell 0. +- **control unit**: The program ([algorithm](algorithm.md)) that's "loaded" on the machine (the controls unit by itself is really a [finite state automaton](finite_state_automaton.md)). It is composed of: + - **a [set](set.md) of N (finitely many) states** {Q0, Q1, ... QN-1}: The machine is always in one of these states. One state is defined as starting (this is the state the machine is in at the beginning), one is the end state (the one which halts the machine when it is reached). + - **a set of finitely many rules** in the format *[stateFrom, inputSymbol, stateTo, outputSymbol, headShift]*, where *stateFrom* is the current state, *inputSymbol* is symbol currently under the read/write head, *stateTo* is the state the machine will transition to, *outputSymbol* is the symbol that will be written to the memory cell under read/write head and *headShift* is the direction to shift the read/write head in (either *left*, *right* or *none*). There must not be conflicting rules (ones with the same combination of *stateFrom* and *inputSymbol*). + +The machine halts either when it reaches the end state, when it tries to leave the tape (go left from memory cell 0) or when it encounters a situation for which it has no defined rule. + +The computation works like this: the input data we want to process (for example a [string](string.md) we want to reverse) are stored in the memory before we run the machine. Then we run the machine and wait until it finishes, then we take what's present in the memory as the machine's output (i.e. for example the reversed string). That is a Turing machine doesn't have a traditional [I/O](io.md) (such as a "[printf](printf.md)" function), it only works entirely on data in memory! + +Let's see a simple **example**: we will program a Turing machine that takes a [binary](binary.md) number on its output and adds 1 to it (for simplicity we suppose a fixed number of bits so an [overflow](overflow.md) may happen). Let us therefore suppose symbols 0 and 1 as the tape alphabet. The control unit will have the following rules: + +| stateFrom | inputSymbol | stateTo | outputSymbol | headShift | +| --------- | ----------- | ------- | ------------ | --------- | +| goRight | non-blank | goRight | inputSymbol | right | +| goRight | blank | add1 | blank | left | +| add1 | 0 | add0 | 1 | left | +| add1 | 1 | add1 | 0 | left | +| add0 | 0 | add0 | 0 | left | +| add0 | 1 | add0 | 1 | left | +| end | | | | | + +Our start state will be *goRight* and *end* will be the end state, though we won't need the end state as our machine will always halt by leaving the tape. The states are made so as to first make the machine step by cells to the right until it finds the blank symbol, then it will step one step left and switch to the adding mode. Adding works just as we are used to, with potentially carrying 1s over to the highest orders etc. + +Now let us try inputting the binary number 0101 (5 in decimal) to the machine: this means we will write the number to the tape and run the machine as so: + +``` +goRight + _V_ ___ ___ ___ ___ ___ ___ ___ + | 0 | 1 | 0 | 1 | | | | ... + '---'---'---'---'---'---'---'--- + goRight + ___ _V_ ___ ___ ___ ___ ___ ___ + | 0 | 1 | 0 | 1 | | | | ... + '---'---'---'---'---'---'---'--- + goRight + ___ ___ _V_ ___ ___ ___ ___ ___ + | 0 | 1 | 0 | 1 | | | | ... + '---'---'---'---'---'---'---'--- + goRight + ___ ___ ___ _V_ ___ ___ ___ ___ + | 0 | 1 | 0 | 1 | | | | ... + '---'---'---'---'---'---'---'--- + goRight + ___ ___ ___ ___ _V_ ___ ___ ___ + | 0 | 1 | 0 | 1 | | | | ... + '---'---'---'---'---'---'---'--- + add1 + ___ ___ ___ _V_ ___ ___ ___ ___ + | 0 | 1 | 0 | 1 | | | | ... + '---'---'---'---'---'---'---'--- + add1 + ___ ___ _V_ ___ ___ ___ ___ ___ + | 0 | 1 | 0 | 0 | | | | ... + '---'---'---'---'---'---'---'--- + add0 + ___ _V_ ___ ___ ___ ___ ___ ___ + | 0 | 1 | 1 | 0 | | | | ... + '---'---'---'---'---'---'---'--- + add0 + _V_ ___ ___ ___ ___ ___ ___ ___ + | 0 | 1 | 1 | 0 | | | | ... + '---'---'---'---'---'---'---'--- + + END +``` + +Indeed, we see the number we got at the output is 0110 (6 in decimal, i.e. 5 + 1). Even though this way of programming is very tedious, it actually allows us to program everything that is possible to be programmed, even whole operating systems, neural networks, games such as [Doom](doom.md) and so on. Here is [C](c.md) code that simulates the above shown Turing machine with the same input: + +``` +#include + +#define CELLS 2048 // ideal Turing machine would have an infinite tape... +#define BLANK 0xff // blank tape symbol +#define STATE_END 0xff +#define SHIFT_NONE 0 +#define SHIFT_LEFT 1 +#define SHIFT_RIGHT 2 + +unsigned int state; // 0 = start state, 0xffff = end state +unsigned int headPosition; +unsigned char tape[CELLS]; // memory tape + +unsigned char input[] = // what to put on the tap at start + { 0, 1, 0, 1 }; + +unsigned char rules[] = +{ +// state symbol newstate newsymbol shift + 0, 0, 0, 0, SHIFT_RIGHT, // moving right + 0, 1, 0, 1, SHIFT_RIGHT, // moving right + 0, BLANK, 1, BLANK, SHIFT_LEFT, // moved right + 1, 0, 2, 1, SHIFT_LEFT, // add 1 + 1, 1, 1, 0, SHIFT_LEFT, // add 1 + 2, 0, 2, 0, SHIFT_LEFT, // add 0 + 2, 1, 2, 1, SHIFT_LEFT // add 0 +}; + +void init(void) +{ + state = 0; + headPosition = 0; + + for (unsigned int i = 0; i < CELLS; ++i) + tape[i] = i < sizeof(input) ? input[i] : BLANK; +} + +void print(void) +{ + printf("state %d, tape: ",state); + + for (unsigned int i = 0; i < 32; ++i) + printf("%c%c",tape[i] != BLANK ? '0' + tape[i] : '.',i == headPosition ? + '<' : ' '); + + putchar('\n'); +} + +// Returns 1 if running, 0 if halted. +unsigned char step(void) +{ + const unsigned char *rule = rules; + + for (unsigned int i = 0; i < sizeof(rules) / 5; ++i) + { + if (rule[0] == state && rule[1] == tape[headPosition]) // rule matches? + { + state = rule[2]; + tape[headPosition] = rule[3]; + + if (rule[4] == SHIFT_LEFT) + { + if (headPosition == 0) + return 0; // trying to shift below cell 0 + else + headPosition--; + } + else if (rule[4] == SHIFT_RIGHT) + headPosition++; + + return state != STATE_END; + } + + rule += 5; + } + + return 0; +} + +int main(void) +{ + init(); + + print(); + + while (step()) + print(); + + puts("halted"); + + return 0; +} +``` + +And here is the program's output: + +``` +state 0, tape: 0<1 0 1 . . . . . . . . . . . . . . . . . +state 0, tape: 0 1<0 1 . . . . . . . . . . . . . . . . . +state 0, tape: 0 1 0<1 . . . . . . . . . . . . . . . . . +state 0, tape: 0 1 0 1<. . . . . . . . . . . . . . . . . +state 0, tape: 0 1 0 1 .<. . . . . . . . . . . . . . . . +state 1, tape: 0 1 0 1<. . . . . . . . . . . . . . . . . +state 1, tape: 0 1 0<0 . . . . . . . . . . . . . . . . . +state 2, tape: 0 1<1 0 . . . . . . . . . . . . . . . . . +state 2, tape: 0<1 1 0 . . . . . . . . . . . . . . . . . +halted +``` + +**Universal Turing machine** is an extremely important type of Turing machine: one that is able to simulate another Turing machine -- we can see it as a Turing machine [interpreter](interpreter.md) of a Turing machine. The Turing machine that's to be simulated is encoded into a string (which can then be seen as a [programming language](programming_language.md) -- the format of the string can vary, but it somehow has to encode the rules of the control unit) and this string, along with an input to the simulated machine, is passed to the universal machine which executes it. This is important because now we can see Turing machines themselves as programs and we may use Turing machines to analyze other Turing machines, to become [self hosted](self_hosting.md) etc. It opens up a huge world of possibilities. + +**Non-deterministic Turing machine** is a modification of Turing machine which removes the limitation of [determinism](determinism.md), i.e. which allows for having multiple different "conflicting" rules defined for the same combination of state and input. During execution such machine can conveniently choose which of these rules to follow, or, imagined differently, we may see the machine as executing all possible computations in parallel and then retroactively leaving in place only the most convenient path (e.g. that which was fastest or the one which finished without getting stuck in an infinite loop). Surprisingly a **non-deterministic Turing machine is computationally equivalent to a deterministic Turing machine**, though of course a non-deterministic machine may be faster (see especially [P vs NP](p_vs_np.md)). + +Turing machines can be used to define computable [formal languages](formal_language.md). Let's say we want to define language *L* (which may be anything such as a programming language) -- we may do it by programming a Turing machine that takes on its input a string (a word) and outputs "yes" if that string belongs to the language, or "no" if it doesn't. This is again useful for the theory of [decidability](decidability.md)/[computability](computability.md). + +## See Also + +- [brainfuck](brainfuck.md) \ No newline at end of file diff --git a/wikipedia.md b/wikipedia.md index 6bae20e..f39f000 100644 --- a/wikipedia.md +++ b/wikipedia.md @@ -76,7 +76,7 @@ Due to mass censorship and brainwashing going on at Wikipedia it is important to |[Encyclopedia Dramatica](dramatica.md) | CC0 | informal/fun/"offensive" but valuable info (on society, tech, ...), basically no censorship, no propaganda | |[Tor Hidden Wiki](http://zqktlwiuavvvqqt4ybvgvi7tyo4hjl5xgfuvpdf6otjiycgwqbym2qad.onion) | PROPRIETARY | Deepweb wiki on [Tor](tor.md), probably less censored. | -TODO: darknet wikis +TODO: darknet wikis, old digital encyclopedias like Encarta ## See Also diff --git a/zuckerberg.md b/zuckerberg.md new file mode 100644 index 0000000..667e4ba --- /dev/null +++ b/zuckerberg.md @@ -0,0 +1,3 @@ +# Mark Zuckerberg + +Zuckerberg is one of the ugliest aliens ever recorded on video. \ No newline at end of file