drummyfish/less_retarded_wiki
5
2
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Update

Browse source
This commit is contained in:
Miloslav Ciz 2024-08-06 22:19:44 +02:00
parent 793eff5870
commit 8dbbd1acb0
14 changed files with 1972 additions and 1867 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
100r.md
View file

@ -1,3 +1,3 @@
# Hundred Rabbits
These motherfuckers are [toxic](toxic.md) [SJWs](sjw.md), avoid them like the devil. For now see [xxiivv](xxiivv.md).
More like hundred retards :D These bitches are [toxic](toxic.md) as fuck [SJWs](sjw.md), avoid them at any cost. For more detail see [xxiivv](xxiivv.md).

1
books.md
View file

@ -22,6 +22,7 @@ Here there will be a constantly WIP list of [books](book.md) that might be of in
- **Masters of Doom** (Kushner, 2003): Another nice book for [Doom](doom.md) fans, this time not really technical but rather just retelling the story of the game's development -- quite comfy, a lot if interesting trivia.
- **[The Jargon File](jargon_file.md)** (1975...): [Hacker culture](hacking.md) dictionary, a lot of wisdom, inside jokes, and things related to oldschool hacking.
- **Rebel Code** (Moody, 2001): A bit of a mainstream view at the whole "[open source](open_source.md)" history -- though it's a small brain business view which we have to keep in mind at all times, it's a nice introduction to the whole FOSS world for the newcomers, as the book covers most of the relevant projects and [people](people.md).
- **Starting Forth** (Leo Brodie, 1981): Good book to learn [Forth](forth.md).
- **The Chrysalids** (John Wyndham, 1955): Apocalyptic sci-fi about a middle-age-like deeply religious dystopia after a nuclear war, it's among the author's best works.
- **The Country of the Blind** by H. G. Wells (1911): Very nice story, also in the public domain and digitized online, easily accessible. Though not related to technology, it's a great food for thought as it entertains an idea of a population of people who are completely blind which has interesting implications for their lives, and furthermore it shows that if you place someone too competent in a group of retards, they won't recognize his competence, in fact they'll see him as someone yet more retarded than they are themselves.
- **The Nostalgia Nerd's Retro Tech**: Nice small database of all the old consoles/computers (SNES, Amiga, C64, ...), each one with high quality photos, short summary, specs and notable games. There is not much text, it's more like tl;drs of the most important stuff, it's an ideal overview of the old computers for a newcomers but can also serve as a quick reference to anyone.

2
c.md
View file

@ -89,7 +89,7 @@ enter a number: 7
(7)
enter a number: 0
(0)
enter a number: 4
enter a number: 15
((5) 15 (3))
enter a number: quit
```

4
consumerism.md
View file

@ -1,6 +1,8 @@
# Consumerism
Consumerism is [cancer](cancer.md) of society created by [capitalism](capitalism.md), it is the societal tendency towards and force established [culture](culture.md) of making members of society into mere slaves that have to constantly keep consuming products and services just for the sake of keeping bullshit businesses running. Consumers have to stand with open mouths at the end of [producer](productivity_cult.md) asses that are constantly shitting out new and new excrement, and this process must never stop. This soon degenerates into such things as [artificial scarcity](artificial_scarcity.md) and [planned obsolescence](planned_obsolescence.md), things that could last long must be made so that they will NOT last long, they must break soon so that the user has to consume a new one periodically, just like he consumes food, because that's what makes the [corporation](corporation.md) most money. So people are consuming computers, cars, swimming pools, cell phones, doctors, political drama, healthcare, things that make them sick, thing that make them healthy again, and so on and so forth. Even things that could be made to last long, such as buildings, or even forever, such as discovered [information](information.md) -- e.g. old books -- are artificially killed (for example using [copyright](copyright.md)), so that new ones have to be made so that people can keep having [jobs](work.md) and be miserable and don't have to lie on the beach and be happy. Businesses that would want to create non-consumerist products cannot exist -- a business that sells a thing that lasts 100 years will have to wait 100 years to sell another one, so naturally there is no chance for it to survive among those that make it so that they're selling the same thing each half a year, that's why consumerism in capitalism is unavoidable: it simply pays off, it makes the company rich and the richer company survives. Of course this is all pure [bullshit](bullshit.md) that wastes lives of people, makes them miserable consuming machines that get depressed and commit suicides, while also creating enormous amounts of waste that are destroying the environment, just capitalism as usual. Under consumerism your life is expected to go like this: be born, consume, die.
Consumerism is [cancer](cancer.md) of society created by [capitalism](capitalism.md), it is the societal tendency towards and force established [culture](culture.md) of making members of society into mere slaves that have to constantly keep consuming products and services just for the sake of keeping bullshit businesses running. Consumers have to stand with open mouths at the end of [producer](productivity_cult.md) asses that are constantly shitting out new and new excrement, and this process must never stop. This soon degenerates into such things as **[artificial scarcity](artificial_scarcity.md)** and **[planned obsolescence](planned_obsolescence.md)**, things that could last long must be made so that they will NOT last long, they must break soon so that the user has to consume a new one periodically, just like he consumes food, because that's what makes the [corporation](corporation.md) most money. So people are consuming computers, cars, swimming pools, cell phones, doctors, political drama, healthcare, things that make them sick, thing that make them healthy again, and so on and so forth. Even things that could be made to last long, such as buildings, or even forever, such as discovered [information](information.md) -- e.g. old books -- are artificially killed (for example using [copyright](copyright.md)), so that new ones have to be made so that people can keep having [jobs](work.md) and be miserable and don't have to lie on the beach and be happy. Businesses that would want to create non-consumerist products cannot exist -- a business that sells a thing that lasts 100 years will have to wait 100 years to sell another one, so naturally there is no chance for it to survive among those that make it so that they're selling the same thing each half a year, that's why consumerism in capitalism is unavoidable: it simply pays off, it makes the company rich and the richer company survives. Of course this is all pure [bullshit](bullshit.md) that wastes lives of people, makes them miserable consuming machines that get depressed and commit suicides, while also creating enormous amounts of waste that are destroying the environment, just capitalism as usual. Under consumerism your life is expected to go like this: be born, consume, die.
Consumerism is additionally pushed by capitalists by many other means, for instance by psychological pressure such as extreme [marketing](marketing.md) that constantly creates artificial trends, hypes and fashion waves, or by economic means such as [inflation](inflation.md) created by printing money -- this is a simple trick for a state (nowadays controlled by [corporations](corporation.md)) to take away money from people so that people can do nothing about it, and this is how capitalism makes it impossible to save money: once you try to save money, it simply loses its value and you end up with nothing, so you're forced to immediately spend any money that you make. You must not stop, just consume, work, consume and work -- people that don't want to engage in this cycle are unwanted by the system and left to starve.
If you don't want to consume, you made a very big mistake by being born in [21st century](21st_century.md).

2
fixed_point.md
View file

@ -1,6 +1,6 @@
# Fixed Point
Fixed point arithmetic is a simple and often [good enough](good_enough.md) method of computer representation of [fractional](rational_number.md) numbers (i.e. numbers with higher precision than [integers](integer.md), e.g. 4.03), as opposed to [floating point](float.md) which is a more complicated way of doing this which in most cases we consider a worse, [bloated](bloat.md) alternative. Probably in 99% cases when you think you need floating point, fixed point will do just fine. Fixed point arithmetic is not to be [confused](often_confused.md) with fixed point of a function in mathematics (fixed point of a function *f(x)* is such *x* that *f(x) = x*), a completely unrelated term.
Fixed point arithmetic is a simple and often [good enough](good_enough.md) method of computer representation of [fractional](rational_number.md) numbers (i.e. numbers with higher precision than [integers](integer.md), e.g. 4.03), as opposed to [floating point](float.md) which is a more complicated way of doing this which in most cases we consider a worse, [bloated](bloat.md) alternative. Probably in 99% cases when you think you need floating point, fixed point will do just fine (this is also advocated e.g. in the book *Starting Forth*). Fixed point arithmetic is not to be [confused](often_confused.md) with fixed point of a function in mathematics (fixed point of a function *f(x)* is such *x* that *f(x) = x*), a completely unrelated term.
Fixed point has at least these advantages over floating point:

174
forth.md
View file

@ -10,21 +10,25 @@ Forth ("fourth generation" shortened to four characters due to technical limitat
It is usually presented as [interpreted](interpreter.md) language but may as well be [compiled](compiler.md), in fact it maps pretty nicely to [assembly](assembly.md). Even if interpreted, it can still be very fast. Forth systems traditionally include not just a compiler/interpreter but also an **interactive environment**, kind of [REPL](repl.md) language shell.
There are several Forth standards, most notably ANSI Forth from 1994 (the document is [proprietary](proprietary.md), sharing is allowed, 640 kB as txt). Besides others it also allows Forth to include optional [floating point](float.md) support.
There are several Forth standards, most notably ANS Forth from 1994 (the document is [proprietary](proprietary.md), sharing is allowed, 640 kB as txt). Besides others it also allows Forth to include optional [floating point](float.md) support, however Forth programmers highly prefer [fixed point](fixed_point.md) (as stated in the book *Starting Forth*). Then there is a newer Forth 2012 standard, but it's probably better to stick to the older one.
A [free](free_software.md) implementation is e.g. GNU Forth ([gforth](gforth.md)) or [pforth](pforth.md) (a possibly better option by LRS standards, favors [portability](portability.md) over performance).
Forth was invented by Charles Moore in 1968, for programming radio telescopes.
There is a book called **Starting Forth** that's freely downloadable and quite good at teaching the language.
Forth was invented by [Charles Moore](charles_moore.md) (NOT the one of the [Moore's Law](moores_law.md) though) in 1968, for programming radio telescopes.
## Language
Forth is case-insensitive (this may however not be the case in some implementations).
The language operates on an evaluation **[stack](stack.md)**: e.g. the operation + takes the two values at the top of the stack, adds them together and pushed the result back on the stack. Besides this there are also some "advanced" features like variables living outside the stack, if you want to use them.
The language operates on an evaluation **[stack](stack.md)**: e.g. the operation + takes the two values at the top of the stack, adds them together and pushed the result back on the stack (i.e. for example `1 2 +` in Forth is the same as `1 + 2` in C). Besides this there are also some "advanced" features like variables living outside the stack, if you want to use them.
The stack is composed of **cells**: the size and internal representation of the cell is implementation defined. There are no data types, or rather everything is just of type signed int.
In fact there are two stacks in Forth: the **parameter stack** (also data stack) and **return stack**. Parameter stack is the "normal" stack on which we do most computations and on which we pass parameters and return values. Returns stack is the stack on which return addresses are stored, BUT it is also used as a temporary stack so that we can let's say put aside a few values to dive deeper on the main stack, however this has to be done carefully -- before end of word ("function") is reached, the return stack must be restored to the original state of course.
Basic [abstraction](abstraction.md) of Forth is so called **word**: a word is simply a string without spaces like `abc` or `1mm#3`. A word represents some operation on stack (and possible other effect such as printing to the console), for example the word `1` adds the number 1 on top of the stack, the word `+` performs the addition on top of the stack etc. The programmer can define his own words which can be seen as "[functions](function.md)" or rather procedures or macros (words don't return anything or take any arguments, they all just invoke some operations on the stack). A word is defined like this:
The stack is composed of **cells**: the size of the cell is implementation defined. The values stored in cells are just binary, they don't have any data type, so whether a value in given cell is considered signed or unsigned is up to the programmer -- some operators treat numbers as signed and some as unsigned (just like in [comun](comun.md)); note that with many operators the distinction doesn't matter (e.g. addition doesn't care if the numbers are signed or not, but comparison does).
Basic [abstraction](abstraction.md) of Forth is so called **word**: a word is simply a string without spaces like `abc` or `1mm#3`. A word represents simply some operations, which may include running native code, pushing numbers on stack or calling other words, for example the word the word `+` performs the addition on top of the stack, `dup` duplicates the top of the stack etc. The programmer can define his own words -- so words are basically kind of "[functions](function.md)" or rather procedures (however words don't return anything or take any arguments in traditional way, they all just invoke some operations -- arguments and return values are passed using the stack). Defining new words expands the current **dictionary**, so Forth basically extends itself as it's running. A word is defined like this:
```
: myword operation1 operation2 ... ;
@ -36,33 +40,47 @@ For example a word that computes and average of the two values on top of the sta
: average + 2 / ;
```
Built-in words include:
Forth programmers use so called **stack notation** to document the function's "signature", i.e. what it does with the stack -- they write this notation in a comment above a defined word to signify to others what the word will do. Stack notation has the format `( before -- after )`, for example the effect of the above defined `average` words would be written as `( a b -- avg )` in this notation.
Some built-in words include:
```
GENERAL:
+ add a b -> (a + b)
- subtract a b -> (a . b)
* multiply a b -> (a * b)
/ divide a b -> (a / b)
= equals a b -> (-1 if a = b else 0)
< less than a b -> (-1 if a < b else 0)
> greater than a b -> (-1 if a > b else 0)
mod modulo a b -> (a % b)
dup duplicate a -> a a
drop pop stack top a ->
swap swap items a b -> b a
rot rotate 3 a b c -> b c a
pick push Nth item xN ... x0 N -> ... x0 xN
. print top & pop
+ add ( a b -- [a+b] )
- subtract ( a b -- [a-b] )
* multiply ( a b -- [a*b] )
/ divide ( a b -- [a/b] )
= equals ( a b -- [-1 if a = b else 0] )
<> not equals ( a b -- [-1 if a != b else 0] )
< less than ( a b -- [-1 if a < b else 0] )
> greater than ( a b -- [-1 if a > b else 0] )
mod modulo ( a b -- [a % b] )
dup duplicate ( a -- a a )
drop pop stack top ( a -- )
swap swap items ( a b -- b a )
rot rotate 3 ( a b c -- b c a )
pick push Nth item ( xN ... x0 N -- ... x0 xN )
. pop & print number as signed
u. pop & print number as unsigned
key read char on top
.s print stack
emit print char & pop
emit pop & print top as char
cr print newline
cells times cell width a -> (a * cell width in bytes)
depth pop all & get d. a ... -> (previous stack size)
cells times cell width ( a -- [a * cell width in bytes] )
depth pop all & get d. ( a ... -- [previous stack size] )
quit don't print "ok" at the end of execution
bye quit
RETURN STACK:
>r pops value, pushed it to return stack
r> pops value from return stack, pushes it
r@ pushes value from return stack (doesn't pop it)
i pushes value from return stack (without pop)
i' pushes second value from return stack (without pop)
j pushes third value from return stack (without pop)
VARIABLES/CONSTS:
variable X creates var named X (X is a word that pushed its addr)
@ -74,18 +92,21 @@ C pushes the value of constant C
SPECIAL:
( ) comment (inline)
\ comment (until newline)
." S " print string S
X if C then if X, execute C // only in word def.
X if C1 else C2 then if X, execute C1 else C2 // only in word def.
do C loop loops from stack top value to stack second from,
top, special word "i" will hold the iteration val.
begin C until like do/loop but keeps looping as long as top = 0
begin C while like begin/until but loops as long as top != 0
allot allocates memory, can be used for arrays
recurse recursively call the word currently being defined
( ) comment (inline)
\ comment (until newline)
." S" print string S (compiles in the string)
X if C then if X, execute C (only in word def., X is popped)
X if C1 else C2 then if X, execute C1 else C2 (only in word def.)
do C loop loops from stack top value to stack second from,
top, special word "i" will hold the iteration val.
begin C until like do/loop but keeps looping as long as top = 0
begin C while like begin/until but loops as long as top != 0
begin C again infinite loop
begin C1 while C2 repeat loop with middle condition
leave loop break (only for counted loops)
allot allocates memory, can be used for arrays
recurse recursively call the word currently being defined
see W shows the definition of word W
```
example programs:
@ -102,6 +123,89 @@ cr ." hey bitch " cr \ prints: hey bitch
: myloop 5 0 do i . loop ; myloop \ prints 0 1 2 3 4
```
TODO: local variables, addresses
## Examples
Here is our standardized **[divisor tree](divisor_tree.md)** program written in Forth:
```
\ takes x, pops it and recursively prints its divisor tree
: printdivisortree
dup 3 <= if
0 swap 1 swap \ stack now: 0 1 x
else
>r 0 1 r> \ stack now: a b x
dup 2 / 1 + 2 do \ find the closest divisors (a, b)
dup i mod 0 = if \ i divides x?
2 pick 2 pick < if \ a < b?
i
swap
>r \ use return stack for tmp storage
swap drop
swap drop
dup r@ swap /
r>
then
then
loop
then
." ( "
2 pick 0 <> if \ divisors found?
2 pick recurse
dup .
1 pick recurse
else
dup .
then
." ) "
drop drop drop
;
: digittonum
dup dup 48 >= swap 57 <= and if
48 -
else
drop -1
then
;
: main
begin \ main loop, read numbers from user
0
begin
key
dup 13 <> while \ newline?
digittonum
dup -1 = if
bye
then
swap 10 * +
repeat
drop \ key
dup 1000 < if
printDivisorTree cr
else
bye
then
again
;
main
bye
```
## How To
Source code files usually have `.fs` extension. We can use mentioned gforth to run our files. Let's create file `my.fs`; in it we write: { Hope the code is OK, I never actually programmed in Forth before. ~drummyfish }

4
gui.md
View file

@ -2,9 +2,9 @@
"*Always add a commandline interface to your software. Graphical User interfaces are for sissies.*" --[bitreich](bitreich.md) manifesto
Graphical user interface (GUI) is a visual [user interface](ui.md) that uses graphics such as images and geometrical shapes. This stands in contrast with [text user interface](tui.md) (TUI) which is also visual but only uses text for communication.
Graphical user interface (GUI) is a visual [user interface](ui.md) that uses graphical elements such as images, many distinct [colors](color.md) and fine geometrical shapes. This stands in contrast with [text user interface](tui.md) (TUI) which is also visual but only uses text for communication (TUI can further be pure line-based [command line interface](cli.md) or a graphical, grid-based text interface that mimics a true GUI, e.g. with [ASCII art](ascii_art.md)).
Expert computer users normally frown upon GUI because it is the "noobish", inefficient, limiting, cumbersome, hard to automate way of interacting with computer. GUI brings [complexity](complexity.md) and [bloat](bloat.md), they are slow, inefficient and distracting. We try not to use them and prefer the [command line](cli.md).
Expert computer users normally frown upon GUI because it is the "noobish", inefficient, limiting, cumbersome, hard to automate, [capitalist](capitalism.md) consumer-style way of interacting with computer. GUI brings [complexity](complexity.md) and [bloat](bloat.md), they are slow, inefficient, distracting, hard to automatize and test. GUI is like baby pictures or simple books with pictures for [illiterate people](plan9.md) and Chimpanzees, for people who need to click on boxes and have flashing strip club colors to keep them entertained, while command line is for normal adults who can read and want to do thing efficiently -- there is a reason why [programming languages](programming_language.md) are plain text (with exception of the ones literally aimed at babies in kindergarden). [Text is universal interface](unix_philosophy.md). So we try not to use GUIs and prefer the [command line](cli.md).
"[Modern](modern.md)" GUIs mostly use [callback](callback.md)-based programming, which again is more complicated than standard polling non-interactive I/O. If you need to do GUI, just use a normal infinite loop FFS.

9
javascript.md
View file

@ -27,7 +27,6 @@ Below is our standardized [divisor tree](divisor_tree.md) program written in bro
function divisorTreeStr(x)
{
let a = -1, b = -1;
let s = "";
for (let i = 2; i <= x / 2; i++) // find closest divisors
if (x % i == 0)
@ -39,12 +38,8 @@ function divisorTreeStr(x)
break;
}
s += "("
s += a > 1 ?
divisorTreeStr(a) + " " + x + " " + divisorTreeStr(b) : x;
return s + ")";
return "(" + (a > 1 ? divisorTreeStr(a) + " " + x + " " +
divisorTreeStr(b) : x) + ")";
}
function main()

1
kiss.md
View file

@ -22,6 +22,7 @@ Apparently the term *KISS* originated in the US Army plane engineering: the plan
- Using a trivial [shell](shell.md) script for compiling your programs rather than a complex build system such as [CMake](cmake.md).
- Using [ASCII art](ascii_art.md) instead of bitmap images.
- [Beatboxing](beatbox.md) to produce a back track for rap songs, as opposed to using (or even paying for) some kind of music software.
- Using hammock instead of bed -- it is much simpler, cheaper, portable and has an extra swinging feature for which it is considered by many to even be superior in terms of comfort.
- In the world of [coffee](coffee.md) so called *Turkish coffee* without any milk and sugar is probably the most KISS option, you just put coffee ground in a mug and pour hot water on it. Compare this to Espresso with milk and sugar which needs a quite complex and expensive machine. { Yeah, I drink the most KISS coffee, though sometimes I also use French press -- that one is still quite simple. ~drummyfish }
- ...

78
programming_language.md
View file

@ -112,47 +112,47 @@ Judging languages may further be complicated by the question of what the languag
Here is a table of notable programming languages in chronological order (keep in mind a language usually has several versions/standards/implementations, this is just an overview).
| language | minimalist/good? | since | speed | mem. | ~min. selfhos. impl. LOC |spec. (~no stdlib pages)| notes |
| ----------------------- | ---------------- | ----- | ------- | -------- | ------------------------ | ---------------------- | ----------------------------------------------------------------------- |
|"[assembly](assembly.md)"| **yes but...** | 1947? | | | | | NOT a single language, non-[portable](portability.md) |
| [Fortran](fortran.md) | **kind of** | 1957 | 1.95 (G)| 7.15 (G) | | 300, proprietary (ISO) | similar to Pascal, compiled, fast, was used by scientists a lot |
| [Lisp](list.md) | **yes** | 1958 | 3.29 (G)| 18 (G) | 100 (judg. by jmc lisp) | 1 | elegant, KISS, functional, many variants (Common Lisp, Closure, ...) |
| [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 | 5.26 (G)| 2.11 (G) | | 80, proprietary (ISO) | like "educational C", compiled, not so bad actually |
| **[C](c.md)** | **kind of** | 1972 | 1.0 | 1.0 | 10K? (judg. by chibicc) | 160, proprietary (ISO) | 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)| **quite yes** | 1972 | 47 (G) | 41 (G) | | 40, proprietary (ANSI) | PURE (bearable kind of) [OOP](oop.md) language, pretty minimal |
| [C++](cpp.md) | no, bearable | 1982 | 1.18 (G)| 1.27 (G) | | 500, proprietary | bastard child of C, only adds [bloat](bloat.md) ([OOP](oop.md)), "games"|
| [Ada](ada.md) | ??? | 1983 | | | | | { No idea about this, sorry. ~drummyfish } |
| Object Pascal | no | 1986 | | | | | Pascal with OOP (like what C++ is to C), i.e. only adds bloat |
| Objective-C | probably not | 1986 | | | | | kind of C with Smalltalk-style "pure" objects? |
| [Oberon](oberon.md) | kind of? | 1987 | | | | | simplicity as goal, part of project Oberon |
| [Perl](perl.md) | rather not | 1987 | 77 (G) | 8.64 (G) | | | interpreted, focused on strings, has kinda cult following |
| [Bash](bash.md) | well | 1989 | | | | | Unix scripting shell, very ugly syntax, not so elegant but bearable |
| [Haskell](haskell.md) | **kind of** | 1990 | 5.02 (G)| 8.71 (G) | | 150, proprietary | [functional](functional.md), compiled, acceptable |
| [Python](python.md) | NO | 1991 | 45 (G) | 7.74 (G) | | 200? (p. lang. ref.) | interpreted, huge bloat, slow, lightweight OOP, artificial obsolescence |
| POSIX [shell](shell.md) | well, "kind of" | 1992 | | | | 50, proprietary (paid) | standardized (std 1003.2-1992) Unix shell, commonly e.g. [Bash](bash.md)|
|[Brainfuck](brainfuck.md)| **yes** | 1993 | | | 100 (judg. by dbfi) | 1 | extremely minimal (8 commands), hard to use, [esolang](esolang.md) |
| [FALSE](false.md) | **yes** | 1993 | | | | 1 | very small yet powerful, Forth-like, similar to Brainfuck |
| [Lua](lua.md) | **quite yes** | 1993 | 91 (G) | 5.17 (G) | 7K (LuaInLua) | 40, free | small, interpreted, mainly for scripting (used a lot in games) |
| [Java](java.md) | NO | 1995 | 2.75 (G)| 21.48 (G)| | 800, proprietary | forced [OOP](oop.md), "platform independent" (bytecode), slow, bloat |
| [JavaScript](js.md) | NO | 1995 | 8.30 (G)| 105 (G) | 50K (est. from QuickJS) | 500, proprietary? | interpreted, the [web](web.md) lang., bloated, classless [OOP](oop.md) |
| [PHP](php.md) | no | 1995 | 23 (G) | 6.73 (G) | | 120 (by Google), CC0 | server-side web lang., OOP |
| [Ruby](ruby.md) | no | 1995 | 122 (G) | 8.57 (G) | | | similar to Python |
| [C#](c_sharp.md) | NO | 2000 | 4.04 (G)| 26 (G) | | | proprietary (yes it is), extremely bad lang. owned by Micro$oft, AVOID |
| [D](d.md) | no | 2001 | | | | | some expansion/rework of C++? OOP, generics etcetc. |
| [Rust](rust.md) | NO! lol | 2006 | 1.64 (G)| 3.33 (G) | | 0 :D | extremely bad, slow, freedom issues, toxic community, no standard, AVOID|
| [Go](go.md) | **kind of** | 2009 | 4.71 (G)| 5.20 (G) | | 130, proprietary? | "successor to C" but not well executed, bearable but rather avoid |
| [LIL](lil.md) | **yes** | 2010? | | | | | not known too much but nice, "everything's a string" |
| [uxntal](uxn.md) | **yes** but SJW | 2021 | | | 400 (official) | 2? (est.), proprietary | assembly lang. for a minimalist virtual machine, PROPRIETARY SPEC. |
| **[comun](comun.md)** | **yes** | 2022 | | | < 3K? | 2, CC0 | "official" [LRS](lrs.md) language, WIP, similar to Forth |
| language | minimalist/good? | since | speed | mem. | ~min. selfhos. impl. LOC |DT LOC|spec. (~no stdlib pages)| notes |
| ----------------------- | ---------------- | ----- | ------- | -------- | ------------------------ | ---- | ---------------------- | ----------------------------------------------------------------------- |
|"[assembly](assembly.md)"| **yes but...** | 1947? | | | | | | NOT a single language, non-[portable](portability.md) |
| [Fortran](fortran.md) | **kind of** | 1957 | 1.95 (G)| 7.15 (G) | | | 300, proprietary (ISO) | similar to Pascal, compiled, fast, was used by scientists a lot |
| [Lisp](list.md) | **yes** | 1958 | 3.29 (G)| 18 (G) | 100 (judg. by jmc lisp) | | 1? | elegant, KISS, functional, many variants (Common Lisp, Closure, ...) |
| [Basic](basic.md) | kind of? | 1964 | | | | | | mean both for beginners and professionals, probably efficient |
| [Forth](forth.md) | **yes** | 1970 | | | 100 (judg. by milliforth)| 74 | 200 (ANS Forth) | [stack](stack.md)-based, elegant, very KISS, interpreted and compiled |
| [Pascal](pascal.md) | **kind of** | 1970 | 5.26 (G)| 2.11 (G) | | | 80, proprietary (ISO) | like "educational C", compiled, not so bad actually |
| **[C](c.md)** | **kind of** | 1972 | 1.0 | 1.0 | 10K? (judg. by chibicc) | 49 | 160, proprietary (ISO) | 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)| **quite yes** | 1972 | 47 (G) | 41 (G) | | | 40, proprietary (ANSI) | PURE (bearable kind of) [OOP](oop.md) language, pretty minimal |
| [C++](cpp.md) | no, bearable | 1982 | 1.18 (G)| 1.27 (G) | | | 500, proprietary | bastard child of C, only adds [bloat](bloat.md) ([OOP](oop.md)), "games"|
| [Ada](ada.md) | ??? | 1983 | | | | | | { No idea about this, sorry. ~drummyfish } |
| Object Pascal | no | 1986 | | | | | | Pascal with OOP (like what C++ is to C), i.e. only adds bloat |
| Objective-C | probably not | 1986 | | | | | | kind of C with Smalltalk-style "pure" objects? |
| [Oberon](oberon.md) | kind of? | 1987 | | | | | | simplicity as goal, part of project Oberon |
| [Perl](perl.md) | rather not | 1987 | 77 (G) | 8.64 (G) | | | | interpreted, focused on strings, has kinda cult following |
| [Bash](bash.md) | well | 1989 | | | | | | Unix scripting shell, very ugly syntax, not so elegant but bearable |
| [Haskell](haskell.md) | **kind of** | 1990 | 5.02 (G)| 8.71 (G) | | | 150, proprietary | [functional](functional.md), compiled, acceptable |
| [Python](python.md) | NO | 1991 | 45 (G) | 7.74 (G) | | | 200? (p. lang. ref.) | interpreted, huge bloat, slow, lightweight OOP, artificial obsolescence |
| POSIX [shell](shell.md) | well, "kind of" | 1992 | | | | 32 | 50, proprietary (paid) | standardized (std 1003.2-1992) Unix shell, commonly e.g. [Bash](bash.md)|
|[Brainfuck](brainfuck.md)| **yes** | 1993 | | | 100 (judg. by dbfi) | | 1 | extremely minimal (8 commands), hard to use, [esolang](esolang.md) |
| [FALSE](false.md) | **yes** | 1993 | | | | | 1 | very small yet powerful, Forth-like, similar to Brainfuck |
| [Lua](lua.md) | **quite yes** | 1993 | 91 (G) | 5.17 (G) | 7K (LuaInLua) | | 40, free | small, interpreted, mainly for scripting (used a lot in games) |
| [Java](java.md) | NO | 1995 | 2.75 (G)| 21.48 (G)| | | 800, proprietary | forced [OOP](oop.md), "platform independent" (bytecode), slow, bloat |
| [JavaScript](js.md) | NO | 1995 | 8.30 (G)| 105 (G) | 50K (est. from QuickJS) | 34 | 500, proprietary? | interpreted, the [web](web.md) lang., bloated, classless [OOP](oop.md) |
| [PHP](php.md) | no | 1995 | 23 (G) | 6.73 (G) | | | 120 (by Google), CC0 | server-side web lang., OOP |
| [Ruby](ruby.md) | no | 1995 | 122 (G) | 8.57 (G) | | | | similar to Python |
| [C#](c_sharp.md) | NO | 2000 | 4.04 (G)| 26 (G) | | | | proprietary (yes it is), extremely bad lang. owned by Micro$oft, AVOID |
| [D](d.md) | no | 2001 | | | | | | some expansion/rework of C++? OOP, generics etcetc. |
| [Rust](rust.md) | NO! lol | 2006 | 1.64 (G)| 3.33 (G) | | | 0 :D | extremely bad, slow, freedom issues, toxic community, no standard, AVOID|
| [Go](go.md) | **kind of** | 2009 | 4.71 (G)| 5.20 (G) | | | 130, proprietary? | "successor to C" but not well executed, bearable but rather avoid |
| [LIL](lil.md) | **yes** | 2010? | | | | | | not known too much but nice, "everything's a string" |
| [uxntal](uxn.md) | **yes** but SJW | 2021 | | | 400 (official) | | 2? (est.), proprietary | assembly lang. for a minimalist virtual machine, PROPRIETARY SPEC. |
| **[comun](comun.md)** | **yes** | 2022 | | | 4K | 76 | 2, CC0 | "official" [LRS](lrs.md) language, WIP, similar to Forth |
NOTE on performance data: the `speed`/`mem.` column says a benchmarked estimate running time/memory consumption of the best case (best compiler, best run, ...) relateive to C (i.e. "how many times the language is worse than C"). The data may come from various sources, for example the *[The Computer Language Benchmark Game](https://sschakraborty.github.io/benchmark/task-descriptions.html)* (G), own measurement (O) etc.
NOTES on the table above:
NOTE on implementation size: this is just very rough estimate based on the smallest implementation found, sometimes guessed and rounded to some near value (for example finding a small implementation whose main goal isn't small size we may conclude it could be written yet a bit smaller).
TODO: add "relative speed" column, make some kinda benchmark program and say how many times each languages is slower than C
- performance data: the `speed`/`mem.` column says a benchmarked estimate running time/memory consumption of the best case (best compiler, best run, ...) relateive to C (i.e. "how many times the language is worse than C"). The data may come from various sources, for example the *[The Computer Language Benchmark Game](https://sschakraborty.github.io/benchmark/task-descriptions.html)* (G), own measurement (O) etc.
- implementation size: this is just very rough estimate based on the smallest implementation found, sometimes guessed and rounded to some near value (for example finding a small implementation whose main goal isn't small size we may conclude it could be written yet a bit smaller).
- DT LOC is the number of [lines of code](loc.md) of our standardized [divisor tree](divisor_tree.md) program at the time of writing this
TODO: Tcl, Rebol

3460
random_page.md
View file

File diff suppressed because it is too large Load diff

2
wiki_pages.md
View file

File diff suppressed because one or more lines are too long

94
wiki_stats.md
View file

@ -3,9 +3,9 @@
This is an autogenerated article holding stats about this wiki.
- number of articles: 588
- number of commits: 857
- total size of all texts in bytes: 4173470
- total number of lines of article texts: 31398
- number of commits: 858
- total size of all texts in bytes: 4180781
- total number of lines of article texts: 31680
- number of script lines: 262
- occurences of the word "person": 7
- occurences of the word "nigger": 91
@ -21,8 +21,8 @@ longest articles:
- [chess](chess.md): 56K
- [faq](faq.md): 52K
- [number](number.md): 52K
- [programming_language](programming_language.md): 44K
- [c](c.md): 44K
- [programming_language](programming_language.md): 44K
- [3d_model](3d_model.md): 40K
- [bloat](bloat.md): 36K
- [woman](woman.md): 36K
@ -35,40 +35,40 @@ longest articles:
top 50 5+ letter words:
- which (2362)
- there (1819)
- people (1618)
- example (1384)
- other (1293)
- number (1146)
- which (2363)
- there (1820)
- people (1619)
- example (1387)
- other (1294)
- number (1165)
- software (1142)
- about (1120)
- program (929)
- about (1121)
- program (943)
- because (880)
- their (876)
- would (871)
- called (812)
- being (800)
- would (873)
- called (813)
- being (802)
- things (794)
- something (787)
- language (770)
- numbers (751)
- something (791)
- language (772)
- numbers (757)
- computer (750)
- simple (745)
- simple (746)
- without (704)
- programming (684)
- function (676)
- programming (686)
- function (683)
- these (675)
- different (656)
- however (648)
- system (616)
- world (613)
- should (601)
- should (602)
- doesn (594)
- point (584)
- games (578)
- society (573)
- while (560)
- society (574)
- while (563)
- drummyfish (548)
- though (543)
- simply (540)
@ -89,6 +89,26 @@ top 50 5+ letter words:
latest changes:
```
Date: Mon Aug 5 22:39:28 2024 +0200
ascii.md
c.md
censorship.md
comun.md
drummyfish.md
feminism.md
forth.md
island.md
javascript.md
kiss.md
main.md
pride.md
privacy.md
project.md
python.md
random_page.md
recursion.md
wiki_pages.md
wiki_stats.md
Date: Sun Aug 4 16:49:53 2024 +0200
3d_rendering.md
aliasing.md
@ -108,26 +128,6 @@ Date: Sun Aug 4 16:49:53 2024 +0200
newspeak.md
number.md
political_correctness.md
public_domain.md
random_page.md
stereotype.md
trolling.md
wiki_pages.md
wiki_stats.md
wiki_style.md
woman.md
work.md
Date: Thu Aug 1 02:31:53 2024 +0200
21st_century.md
3d_rendering.md
42.md
cancel_culture.md
doom.md
duke3d.md
faq.md
interpolation.md
jokes.md
main.md
```
most wanted pages:
@ -169,12 +169,12 @@ most popular and lonely pages:
- [minimalism](minimalism.md) (91)
- [gnu](gnu.md) (91)
- [linux](linux.md) (90)
- [censorship](censorship.md) (85)
- [programming](programming.md) (84)
- [fun](fun.md) (84)
- [censorship](censorship.md) (84)
- [free_culture](free_culture.md) (81)
- [less_retarded_society](less_retarded_society.md) (80)
- [fight_culture](fight_culture.md) (80)
- [less_retarded_society](less_retarded_society.md) (79)
- [math](math.md) (77)
- [hacking](hacking.md) (77)
- [bullshit](bullshit.md) (77)
@ -183,7 +183,7 @@ most popular and lonely pages:
- [art](art.md) (76)
- [foss](foss.md) (75)
- [programming_language](programming_language.md) (72)
- [corporation](corporation.md) (70)
- [corporation](corporation.md) (71)
- [chess](chess.md) (70)
- ...
- [anal_bead](anal_bead.md) (5)

2
woman.md
View file

@ -1,5 +1,7 @@
# <3 Woman <3
{ Hello, if you're offended scroll down, I actually apologize to some women at the end :D ~drummyfish }
A woman (also girl, gril, gurl, femoid, toilet, wimminz, the weaker sex, the dumber sex or succubus; [tranny](tranny.md) girl being called [t-girl](tgirl.md), troon, [trap](trap.md), [femboy](femboy.md), fake girl or [mtf](mtf.md)) is one of two genders ([sexes](sex.md)) of [humans](human.md), the other one being [man](man.md) -- traditionally woman is defined as that who was born with a vagina. Women are the weaker sex, they are [cute](cute.md) (sometimes) but notoriously bad at [programming](programming.md), [math](math.md) and [technology](technology.md): in the field they usually "work" on [bullshit](bullshit.md) (and mostly [harmful](harmful.md)) positions such as "diversity department", [marketing](marketing.md), "[HR](human_resources.md)", [UI](ui.md)/[user experience](ux.md), or as a [token](token.md) girl for media. If they get close to actual technology, their highest "skills" are mostly limited to casual "[coding](coding.md)" (which itself is a below-average form of [programming](programming.md)) in a baby language such as [Python](python.md), [Javascript](javascript.md) or [Rust](rust.md). Mostly they are just hired for quotas and make coffee for men who do the real work (until TV cameras appear). Don't let yourself be fooled by the propaganda, women have always been bad with tech. But indeed, very rarely a somewhat skilled woman may appear (we're not saying women can't be capable, just that they rarely are).
The symbol for woman is a circle with cross at its bottom ([Unicode](unicode.md) U+2640). Women mostly like pink [color](color.md) and similar colors like red and purple.