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-02-03 22:30:33 +01:00
parent a9b582054b
commit 16fc4bbb12
12 changed files with 128 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
bloat.md
View file

@ -133,6 +133,7 @@ The concept of bloat can be applied even outside the computing world, e.g. to no
## See Also
- [harmful](harmful.md)
- [maximalism](maximalism.md)
- [obscurity](obscurity.md)
- [shit](shit.md)

27
cc0.md
View file

@ -2,29 +2,12 @@
CC0 is a [waiver](waiver.md) (similar to a [license](license.md)) of [copyright](copyright.md), created by [Creative Commons](creative_commons.md), that can be used to dedicate one's work to the [public domain](public_domain.md) (kind of).
Unlike a license, a waiver such as this *removes* (at least effectively) the author's copyright; by using CC0 the author willingly gives up his own copyright so that the work will no longer be owned by anyone (while a license preserves the author's copyright while granting some rights to other people). It's therefore the most [free](free_software.md) and [permissive](permissive.md) option for releasing intellectual works. CC0 is designed in a pretty sophisticated way, it also waives "neighboring rights" ([moral rights](moral_rights.md)), and also contains a fallback license in case waiving copyright isn't possible in a certain country. For this CC0 is one of the best ways, if not the best, of truly and completely dedicating works to public domain world-wide (well, at least in terms of copyright). In this world of extremely fucked up [intellectual property](intellectual_property.md) laws it is not enough to state "my work is public domain" -- you need to use something like CC0 to achieve legally valid public domain status.
Unlike a license, a waiver such as this *removes* (at least effectively) the author's copyright; by using CC0 the author willingly gives up his own copyright so that the work will no longer be owned by anyone (while a license preserves the author's copyright while granting some rights to other people). It's therefore the most [free](free_software.md) and [permissive](permissive.md) option for releasing intellectual works. CC0 is designed in a pretty sophisticated way, it also waives "neighboring rights" (e.g. [moral rights](moral_rights.md); waving these rights is why we prefer CC0 over other waivers such as [unlicense](unlicense.md)), and also contains a fallback license in case waiving copyright isn't possible in a certain country. For this CC0 is one of the best ways, if not the best, of truly and completely dedicating works to public domain world-wide (well, at least in terms of copyright). In this world of extremely fucked up [intellectual property](intellectual_property.md) laws it is not enough to state "my work is public domain" -- you need to use something like CC0 to achieve legally valid public domain status.
WATCH OUT: **don't confuse CC0 with Creative Commons Public Domain Mark** (apart from name the symbols are also a bit similar), the latter is not a license or waiver, just a tag, i.e. CC0 is used to release something to the public domain, while PD mark is used to mark that something is already in the public domain (mostly due to being old).
CC0 is recommended by [LRS](lrs.md) for both programs and other art -- however for programs additional waivers of [patents](patent.md) should be added as CC0 doesn't deal with patents. CC0 is endorsed by the [FSF](fsf.md) but not [OSI](osi.md) (who rejected it because it explicitly states that trademarks and patents are NOT waived).
## Things Under CC0
It's nice that CC0 became quite widely used and you can find a lot of material under this waiver, but **BEWARE**, if you find something under CC0, do verify it's actually valid, normies often don't know what CC0 means and happily post derivative works of proprietary stuff under CC0.
Here are some things and places with CC0 materials that you can use in your projects so that you can release them under CC0 as well. **BEWARE**: if you find something under CC0, do verify it's actually valid, normies often don't know what CC0 means and happily post derivative works of proprietary stuff under CC0.
TODO
- software:
- much of [LRS](lrs.md) sofware: [Anarch](anarch.md), [small3dlib](small3dlib.md), [raycastlib](raycastlib.md), [SAF](saf.md), [comun](comun.md), ...
- [Dusk OS](duskos.md)
- ...
- other assets:
- many things on [Wikimedia Commons](wikimedia_commons.md)
- many things on opengameart
- many things on BlendSwap
- all of [drummyfish's](drummyfish.md) stuff including fonts, textures, 3D models etc.
- [librivox](librivox.md) creates CC0 audiobooks from old books
- ...
- text:
- [Esolang Wiki](esolang.md)
- OSdev Wiki [since 2011](https://wiki.osdev.org/OSDev_Wiki:Copyrights)
- [Encyclopedia Dramatica](dramatica.md)
- ...
Some **things under CC0** include Librivox audiobooks, [Dusk OS](duskos.md), great many things on [Wikimedia Commons](wikimedia_commons.md), opengameart, Blendswap and freesound, whole [Esolang Wiki](esolang.md), OSdev Wiki (since 2011), [Encyclopedia Dramatica](dramatica.md), [LRS](lrs.md) software ([Anarch](anarch.md), [small3dlib](small3dlib.md), [raycastlib](raycastlib.md), [SAF](saf.md), [comun](comun.md)), Lix (libre game) and many others.

3
cpu.md
View file

@ -76,8 +76,9 @@ TODO: add more, mark CPUs with ME, add features like MMX, FPU, ...
| RAD750 |2001 | 32 | PowerPC | 10 M | 150 nm | 200 M | 360 | 1 | 64 K cache | radiation hard., space (Curiosity, ...) |
| AMD Opteron |2003 | 64 | x86 (x86-64) | 105 M | 130 nm | 1.6 G | 940 | 1 | ~1 M cache | 1st 64 bit x86 CPU |
| Intel Pentium D 820 |2005 | 64 | x86 (x86-64) | 230 M | 90 nm | 2.8 G | 775 | 2 | ~2 M cache | 1st desktop multi core CPU |
| Intel Core i5-2500K |2011 | 64 | x86 (x86-64) | 1 B | 32 nm | 3.3 G | | 4 | ~6 M cache | |
| Intel Core i5-2500K |2011 | 64 | x86 (x86-64) | 1 B | 32 nm | 3.3 G | | 4 | ~6 M cache, ME | |
| PicoRV32 |2015?| 32 |RISC-V (RV32IMC)| | | ~700 M | | | | simple, free hardware RISV-V core |
| Apple A9 |2015 | 64 | ARM (ARMv8) | 2 B | 14 nm | 1.8 G | | 2 | ~7 M cache | iPhones |
|AMD Ryzen Threadrip. PRO 5995WX|2022 | 64 | x86 (x86-64) | 33 B | 7 nm | 4.5 G | 4094 | 64 | ~300 M cache, ME | high end bloat |
| [Talos ES](talos_es.md) |2023 | 8 | own (RISC) | | | | | | | simple but usable DIY free hardware CPU |

81
debugging.md Normal file
View file

@ -0,0 +1,81 @@
# Debugging
WORK IN PROGRESS
Debugging is a term usually related to [computer](computer.md) technology (but sometimes also extended beyond it) where it stands for the practice of actively searching for [bugs](bug.md) (errors, design flaws, defects, ...) and fixing them; most typically it happens in software [programming](programming.md), but we may also talk about debugging [hardware](hardware.md) etc. Debugging is notoriously tedious and stressful, it can even take majority of the programmer's time and some bugs are extremely hard to track down, however systematic approaches can be applied to basically always succeed in fixing any bug.
Fun fact: the term *debugging* allegedly comes from the old times when it meant LITERALLY getting rid of bugs that broke computers by getting stuck in the relays.
**Spare yourself debugging by testing as you go** -- while programming it's best to at least quickly test the program is working after each small step change you make. Actually you should be writing **[automatic tests](automatic_test.md)** along with your main program that quickly tests that all you've programmed so far still works (see also [regression](regression.md)). This way you discover a bug early and you know it's in the part you just changed so you find it and fix it quickly. If you don't do this and just write the whole program before even running it, your program will just crash and you won't have a clue why -- at this point you most likely have SEVERAL bugs working together and so even finding one or two of them will still leave your program crashing -- this situation is so shitty that the time you saved earlier won't nearly be worth it.
## Debugging Software
Debugging programs mostly happens in these steps:
1. **Discovering bug**: you notice a bug, this usually happens during [testing](testing.md) but of course can also just happen during normal use etc.
2. **Reproducing it**: reproducing the bug is extremely important -- actually you probably can't move on without it. Reproducing means finding an exact way to make the bug happen, e.g. "click this button while holding down this key" etc.
3. **Locating it**: now as you have a crashing program, you examine it and find WHY exactly it crashes, which line of code causes the crash etc.
4. **Fixing it**: now as you know why and where the bug exists, you just make it go away. Sometimes a [hotfix](hotfix.md) is quickly applied before implementing a proper fix.
The following are some of the most common methods used to debug software, roughly in order by which one typically applies them in practice.
### Testing
[Testing](testing.md) is an area of itself, it's the main method of finding bugs. There are many kind of testing like manual testing (just playing around with the program), [automatic testing](automatic_testing.md) (automatized testing by a program), security/penetration testing, stress testing, whitebox/blackbox testing, unit testing, code reviews and whatnot. **[Formal verification](verification.md)** is similar to testing that can reveal further bugs, but it's more difficult to do.
### Eyeballing
Quick way to spot small bugs is obviously to just look at the code, however this really works for the small, extremely obvious bugs like writing `=` instead of `==` etc.
### Manual Execution
In this method you try to go through the program yourself step by step, just as the computer would. By this you will find out just WHY and WHERE your program gets to a wrong result or to a line that makes it crash.
### Printing
Using print statements is extremely popular and efficient method of locating bugs; the idea is to use the language's print functions to [log](log.md) what's happening. By this you can e.g. find where exactly (which line of source code) your program crashes, you simply insert `printf("asdf\n");` somewhere and keep moving this print statement and re running the program until the text stops showing up on the screen - then you know the program crashes before it reached the print. Note that you can use the principle of [binary search](binary_search.md) (also known as *wolf fence algorithm*) to move the print in the code so that you find the crash place relatively quickly. Besides this prints can of course also show you e.g. values in variables so you can e.g. check WHERE EXACTLY the value changes to a wrong value and so on.
The advantage of this is that you don't need any extra debugger, the method works basically everywhere and is actually very effective, it may be all you will need in 99% of cases. { TBH I don't even regularly use debugger, debugging with prints just works for me. ~drummyfish }
**IMPORTANT NOTE** especially for [C](c.md) programmers: output is usually line buffered, so in each print you HAVE TO add a newline (`\n`) at the end to make it print immediately. If you don't do this, it may happen that the print will be executed but the output will stay waiting in the output buffer as the program crashes so it won't show up on your screen. Similarly in other languages you may want to call some [flush](flush.md) function etc.
Sometimes a bug can be super nasty and make the program crash always in random places, even depending e.g. on where you put the print statement, even if the print statement shouldn't really have an effect on the rest of the program. When you spot something like this, you probably have some super nasty bug related to undefined behavior or optimization, try to mess with optimization flags, use static analyzers, reduce your program to a minimum program that still bugs etc. This may take some time.
### Rubber Duck
Rubber duck debugging works like this: you try to explain your code to someone -- even someone who doesn't understand programming, for example rubber duck -- and in doing this you often spot some error in reasoning. Explaining code to a programmer may have a further advantage as he may ask you clever questions.
### Reducing Your Program To Minimum
When dealing with a super nasty bug in a complex program that's dodging solutions by the simpler methods, it is useful to just copy your program elsewhere and there strip down everything off of it while still keeping the bug in place. I.e. you just keep deleting functions and all the program does while making sure the bug you're after is still happening. This will firstly eliminate places where you have to look for the bug but mainly will usually lead you to reducing the program to just a few lines of code that behave extremely weirdly, like a function whose behavior depends on where you put a print statement of if you use a wider data type etc. Then you usually find the problematic line or whatever it is that's causing the bug and once you know the line, you can look at it really carefully, google the behavior of each operator etc. to really find the bug.
### Debuggers And Other Debugging Tools Like Profilers
There exist many software tools specialized for just helping with debugging (there are even physical hardware debuggers etc.), they are either separate software (good) or integrated as part of some development environment (bad by [Unix philosophy](unix_philosophy.md)) such as an [IDE](ide.md), web browser etc. Nowadays a compiler itself will typically do some basic checks and give you warning about many things, but oftentimes you have to turn them on (check man pages of your compiler).
The most typical debugging tool is a **[debugger](debugger.md)**, a program that lets you to play around with the program as it's running, it typically allows doing things like like:
- Step through the program line-by-line (typically there is are two options: step by lines and step by functions), sometimes even backwards in time.
- Run the program and pause it exactly where you need ([breakpoints](breakpoint.md)).
- Inspect values in RAM, CPU registers etc.
- Modify values in RAM, registers etc.
- Modify code on-the-fly.
- Assert if certain conditions hold.
- Link lines of [assembly](assembly.md) to lines in original source code.
- Warn about suspicious things.
- ...
Furthermore there many are other useful tools such as:
- **dynamic program analyzer**: A tool that will watch your program running and check for things like [memory leaks](memory_leak.md), access of unallocated memory, suspicious behavior, unsafe behavior, call of obsolete functions and many others. The most famous such tool is probably **[valgrind](valgrind.md)**, it's a good habit to just use valgrind from time to time to check our program.
- **[profiler](profiling.md)**: A kind of dynamic analyzer that focuses on statistical measuring of resource usage of your program, typically execution times of different functions, memory consumption or network usage. Basically it will watch your program run and then draw you graphs of which parts of your programs consume most resources. This usually helps [optimization](optimization.md) but can also serve to find bugs (you can spot where your memory starts leaking etc.). Some basic profiling can be done even without profiler, just inside your own program, but it can get tricky. One famous profiler is e.g. [gprof](gprof.md).
- **static source code analyzer**: Static analyzers look at the source code (or potentially even compiled binary) and try to find bugs/inefficiencies in it without running it, just by reasoning. Static analyzers often tell you about [undefined behavior](undefined_behavior.md), potential overflows, unused code, unreachable branches, unsatisfiable conditions, confusing formatting and so on. This complement the dynamic analysis. Some tools to do this are e.g. [cppcheck](cppcheck.md) and [splint](splint.md), though thanks to compilers performing a lot of static analysis themselves these seem not as widely used as dynamic analyzers nowadays.
- **[hex editor](hex_editor.md)**: Tool allowing you to mess with binary files, useful for any program that works with binary files.
- **[emulators](emulator.md), [virtual machines](vm.md), ...**: Running your program on different platform often reveals bugs -- while your program may [work perfectly fine](works_on_my_machine.md) on your computer, it may start crashing on another because that computer may have different integer size, [endianness](byte_sex.md), amount of RAM, timings, file system etcetc. Emulators and VMs allow you to test exactly this AND furthermore often allow easy inspection of the emulated machine's memory and so on.
- ...
### Shotgun Debugging
This is kind of an improper YOLO way of trying to fix bugs, you just change a lot of stuff in your program in hopes a bug will go away, it rarely works, doesn't really get rid of the bug (just of its manifestation at best) and can at best perhaps be a simple [hotfix](hotfix.md). Remember **if you don't understand how you fixed a bug, you didn't actually fix it**.
TODO: mini gdb tutorial

4
free_hardware.md
View file

@ -21,10 +21,12 @@ The following is a list of hardware whose design is **at least to some degree**
The following is a list of some "freedom friendly" hardware, i.e. hardware that though partly or fully proprietary is not or can be made non-malicious to the user (has documented behavior, allows fully free software, librebooting, battery replacement, repairs etc.):
- **[Agon](agon.md)**: Simple game console.
- **[Ben NanoNote](ben_nanonote.md)**: tiny [GNU](gnu.md)/[Linux](linux.md) laptop whose design is free, however it utilizes e.g. a proprietary CPU.
- **[DragonBox Pyra](pyra.md)**: Upcoming small handheld computer running [GNU](gnu.md)/[Linux](linux.md) that *almost* meets the RYF criteria, schematics will be available, GPU drivers are sadly proprietary. Successor to OpenPandora.
- **[Librem 5](librem5.md)**: WARNING, this device has been criticized a lot. It's an "open"/privacy-friendly smartphone with free-licensed design running [GNU](gnu.md)/[Linux](linux.md), however it uses proprietary firmware (loaded from secondary CPU to sneakily comply with RYF) and the functionality is, according to reviews, horrible.
- **[MNT Reform](mnt_reform.md)**: "Open hardware" (free-licensed design but using proprietary components) laptop with [NXP](nxp.md) [ARM](arm.md) CPU and [Vivante](vivante.md) GPU that can run with free drivers, has no camera or microphone. Pretty expensive.
- **[Talos ES](talos_es.md)**: Very simple usable [CPU](cpu.md) that can be made at home.
- **Old [Thinkpad](thinkpad.md) laptops**: Old thinkpads such as [X200](x200.md), [T400](t400.md) and [T500](t500.md) are construction-wise superior to maybe any other laptop ever made, however despite being proprietary they are compatible with [libreboot](libreboot.md) and can be purchased with [Intel ME](intel_me.md) CPU backdoor disabled, offering complete control over the device, plus they can be bought relatively cheap. Very popular, some even certified ["Respects Your Freedom"](ryf.md) by the [FSF](fsf.md).
- **[OLinuXino](olinuxino.md)**: TODO
- **[OpenPandora](openpandora.md)**: Game console/tiny computer.
@ -34,6 +36,7 @@ The following is a list of some "freedom friendly" hardware, i.e. hardware that
- **[Pinephone](pinephone.md)**: Another "free/open" smartphone running GNU/Linux, probably better than Librem5, also uses some proprietary firmware (e.g. for Wifi), design is only source-available.
- **[Ringo MakerPhone](ringo.md)**: Educational Arduino dumbphone running on free software, by [Circuitmess](circuitmess.md). { I own one, is a bit buggy but [works](just_werks.md) for calls and messages. ~drummyfish }
- **[Ronja](ronja.md)**: Device for optical communication using ethernet protocol.
- **[Uzebox](uzebox.md)**: Very simple TV [game](game.md) [console](open_console.md).
- ...
The following is a list of [firmware](firmware.md), [operating systems](os.md) and software tools that can be used to liberate freedom-friendly proprietary devices:
@ -43,7 +46,6 @@ The following is a list of [firmware](firmware.md), [operating systems](os.md) a
- **[PostmarketOS](postmarketos.md)**: Mobile [GNU](gnu.md)/[Linux](linux.md) distribution that can be used to liberate smartphones.
- **[Replicant](replicant.md)**: Fork of [Android](android.md) mobile OS that replaces proprietary components with free software, can be used to liberate smartphones, though it is still [bloat](bloat.md).
- **[Rockbox](rockbox.md)**: Free firmware for digital audio players allowing replacement of the proprietary firmware and even improving on functionality and [GUI](gui.md).
- **[Uzebox](uzebox.md)**: Very simple TV [game](game.md) [console](open_console.md).
- ...
## See Also

1
jokes.md
View file

@ -42,6 +42,7 @@ Also remember the worst thing you can do to a joke is put a [disclaimer](disclai
- `int randomInt(void) { int x; return x; }`
- Boss: "We're going to need to store additional information about gender of all 1600 people in our database." Me: "OK that's only 200 extra bytes.". Diversity department: "You're fired."
- the [downto](downto.md) operator
- I just had sex with a German chick, for some reason she kept yelling her age. (Or maybe she just didn't consent.)
- I find it much more pleasant to browse the web on a 1 bit display, it can't display a [rainbow](lgbt.md).
- Why are [noobs](noob.md) the most pacifist beings in existence? Because they never beat anyone.
- There's a new version of Debian Bull's Eye that's compiled exclusively with [Rust](rust.md). Its code name is [Bull's Shit](bullshit.md).

5
open_console.md
View file

@ -50,8 +50,9 @@ Some notable open consoles (which fit the definition at least loosely) are liste
|[GB META](gamebuino.md) |32b 48 MHz | 32 | 256 | 168x120 |A + -, SD |
|[Nibble](nibble.md) |32b 160 MHz| 80 | 4000 | 128x128 |A, AAA bat. |
|[UzeBox](uzebox.md) |8b 20 MHz | 4 | 64 | 360x240 |C, + |
|[Tiny Arcade](tiny_arcade.md)| | | | | |
|[Thumby](thumby.md) | | | | | |
|[Tiny Arcade](tiny_arcade.md)|32b | | | |A |
|[Thumby](thumby.md) |32b 133 MHz| 264 | 2000 | 72x40 |RPI (RP2040) |
|[Agon](agon.md) |8b 18 MHz | 512 | | 640x480 | |
TODO: Retro Game Tiny, Adafruit PyGamer, ... see also https://github.com/ESPboy-edu/awesome-indie-handhelds

9
privacy.md
View file

@ -6,14 +6,17 @@ Digital privacy is the ability of someone to hide "sensitive" [information](info
{ I have my personal data publicly online and under CC0 for anyone to download and do anything with, including my real name, date of birth, medical info and even nude photos. Literally nothing bad ever happened due to this. ~drummyfish }
Digital privacy can be further categorized. We can talk e.g. about **communication privacy** (emails, chat, ...), **data privacy** (cookies, tracking, medical data, ...), **personal privacy** (intimate photos, sexual orientation, ... ), **individual privacy** (identifying information, anonymity, [spam](spam.md), ...) etc. Privacy is also closely related to **[cryptography](cryptography.md)**, as [encryption](encryption.md) is how information can be "protected" against reaching unauthorized entities, and to [free software](free_software.md), as using safe tools with available source code is crucial to avoid malware. Still, to achieve high privacy additional appropriate behavior has to be adopted, e.g. protection against [spyware](spyware.md), using proxies and/or onion routing, turning off browser [cookies](cookie.md), avoiding fingerprinting, avoiding [social networks](social_network.md), avoiding revealing potentially identifying information etc.
**Society is becoming more and more obsessed with privacy and that is EXTREMELY BAD.** It leads to hardcore [censorship](censorship.md), people are hiding their email addresses so it's impossible to contact them, photos of child faces are wiped from the Internet, more and more videos on the internet now just blur everything in the video that's not the main focus of it, "just in case", people are even afraid to credit other people by name even if they are e.g. legally obliged to by a license such as CC-BY-SA ([lmao](lmao.md) https://forum.freegamedev.net/viewtopic.php?f=7&t=19322). Such [retardedness](retard.md) has probably never been seen yet.
**How to 100% solve privacy**: make it moral to make ALL information public, always, without any censorship, "protection", laws and other bullshit. { NO, it's fucking NOT a joke or "satire", I am 100% serious. More like 3000% actually. It's extremely smart, that's why people don't do it. ~drummyfish } This way passwords will become obsolete, which has a nice side effect of also ending a lot of capitalist bullshit such as banking and [intellectual property](intellectual_property.md), people will have to start sharing. Governments and corporations will also start taking extreme advantage of the situation, so people will stop using online technology as much and maybe they'll even finally decide to ditch governments and corporations, another great leap in development of society. People will also stop being concerned about their "private data" -- at first they will be freaking out that everyone can see their dick pics and what porn they jerk off to but since EVERYONE's data will be visible, they will find out that everyone watches weird porn, that everyone has a dick (well, about half of population), and they'll just stop acting like chimps in a while. This literally only has advantages and it solves many of our greatest issues all at once. At this point privacy has been solved. { Leave the Nobel Prize at my door, thanks. ~drummyfish }
{ I'm thinking of a life experiment: start living without a password. In it I would literally make my password public on my website and start to somehow live like that, i.e. I would stop using a bank account, I would stop using social media accounts, would just host my own git repository and email. That doesn't even sound so difficult, I'll probably give it a try one day. ~drummyfish }
**As of 2023 privacy is impossible to achieve** unless you live in wilderness completely independently of the main "civilization". If you use any kind of computer (laptop, TV, phone, car, camera etc.), you are already being watched: basically all [CPU](cpu.md)s have proven hardware spyware in them capable of bypassing encryption, see [Intel ME](intel_me.md) etc., no matter what operating system you use, and even if you use some obscure CPU without it, you are watched through your Internet activity (even if you use a "secure" browser, which you most likely don't even if you think you do), your browsing habits are watched and analyzed by highly advanced [AI](ai.md) that can track you even without cookies etc., e.g. just from your writing style, patterns of repeated daily activity, mouse movement signature etc. -- all small fragments of information about your activity such as those mentioned above and your locations over time (known from your phone connecting to towers, someone else's phone detecting your voice, street or car camera detecting your face, credit card payments etc.) are connected with other fragments of information (even those of other people) and AI makes a complete picture of your life available to those who need it. You may think you're doing everything right and that they can't find you, but it's enough if e.g. someone from your family posted a picture with you on facebook 10 years ago or if you as a child played online games -- this is enough to know which people you are related to and them being tracked then leads to you also being tracked to a big degree despite you using 7 proxies and living underground. If the government furthermore decides to watch you more (which may happen just because you e.g. try to "protect" your privacy more and start using [Tor](tor.md), which is suspicious), they can just watch you in real time through satellites (even inside buildings) and so on. So you just have to accept you are being watched, and unless we end [capitalism](capitalism.md), it will only be getting worse (mind reading technology is already emerging).
We have to state that **privacy concerns are a symptom of [bad society](capitalism.md). We shouldn't ultimately try to protect privacy more (cure symptoms) but rather make a [society where need for privacy isn't an issue](less_retarded_society.md) (cure the root cause).** This sentiment is shared by many hackers, even [Richard Stallman](rms.md) himself used to revolt against passwords when he was at MIT AI Labs; he intentionally used just the password "rms" to allow other people to use his account (this is mentioned in the book *Free As In Freedom*). Efforts towards increasing and protecting privacy is in its essence an unnecessary [bullshit](bullshit.md) effort wasting human work, similarly to [law](law.md), [marketing](marketing.md) etc. It is all about censorship and secrecy. Besides this, **all effort towards protecting digital privacy will eventually fail**, thanks to e.g. advanced [AI](ai.md) that will identify individuals by pattern in their behavior, even if their explicit identity information is hidden perfectly. Things such as browser [fingerprinting](fingerprint.md) are already a standard and simple practice allowing highly successful uncovering of identity of anonymous people online, and research AI is taking this to the next level (e.g. the paper *Detecting Individual Decision-Making Style: Exploring Behavioral Stylometry in Chess* shows revealing [chess](chess.md) players by their play style). With [internet of stinks](iot.md), cameras, microphones and smartphones everywhere, advanced AI will be able to identify and track an individual basically anywhere no matter the privacy precautions taken. Curing the root cause is the only option to prevent a catastrophic scenario.
By this viewpoint, [LRS](lrs.md)'s stance towards privacy differs from that of many (if not most) [free software](free_software.md), [hacker](hacker.md) and [suckless](suckless.md) communities: to us **privacy is a form of [censorship](censorhip.md)** and as such is seen as inherently bad. We dream of a world without abuse where (digital) privacy is not needed because society has adopted our philosophy of information freedom, non-violence and non-competition and there is no threat of sensitive information abuse. Unlike some other people (so called pragmatics), not only do we dream of it, we actively try to make it a reality. Even though we know the ideally working society is unreachable, we try to at least get close to it by restricting ourselves to bare minimum privacy (so we are very open but won't e.g. publish our passwords). We believe that abuse of sensitive information is an issue of the basic principles of our society (e.g. [capitalism](capitalism.md)) and should be addressed by fixing these issues rather than by harmful methods such as censorship.
Digital privacy can be further categorized. We can talk e.g. about **communication privacy** (emails, chat, ...), **data privacy** (cookies, tracking, medical data, ...), **personal privacy** (intimate photos, sexual orientation, ... ), **individual privacy** (identifying information, anonymity, [spam](spam.md), ...) etc.
Privacy is closely related to [cryptography](cryptography.md), as encryption is how information can be "protected" against reaching unauthorized entities, and to [free software](free_software.md), as using safe tools with available source code is crucial to avoid malware. Still, to achieve high privacy additional appropriate behavior has to be adopted, e.g. protection against [spyware](spyware.md), using proxies and/or onion routing, turning off browser [cookies](cookie.md), avoiding fingerprinting, avoiding [social networks](social_network.md), avoiding revealing potentially identifying information etc.

4
programming_tips.md
View file

@ -2,9 +2,9 @@
This is a place for sharing some practical programming tips.
- **Add by small steps**: When adding features/functionality etc. into your code, do it by very small steps and test after each step. Do NOT add multiple things at once. If you add 3 features at once and then find out the program doesn't work, you will have an extremely hard time finding out the bug because it may be in feature 1, feature 2, feature 3 or ANY COMBINATION of them, so you may very well never find the bug. If you instead test after adding each step, you find potential bugs immediately which will make fixing them very quick and easy.
- **Add by small steps**, spare yourself [debugging](debugging.md) hell later: when adding features/functionality etc. into your code, do it by very small steps and test after each step. Do NOT add multiple things at once. If you add 3 features at once and then find out the program doesn't work, you will have an extremely hard time finding out the bug because it may be in feature 1, feature 2, feature 3 or ANY COMBINATION of them, so you may very well never find the bug. If you instead test after adding each step, you find potential bugs immediately which will make fixing them very quick and easy.
- **Program on a weak computer** or alternatively use some utility such as [cpulimit](cpulimit.md) to make your hardware weaker, this will help you make your program efficient (and learn [how to do it](optimization.md)), any inefficiency will be immediately apparent as your program will simply run slow or swap. Using a physically weak computer is best as it is limited in all aspects so it will also help you make the program easy to develop on such computer etc., small [embedded](embedded.md) devices such as [open consoles](open_console.md) are ideal.
- **No indentation for temporary code**: Tiny "workflow" tip: when adding new code, keep it unindented so that you know it's the newly added code and can delete it at any time. Only when you test the added code, indent it correctly to incorporate it as the final code. Of course, this fails in languages where indentation matters ([Python](python.md) cough cough) but similar effects can be achieved e.g. by adding many empty lines in front of/after the temporary code.
- **Program on a weak computer**, this will "force" you to make your program efficient (and learn [how to do it](optimization.md)), any inefficiency will be immediately apparent as your program will simply run slow or swap. Small [embedded](embedded.md) devices such as [open consoles](open_console.md) are ideal.
- **[Comments](comment.md)/[preprocessor](preprocessor.md) to quickly hide code**: It is a basic trick to comment out lines of code we want to temporarily disable. However preprocessor may work even better, e.g. in C if you want to be switching between two parts of code, instead of constantly commenting one part and uncommenting the other just use `#if 0` and `#else` directives around the two parts. You can switch between them by just changing 0 to 1 and back. This can also disable parts of code that already contain multiline comments (unlike a comment as nested multiline comments aren't allowed).
- **[KEEP IT SIMPLE](kiss.md)** and keep it [LRS](lrs.md), do not blindly follow mainstream ways and "workflows" as those are more often than not horrible. For example instead of using some uber bug tracker, you should use a simple plaintext TODO.txt file; instead of using and IDE use [vim](vim.md) or something similar. Stay away from [OOP](oop.md), [dependencies](dependency.md) etc.
- **Don't listen to advice of anyone who does programming for living**, he's most definitely accustomed to the worst ways of programming and will try to push you to [OOP](oop.md), [bloat](bloat.md), [proprietary](proprietary.md) tech, [tranny software](tranny_software.md), [GitHub](github.md) etc. Listening to advice of such people is like taking advice on whether to take drugs from a drug dealer.

2
usenet.md
View file

@ -16,7 +16,7 @@ Usenet was the pre-[web](www.md) web, kind of like an 80s [reddit](reddit.md) wh
## Where To Freely Browse Usenet
Search for Usenet archives, I've found some sites dedicated to this, also [Internet archive](internet_archive.md) has some newsgroups archived. [Google](google.md) has Usenet archives on a website called "Google groups" (now sadly requires login). There is a nice archive at https://www.usenetarchives.com. Possibly guys from Archive Team can help (https://wiki.archiveteam.org/index.php/Usenet, https://archive.org/details/usenet, ...). See also http://www.eternal-september.org. There is an archive from 1981 accessible through [gopher](gopher.md) at gopher://gopher.quux.org/1/Archives/usenet-a-news. Also https://yarchive.net/.
Search for Usenet archives, I've found some sites dedicated to this, also [Internet archive](internet_archive.md) has some newsgroups archived. [Google](google.md) has Usenet archives on a website called "Google groups" (now sadly requires login). There is a nice archive at https://www.usenetarchives.com. Possibly guys from Archive Team can help (https://wiki.archiveteam.org/index.php/Usenet, https://archive.org/details/usenet, ...). See also http://www.eternal-september.org. There is an archive from 1981 accessible through [gopher](gopher.md) at gopher://gopher.quux.org/1/Archives/usenet-a-news. Also https://yarchive.net/. Also search for *Henry Spencer's UTZOO NetNews Archive*.
{ Also here's some stuff https://old.reddit.com/r/usenet/wiki/index. ~drummyfish }

2
wiki_pages.md
View file

File diff suppressed because one or more lines are too long

30
wiki_stats.md
View file

@ -3,8 +3,8 @@
This is an autogenerated article holding stats about this wiki.
- number of articles: 545
- number of commits: 675
- total size of all texts in bytes: 2832550
- number of commits: 676
- total size of all texts in bytes: 2832657
longest articles:
@ -24,6 +24,26 @@ longest articles:
latest changes:
```
Date: Fri Feb 2 08:28:14 2024 +0100
ancap.md
cat_v.md
copyleft.md
cpu.md
drummyfish.md
fascism.md
float.md
forth.md
hero_culture.md
jokes.md
liberalism.md
libertarianism.md
often_confused.md
people.md
security.md
suckless.md
turing_machine.md
wiki_pages.md
wiki_stats.md
Date: Wed Jan 31 00:35:22 2024 +0100
trolling.md
wiki_pages.md
@ -32,12 +52,6 @@ Date: Tue Jan 30 22:35:23 2024 +0100
cpu.md
wiki_pages.md
wiki_stats.md
Date: Tue Jan 30 19:43:23 2024 +0100
fascism.md
wiki_pages.md
wiki_stats.md
Date: Tue Jan 30 09:10:10 2024 +0100
Date: Tue Jan 30 07:54:47 2024 +0100
```
most wanted pages: