Update

bloat.md

@@ -114,6 +114,7 @@ Small/medium bloat includes for example:
 - [GNU](gnu.md) Unix utils (things like [busybox](busybox.md) or [sbase](sbase.md) are probably better)
 - [data types](data_type.md) (untyped or single type is better, everything can be just a [number](number.md))
 - [package managers](package_manager.md) (just don't use them, install just a few programs manually, or at least make package managers as simple as possible)
+- [electricity](electricity.md) ([mechanical](mechanical.md) computers may be just fine)
 - [computers](computer.md) (pen and paper or counting with [rocks](rock.md) is better)
 - anything [wireless](wireless.md) ([wifi](wifi.md), mice, ...)
 - ...
@@ -127,7 +128,7 @@ The concept of bloat can be applied even outside the computing world, e.g. to no
 - [cars](car.md)
 - using languages other than [English](english.md) or [Esperanto](esperanto.md)
 - luxury (big house, yacht with a swimming pool, ...)
-- [electricity](electricity.md)
+- having electricity at home
 - ...
 
 ## See Also

capitalism.md

@@ -65,6 +65,7 @@ The following is a list of just SOME attributes of capitalism -- note that not a
 - **loss of humanity**: In capitalism humans are just consumers, machines for production and "resources" -- corporations now routinely use these terms (*human resources department* etc.). People are brainwashed to no longer even see it as concerningto be called such terms. People's worth is only in how much they can work or consume.
 - **abuse of animals**: In capitalism animals are just products and resources, they are kept in very bad conditions just to be killed for meat or other purpose. They are slaughtered by millions just so we can overeat to morbid obesity. Maximizing profit dictates no money should be spent on animal comfort.
 - **[productivity cult](productivity_cult.md)**: People are brainwashed and forced into becoming robots whose sole purpose is to produce. Working overtimes, skipping lunch, minimizing sleep etc. has already become part of the work culture for example in USA and Japan.
+- **financial crises**: Crises are as regular and certain in capitalism as rain is in the nature, and possibly much more unpredictable; every crisis hurts everyone but the strongest corporations, whom it in turn makes stronger. People become poorer and great many small and mid-size businesses, i.e. potential competition to the big guys, either die to a bankrupt or are forced to let themselves be devoured by the big guys. This further accelerated the scissors effect, making poor poorer (i.e. better abusable) and rich richer. This is also yet another reason why the small "good guy"/"not only for profit" companies always lose, they simply refuse to steal the food of others to eat themselves obese before a famine and so they will die during the next famine or the next or the one after it. Only the bad guys survive many series of crises.
 - **everything is fake**: Everything is rotten and corrupted on the inside with an extreme effort towards putting up a misleading good looking facade. TV shows, including "news", are all staged (even those swearing not to be, no producer is going to invest money in something depending on pure luck), smiles and emotion of people you meet in workplace or see on ads, women's tits, butts and faces, men's muscles, photos on social media, food that has basically no food in it, even news and facts, everything is fake. Investigating any area (government, working conditions, technology, healthcare, education, charities, academia and "[science](soyence.md)", ...) a bit in depth practically always leads to unrevealing how corrupt it actually is despite it looking nice and ideal at the first look.
 - **loss of ownership**: Even that which is most saint to a capitalist -- property and the ability to own things -- is greatly lost under capitalism. This happens with the trend of everything becoming a service, a typical example of which is so called "[software as a service](saas.md)". While in the past one would buy a physical copy of a program that he would at least physically own forever, nowadays many programs become a subscription service, e.g. games, movies and music are no longer something you buy but just buy a one time ticket for. But this trend is everywhere, artificial obsolescence tries to limit durability of physical goods such electronic devices so that one has to keep consuming them like a service.
 - **[rape effect](rape_effect.md)**: The mechanisms of capitalism work in such ways that everyone gets progressively more raped with any further advance of capitalism.

how_to.md

@@ -145,6 +145,7 @@ This is a summary of some main guidelines on how an LRS supporter should behave
 - Similarly **avoid [toxic](toxic.md) communities**, don't argue, just leave, it's better to be alone than in bad company. Basically anything with a COC, language filter, SJW vibe, rainbow etc. isn't even more worth checking out.
 - **Be a [generalist](generalism.md), see the big picture, study the whole world**, do not become overspecialized in the capitalist way. Sure you may become an expert at something, but it shouldn't make your view of the world too narrow. You may spend most of your time studying and programming computer compilers for example, but still do (and enjoy) other things, for example reading fiction, studying religions, languages, psychology, playing [go](go.md), making music, building houses, painting, doing sports, ...
 - **Live your life as you want**, don't let someone else control your life and manipulate you, e.g. with feelings of guilt -- this often happens with your parents, partner, friends, culture, laws, ... This isn't an argument for self interest! On the contrary, most people nowadays will try to push you to following self interest or fascist goals that will also benefit them. You only have one life, others have theirs, so listen to advice but remember to always make your own decisions in important things. If you feel you don't want to go to school or that you don't want to work or that you want to do something that people despise or you want to do something that you've read is wrong, just do what you feel is best, even if it's a let down for your family or if it contradicts what the whole society is telling you.
+- **Publish everything immediately**, don't wait for your project "to be ready" for a release, make it public right now! You don't have to advertize it, just make it public. Some reasons are for example: you aren't behaving strategically like a capitalist, you get early feedback from others (important so you don't spend a lot of time on shit), you let others know what you're working on so they don't waste time working on the same thing, even an incomplete project may be useful to someone (parts of it may already be useful to someone), and also, very importantly, if you hesitate YOU WILL NEVER RELEASE THE PROJECT, you will become obsessed with perfectionism and ashamed to ever release the project. YES YOU WILL, I have seen it about 10000000 billion times. You think you will release it but you won't, every additional day you hesitate the chance of release decreases by 10%, so after 10 days it's already certain you will never release it, further on the chance even gets negative.
 - PRO TIP: **Get yourself [banned](ban.md) on toxic platforms** like [Wikipedia](wikipedia.md), [GitHub](github.md), [Steam](steam.md), [4chan](4chan.md) etcetc., it has many advantages -- you gain [freedom](freedom.md) (no longer having to care about platform you are banned on), the platform loses one user/slave (you), you stop being abused by the platform, it's also [fun](fun.md) (just find some creative way to get banned, possibly cause uprising on the platform, make mods angry and waste their time on cleaning up your mess), it will make you become more self sufficient and you help decentralize the Internet again (can't edit Wikipedia? Just make your own :-]), it will make you find better places, you may also help bring the toxic platform down (others will see the platform utilizes censorship, some may follow you in leaving...) etcetc.
 - ...
 

make_html.sh

@@ -12,16 +12,24 @@ cp report.html html
 
 DATE=`date +"%D"`
 FILECOUNT=`ls *.md | wc -l`
-FILELIST="filelist.html"
-HEADER="<html><head><link rel=\"stylesheet\" href=\"style.css\"><title>LRS Wiki</title></head><body><h1>less_retarded_wiki</h1><a href=\"main.html\">main page</a>, <a class=\"notdead\" href=\"$FILELIST\">file list ($FILECOUNT)</a>, <a class=\"notdead\" href=\"https://git.coom.tech/drummyfish/less_retarded_wiki/archive/master.zip\">source</a>, <a class=\"notdead\" href="report.html">report</a>, <a class=\"notdead\" href=\"wiki_stats.html\">stats</a>, wiki last updated on $DATE<hr />"
+FILELIST="wiki_pages"
+HEADER="<html><head><link rel=\"stylesheet\" href=\"style.css\"><title>LRS Wiki</title></head><body><h1>less_retarded_wiki</h1><a href=\"main.html\">main page</a>, <a class=\"notdead\" href=\"$FILELIST.html\">file list ($FILECOUNT)</a>, <a class=\"notdead\" href=\"https://git.coom.tech/drummyfish/less_retarded_wiki/archive/master.zip\">source</a>, <a class=\"notdead\" href=\"report.html\">report</a>, <a class=\"notdead\" href=\"wiki_stats.html\">stats</a>, wiki last updated on $DATE<hr />"
 FOOTER="<hr/><p>All content available under <a class=\"notdead\" href=\"https://creativecommons.org/publicdomain/zero/1.0/\">CC0 1.0</a> (public domain). Send comments and corrections to drummyfish at disroot dot org. </p></body></html>"
 
-echo "$HEADER <ul>" > html/$FILELIST
+printf "# Wiki Files\n\nThis is an autogenerated page listing all pages.\n\n" > $FILELIST.md
+
+firstFile=true
 
 for f in *.md; do
   fname=$(echo "$f" | sed "s/\.md//g")
 
-  echo "<li><a href="${fname}.html"> $fname </a></li>" >> html/$FILELIST
+  if [ "$firstFile" = true ] ; then
+    firstFile=false
+  else
+    printf " -- " >> $FILELIST.md
+  fi
+
+  printf "**[$fname]($f)** ($(cat $f | wc -l))" >> $FILELIST.md
 
   f2="html/${fname}.html"
 

mechanical.md

@@ -0,0 +1,145 @@
+# Mechanical Computer
+
+WORK IN PROGRESS
+
+Mechanical computer (simple ones also being called *mechanical [calculators](calculator.md)*) is a [computer](computer.md) that uses mechanical components (e.g. marbles, gears, strings, even fluids ...) to perform computation (both [digital](digital.md) and [analog](analog.md)). Not all non-[electronic](electronic.md) computers are mechanical, there are still other types too -- e.g. computers working with [light](light.md), biological, [quantum](quantum.md), [pen and paper](pen_and_paper.md) computers etc. Sometimes it's unclear what counts as a mechanical computer vs a mere calculator, an automaton or mere instrument -- here we will consider the term in a very wide sense. Mechanical computers used to be used in the [past](history.md), mainly before the development of [vacuum tubes](vacuum_tube.md) and [transistors](transistor.md) that opened the door for much more powerful computers. However some still exist today, though nowadays they are usually intended to be educational toys, they are of interest to many (including [us](lrs.md)) as they offer simplicity (independence of [electricity](electricity.md) and highly complex components such as transistors and microchips) and therefore [freedom](freedom.md). They may also offer help after the [collapse](collapse.md). While nowadays it is possible to build a simple electronic computer at home, it's only thanks to being able to buy highly complex parts at the store, i.e. still being dependent on [corporations](corporation.md); in a desert one can much more easily build a mechanical computer than electronic one. Mechanical computers are very cool.
+
+If mechanical computer also utilizes [electronic](electronics.md) parts, it is called an electro-mechanical computer; here we'll however be mainly discussing purely mechanical computers.
+
+**Disadvantages** of digital mechanical computers against electronic ones are great, they basically lose at everything except simplicity of implementation (in the desert). Mechanical computer is MUCH slower (speed will be measured in Hz), has MUCH less memory (mostly just a couple of [bits](bit.md) or [bytes](byte.md)), will be difficult to program ([machine code](machine_code.md) only), is MUCH bigger, limited by mechanical friction (so it will also be noisy), suffers from mechanical wear etc. Analog mechanical computers are maybe a bit better in comparison, but still lose to electronics big time. But remember, [less is more](less_is_more.md).
+
+Some notable mechanical computers include e.g. the 1882 [Difference Engine](difference_engine.md) by Charles Babbage (aka the first [programmer](programmer.md)), Antikythera mechanism (ancient Greek astronomical computer), the famous [Curta](curta.md) calculators (quality, powerful pocket-sized mid-20th century calculators) { These are really cool, check them out. ~drummyfish }, [Enigma](enigma.md) ciphering device (used in WWII), [abacus](abacus.md), [slide rule](slide_rule.md), Odhner Arithmometer (extremely popular Russian table calculator), [Digi-Comp](digi_comp.md) I (educational programmable 3 bit toy computer) or [Turing Tumble](turing_tumble.md) { Very KISS and elegant, also check out. ~drummyfish } (another educational computer, using marbles).
+
+Let's also take a look at how we can classify mechanical computers. Firstly they can be:
+
+- **special purpose**: Made to solve only limited set of problems, example being a mechanical calculator that can only perform a few operations like addition and subtraction. A special purpose computer may be easier to make as it doesn't have to bother with the flexibility needed for solving general problems.
+- **general purpose**: Full programmable [Turing complete](turing_complete.md) computer capable of solving very wide range of tasks efficiently. This is of course harder to make, so general purpose mechanical computers are rarer.
+
+Next we may divide mechanical computers to:
+
+- **[analog](analog.md)**: Working with analog data, i.e. continuous, infinitely precise values, typical examples are various integration machines. The analog approach is probably more natural and efficient in the mechanic world, so we encounter many of analog computers here (compared to the electronic world).
+- **[digital](digital.md)**: Working with discrete values, i.e. [whole numbers](integer.md), [bits](bit.md) etc.
+- **analog-digital**: Combination of both digital and analog, again this is more common in mechanic world than in electronic world.
+
+And to:
+
+- **autonomous**: Computers that only require to be started and then work completely on their own, without human intervention.
+- **semi-autonomous**: Computers largely working on their own but still requiring some human assistance during computation, for example rotating some lever to keep the parts moving.
+- **computation helpers**: Tools that only aid the man who is doing most of the computation -- typical examples are [abacus](abacus.md), [slide rule](slide_rule.md) or [integraph](integraph.md).
+
+## Basics
+
+**Analog** computers are usually special purpose. { At least I haven't ever heard about any general purpose analog computer, not even sure if that could work. ~drummyfish } Very often they just solve some specific equation needed e.g. for computing ballistic curves, they may perform [Fourier transform](fourier_transform.md) etc. Especially useful are computers performing [integration](integration.md) and solving [differential equations](differential_equation.md) as computing many practically encountered equations is often very hard or impossible -- mechanical machines can integrate quite well, e.g. using the famous ball and disk integrator.
+
+As mere [programmers](programming.md) let us focus more on **digital** computers now.
+
+When building a digital computer from scratch we usually start by designing basic [logic gates](logic_gate.md) such as AND, NOT and OR -- here we implement the gates using mechanical principles rather than transistors or relays. For simple special-purpose calculators combining these logic gates together may be enough (also note we don't HAVE TO use logic gates, some mechanisms can directly perform arithmetic etc.), however for a highly programmable general purpose computer **logic gates alone practically won't suffice** -- in theory when we have finite memory ([in real world](irl.md) always), we can always just use only logic gates to perform any computation, but as the memory grows, the number of logic gates we would need would grow exponentially, so we don't do this. Instead we will need to additionally implement some **sequential processing**, i.e. something like a [CPU](cpu.md) that performs steps according to program instructions.
+
+Now we have to choose our model of computation and general architecture, we have possibly a number of options. Mainly we may be deciding between having a separate storage for data and program (Harvard architecture) or having the program and data in the same memory (intending for the computer to "reshape" this initial program data into the program's output). Here there are paths to explore, the most natural one is probably trying to imitate a **[Turing machine](turing_machine.md)**, probably the simplest "intuitive" computer, but we can even speculate about e.g. some kind of rewriting system imitating formal [grammars](grammar.md), [cellular automata](cellular_automaton.md) etc. Turing machine seems to be the friendliest (both for construction and programming -- try to program something useful in [rule 110](rule110.md)...), most natural way, so that might be the best first choice.
+
+Turing machine has a separate memory for program and data. To build it we need two main parts: memory tape (an array of [bits](bit.md)) and control unit (table of states and their transitions). We can potentially design these parts separately and let them communicate via some simple interface, which simplifies things. The specific details of the construction will now depend on what components we use (gears, marbles, dominoes, levers, ...)...
+
+## Concepts
+
+Here we will overview some common concepts and methods used in mechanical computers. Remember the concepts may, and often are, **combined**. Also note that making a mechanical computer will be a lot about mechanical engineering, so great many concepts from it will appear -- we can't recount all of them here, we'll just focus on the most important concepts connected to the computing part.
+
+### Gears/Wheels
+
+Gears (wheels with teeth) are a super simple mechanism popular in mechanical computers. Note that **gears may be both digital and analog** -- whether they're one or the other depends on our interpretation (if we assign importance to every arbitrary orientation or just a finite number of orientations that click the tooth into some box).
+
+The **advantages** of gears are for example instant transfer of motion -- even if we have many wheels in sequence, rotating the first one instantly (practically) rotates the last one as well. Among **disadvantages** on the other hand may be the burden of friction (having too many gears in a row will require a lot of power for rotation and strong fixation of the gears) and also manufacturing a non-small number of good, quality gears may be more difficult than alternatives (marbles, ...).
+
+Besides others gears/wheels can be used to:
+
+- **Transmit power**, i.e. delivering motion to components that need motion to work (even in computers that don't use gears themselves as computing components).
+- **Do [arithmetic](arithmetic.md)**: for example a differential can be used to instantly add two numbers (or actually to compute any linear combination, e.g. average, ... using the [slide rule](slide_rule.md) concept we can probably even implement multiplication, division etc.).
+- **Represent a general digital value** by how they are currently rotated, i.e. a gear with *N* teeth -- each one labeled with a value -- can hold one of *N* values depending on which of the values is currently under some pointer -- this is often used in mechanical calculators e.g. to display computed values. This has the advantage of being able to represent a digital number with one relatively simple part (the wheel) without having to encode multiple bits (i.e. many smaller parts). This may also be used to make a **[look up table](lut.md)** -- imagine e.g. a wheel which by rotating looks up some value that may be represented e.g. by displacement (imagine spinning spiral) or holes on the wheel. If the gear represents a natural number, it naturally implements [modulo](mod.md) increment/decrement (highest value will overflow to lowest and vice versa).
+- **Represent one [bit](bit.md)** by turning either clockwise or counterclockwise.
+- Possibly represent values also in other ways, for example by speed of rotation, rotation vs stillness, position (gear traveling on some toothed slider, ...) etcetc.
+- ...
+
+```
+       1         1
+  __  ,-,  ___  ,-,  _______
+ |   { o }     { o }   ,-,  |
+ |    '-',    ,-,'-'  { o } |
+ |    _|||___{ o }_____;-;  |
+ |            '-'.-.  { o } |
+ |_____________ { o } _'-'__|   
+                 '-' 
+                  1
+                   
+                   
+       0         1
+  __  ,-,  ___  ,-,  ______
+ |   { o }     { o }-,     |
+ |   ,'-' ,-,   '-{ o }    |
+ |  _|||_{ o }_____;-;     |
+ |        '-'  .-.{ o }    |
+ |___________ { o }'-'_____|   
+               '-' 
+                0
+```
+
+*NXOR (equality) gate implemented with gears (counterclockwise/clockwise rotation mean 1/0); the bottom gear rotates counterclockwise only if the both input gears rotate in the same direction.*
+
+### Marbles/Balls
+
+Using marbles (and possibly also similar rolling shapes, e.g. cylinders, disks, ...) for computation is **one of the simplest** and most [KISS](kiss.md) methods for mechanical computers and may therefore be considered very worthy of our attention -- it's much easier to build a "marble maze" than to build a geared machine (even gears themselves aren't that easy to make).
+
+**Basic principle** is that of a marble performing computation by going through a maze -- while a single marble can be used to evaluate some simple [logic circuit](logic_circuit.md), usually (see e.g. [Turing Tumble](turing_tumble.md)) the design uses many marbles and performs sequential computation, i.e. there is typically a **bucket** of marbles placed on a high place from which we release one marble which (normally by relying on [gravity](gravity.md)) goes through the maze and performs one computation cycle (switches state, potentially flips a memory bit etc.) and then, at the bottom (end of its path), presses a switch to release the next marble from the top bucket. So the computation is autonomous, it consumes marbles from the top bucket and fills the bottom bucket (with few marbles available an operator may sometimes need to refill the top bucket from the bottom one). The maze is usually an angled board onto which we just place obstacles; multiple layers of boards with holes/tunnels connecting them may be employed to allow more complexity.
+
+NOTE: Balls may be used to perform computation also in other ways than described here, very notable is e.g. the **[billiard ball computer](billiard_ball_computer.md)** (which also has a great advantage of performing reversible computation). However here we will focus on the traditional "marble maze" approach.
+
+The **disadvantage** here is that the computation is **slow** as to perform one cycle a marble has to travel some path (which may take many seconds, i.e. in the simple form you get a "CPU" with some fractional frequency, e.g. 1/5 Hz). This can potentially be improved a little, e.g. by [pipelining](pipeline.md) (releaseing the next marble as soon as possible, even before the current one finishes the whole path) and [parallelism](parallelism.md) (releasing multiple marbles, each one doing some part of work in parallel with others). **Advantages** on the other hand include mentioned simplicity of construction, visual clarity (we can often make the computer as a flat 2D board that can easily be observed, debugged etc.) and potentially good extensibility -- making the pipeline (maze) longer, e.g. to add more bits or functionality, is always possible without being limited e.g. by friction like with gears (though usually for the cost of speed).
+
+Some things that can be done with marbles include:
+
+- **Flipping/setting bits**: A marble running through some specific part of the maze can flip something over, which we may interpret as flipping a bit. A simple rotating "T" shape can be used to make a one bit [flip-flop](flip-flop.md) (see below).
+- **Branching**: If/else/switch branching can be implemented simply as a marble taking one road or another on a crossroad, which can be decided by some moving part connected to some bit elsewhere.
+- **Rotating gears**: A marble may rotate a gear by precise number of teeth, this can be used e.g. to implement a shift on memory tape (see pictures below).
+- **Weight/count representing a value**: instead of encoding a number with flippable bits we may instead use a small bucket into which marbles fall -- the number of marbles in the bucket then encode the number stored. We may e.g. introduce a limit number (`if x > N`), i.e. weight at which the bucket becomes heavier than a counterweight and opens some new path for the marbles.
+- ...
+
+```
+     :
+ #   o   #     #       #     #       #     #       #
+ ##     ##     ##     ##     ##     ##     ##     ##
+ ###   ###     ### : ###     ###   ###     ###   ###
+ #  \ /  #     #  \o/  #     #  \ /  #     #  \ /  #
+ #   O   #     #   O   #     #  oO   #     #   O   #
+ #   #\  #     #   #\  #     #  /#   #     #  /#   #
+ #   #   #     #   #   #     #   #   #     # : #   #
+ #   #   #     #   #   #     #   #   #     # o #   #
+   0   1         0   1         0   1         0   1
+```
+
+*Marble falling into a [flip-flop](flip_flop.md) will test its value (fall out either from the 0 or 1 hole) and also flip the bit -- next marble will fall out from the other hole.*
+
+```
+\:  marble slide
+ \o
+  \           hole      sliding plane
+=============----===============VVVVVVVVVVV====  <----->
+  |    |    |    |    |    |       -''-
+  | b0 | b1 | b2 | b3 | b4 |      { () } 
+  |    |    |    |    |    |       '--' gear
+             bits
+```
+
+*Above a gear is used to select which hole an incoming marble will fall into (each hole may contain e.g. a flip-flop bit shown above). This may potentially be used to e.g. implement random access memory.*
+
+### Fluids
+
+Whether the use of fluids/gases (water, air, steam, maybe even sand, ...) is still considered mechanical computing may be debatable, but let's take a look at it anyway.
+
+- **Power**: flowing fluid (steam, water stream, falling sand, ...) can be the source of movement in the mechanism.
+- **[Hydraulics](hydraulic.md) can easily transmit movement**: fluid in a tube under pressure can transfer movement on a long distance and can be curved in any way, this may be much simpler way of transferring movement than e.g. a sequence of many gears.
+- **[Logic](logic.md)**: fluids can also implement logic gates, see [fluidics](fluidics.md).
+- **Weight/volume can have significance**: similarly to marbles, the amount of water in a bucket may record a value, we may employ weights, overflows etc. to incorporate this into computations.
+- **[Electronics](electronics.md) emulation**: it's known many electronic concepts can be imagined with water pipes instead that deal with similar concepts (pressure ~= voltage, flow ~= current, resistor ~= narrower pipe, ...). By this we may possibly emulate very simple electronics without actual electricity.
+- ...
+
+### Other
+
+Don't forget there exist many other possible components and concepts a mechanical computer can internally use. Teethed **cylinders/disks** may be used to record plots of data over time or to store and deliver read/only data (e.g. the program instructions) easily, see music boxes and gramophones; **[punch card](punch_card.md)** have widely been used for storing read-only data too. Sometimes deformed cylinders were used as an analog **2D [look up table](lut.md)** for some mathematical [function](function.md) -- imagine e.g. a device that has input *x* (rotating cylinder along its axis) and *y* (shifting it left/right); the cylinder can then at each surface point record function *f(x,y)* by its width which will in turn displace some stick that will mark the function value on a scale. To transfer movement **strings, chains and belts** may also be used. [Random number generation](rng.md) may be implemented e.g. with [Galton board](galton_board.md). Some mechanical computers even use pretty complex parts such as mechanical arms, but these are firstly hard to make and secondly prone to breaking, so try to avoid complexity as much as possible.

wiki_stats.md

@@ -2,8 +2,8 @@
 
 This is an auto-generated article holding stats about this wiki.
 
-- number of articles: 536
-- total size of all texts in bytes: 2700870
+- number of articles: 538
+- total size of all texts in bytes: 2739611
 
 longest articles:
 
@@ -23,6 +23,9 @@ longest articles:
 latest changes:
 
 ```
+Date:   Wed Jan 10 15:57:16 2024 +0100
+left_right.md
+wiki_stats.md
 Date:   Wed Jan 10 14:44:40 2024 +0100
 bit_hack.md
 bloat.md
@@ -43,9 +46,6 @@ rock.md
 slowly_boiling_the_frog.md
 Date:   Sun Jan 7 03:16:15 2024 +0100
 how_to.md
-wiki_stats.md
-Date:   Sun Jan 7 02:43:35 2024 +0100
-bloat.md
 ```
 
 most wanted pages:
@@ -68,8 +68,8 @@ pointer.md
 html.md
 embedded.md
 cryptography.md
+cpu.md
+turing_complete.md
 sdl.md
-pascal.md
-opengl.md
 ```